| // 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. |
| |
| //! A basic Logical Interface (LIF) Manager. |
| |
| // TODO(dpradilla): remove when done. |
| #![allow(dead_code)] |
| |
| use crate::portmgr::PortId; |
| use crate::{error, ElementId, Version, UUID}; |
| use fidl_fuchsia_net_stack::InterfaceAddress; |
| use fidl_fuchsia_router_config; |
| use std::collections::{HashMap, HashSet}; |
| use std::net::IpAddr; |
| |
| /// `LIFType` denotes the supported types of Logical Interfaces. |
| #[derive(Eq, PartialEq, Debug, Copy, Clone)] |
| pub enum LIFType { |
| INVALID, |
| WAN, |
| LAN, |
| ACCESS, |
| TRUNK, |
| GRE, |
| } |
| |
| /// `LIF` implements a logical interface object. |
| #[derive(Eq, PartialEq, Debug, Clone)] |
| pub struct LIF { |
| id: ElementId, |
| l_type: LIFType, |
| name: String, |
| // pid is the id of the port associated with the LIF. |
| // In case of a LIF associated to a bridge, it is the id of the bridge port. |
| // In the case of a LIF associated to a single port, it's the id of that port. |
| pid: PortId, |
| // ports is the list of ports that are associated to the LIF. |
| // In the case of a bridge these are all the ports that belong ot the bridge. |
| ports: HashSet<PortId>, |
| // vlan id of the bridge. |
| vlan: u16, |
| properties: LIFProperties, |
| } |
| |
| impl LIF { |
| pub fn new( |
| v: Version, |
| l_type: LIFType, |
| name: &str, |
| pid: PortId, |
| port_list: Vec<PortId>, |
| vlan: u16, |
| properties: Option<LIFProperties>, |
| ) -> error::Result<Self> { |
| match l_type { |
| LIFType::WAN => { |
| if port_list.len() != 1 { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidNumberOfPorts)); |
| } |
| } |
| LIFType::LAN => { |
| if port_list.len() < 1 { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidNumberOfPorts)); |
| } |
| } |
| _ => return Err(error::NetworkManager::LIF(error::Lif::TypeNotSupported)), |
| }; |
| let ports: HashSet<PortId> = port_list.iter().cloned().collect(); |
| let id = ElementId::new(v); |
| Ok(LIF { |
| id, |
| l_type, |
| name: name.to_string(), |
| pid, |
| ports, |
| vlan, |
| properties: match properties { |
| None => LIFProperties { enabled: true, ..Default::default() }, |
| Some(p) => p, |
| }, |
| }) |
| } |
| |
| fn add_port(&mut self, v: Version, p: PortId) -> error::Result<()> { |
| self.id.version = v; |
| self.ports.insert(p); |
| Ok(()) |
| } |
| |
| pub fn ports(&self) -> impl ExactSizeIterator<Item = PortId> + '_ { |
| self.ports.iter().map(|p| p.clone()) |
| } |
| |
| fn remove_port(&mut self, v: Version, p: PortId) -> error::Result<()> { |
| match self.l_type { |
| LIFType::LAN => { |
| if self.ports.len() <= 1 { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidNumberOfPorts)); |
| } |
| } |
| LIFType::WAN => { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidNumberOfPorts)) |
| } |
| _ => return Err(error::NetworkManager::LIF(error::Lif::TypeNotSupported)), |
| } |
| if !self.ports.contains(&p) { |
| return Ok(()); |
| } |
| self.id.version = v; |
| self.ports.remove(&p); |
| Ok(()) |
| } |
| fn set_vlan(&mut self, _v: Version, _vlan: u16) -> error::Result<()> { |
| Err(error::NetworkManager::LIF(error::Lif::NotSupported)) |
| } |
| pub fn set_properties(&mut self, v: Version, p: LIFProperties) -> error::Result<()> { |
| self.id.version = v; |
| self.properties = p; |
| Ok(()) |
| } |
| |
| fn rename(&mut self, v: Version, name: &'static str) -> error::Result<()> { |
| self.id.version = v; |
| self.name = name.to_string(); |
| Ok(()) |
| } |
| // id returns the LIF ElementID. |
| pub fn id(&self) -> ElementId { |
| self.id |
| } |
| |
| // set_pid sets the Lif pid. |
| pub fn set_pid(&mut self, pid: PortId) { |
| self.pid = pid; |
| } |
| |
| // pid returns the Lif pid. |
| pub fn pid(&self) -> PortId { |
| self.pid |
| } |
| |
| pub fn properties(&self) -> &LIFProperties { |
| &self.properties |
| } |
| |
| pub fn to_fidl_lif(&self) -> fidl_fuchsia_router_config::Lif { |
| let ps: Vec<_> = self.ports.iter().map(|p| p.to_u32()).collect(); |
| let lt; |
| let p; |
| match self.l_type { |
| LIFType::WAN => { |
| lt = fidl_fuchsia_router_config::LifType::Wan; |
| p = Some(self.properties.to_fidl_wan()); |
| } |
| LIFType::LAN => { |
| lt = fidl_fuchsia_router_config::LifType::Lan; |
| p = Some(self.properties.to_fidl_lan()); |
| } |
| _ => { |
| lt = fidl_fuchsia_router_config::LifType::Invalid; |
| p = None; |
| } |
| }; |
| fidl_fuchsia_router_config::Lif { |
| element: Some(fidl_fuchsia_router_config::Id { |
| uuid: self.id.uuid.to_ne_bytes(), |
| version: self.id.version, |
| }), |
| type_: Some(lt), |
| name: Some(self.name.clone()), |
| port_ids: Some(ps), |
| vlan: Some(self.vlan), |
| properties: p, |
| } |
| } |
| } |
| |
| // TODO(dpradilla): Move lines 175-205 to line 34 so things are defined in the proper order. |
| #[derive(Eq, PartialEq, Debug, Clone)] |
| // LifIpAddr is an IP address and its prefix. |
| pub struct LifIpAddr { |
| pub address: IpAddr, |
| pub prefix: u8, |
| } |
| |
| impl From<&InterfaceAddress> for LifIpAddr { |
| fn from(addr: &InterfaceAddress) -> Self { |
| LifIpAddr { |
| address: match addr.ip_address { |
| fidl_fuchsia_net::IpAddress::Ipv4(fidl_fuchsia_net::Ipv4Address { addr }) => { |
| IpAddr::from(addr) |
| } |
| fidl_fuchsia_net::IpAddress::Ipv6(fidl_fuchsia_net::Ipv6Address { addr }) => { |
| IpAddr::from(addr) |
| } |
| }, |
| prefix: addr.prefix_len, |
| } |
| } |
| } |
| |
| impl From<&fidl_fuchsia_router_config::CidrAddress> for LifIpAddr { |
| fn from(a: &fidl_fuchsia_router_config::CidrAddress) -> Self { |
| match a.address { |
| Some(fidl_fuchsia_net::IpAddress::Ipv4(fidl_fuchsia_net::Ipv4Address { addr })) => { |
| LifIpAddr { address: IpAddr::from(addr), prefix: a.prefix_length.unwrap() } |
| } |
| Some(fidl_fuchsia_net::IpAddress::Ipv6(fidl_fuchsia_net::Ipv6Address { addr })) => { |
| LifIpAddr { address: IpAddr::from(addr), prefix: a.prefix_length.unwrap() } |
| } |
| None => LifIpAddr { address: IpAddr::from([0, 0, 0, 0]), prefix: 0 }, |
| } |
| } |
| } |
| |
| impl LifIpAddr { |
| pub fn to_fidl_address_and_prefix(&self) -> fidl_fuchsia_router_config::CidrAddress { |
| match self.address { |
| IpAddr::V4(a) => fidl_fuchsia_router_config::CidrAddress { |
| address: Some(fidl_fuchsia_net::IpAddress::Ipv4(fidl_fuchsia_net::Ipv4Address { |
| addr: a.octets(), |
| })), |
| prefix_length: Some(self.prefix), |
| }, |
| IpAddr::V6(a) => fidl_fuchsia_router_config::CidrAddress { |
| address: Some(fidl_fuchsia_net::IpAddress::Ipv6(fidl_fuchsia_net::Ipv6Address { |
| addr: a.octets(), |
| })), |
| prefix_length: Some(self.prefix), |
| }, |
| } |
| } |
| pub fn to_fidl_subnet(&self) -> fidl_fuchsia_net::Subnet { |
| match self.address { |
| IpAddr::V4(a) => fidl_fuchsia_net::Subnet { |
| addr: fidl_fuchsia_net::IpAddress::Ipv4(fidl_fuchsia_net::Ipv4Address { |
| addr: (u32::from_be_bytes(a.octets()) >> (32 - self.prefix) |
| << (32 - self.prefix)) |
| .to_be_bytes(), |
| }), |
| prefix_len: self.prefix, |
| }, |
| IpAddr::V6(a) => fidl_fuchsia_net::Subnet { |
| addr: fidl_fuchsia_net::IpAddress::Ipv6(fidl_fuchsia_net::Ipv6Address { |
| addr: (u128::from_be_bytes(a.octets()) >> (128 - self.prefix) |
| << (128 - self.prefix)) |
| .to_be_bytes(), |
| }), |
| prefix_len: self.prefix, |
| }, |
| } |
| } |
| pub fn to_fidl_interface_address(&self) -> fidl_fuchsia_net_stack::InterfaceAddress { |
| match self.address { |
| IpAddr::V4(a) => fidl_fuchsia_net_stack::InterfaceAddress { |
| ip_address: fidl_fuchsia_net::IpAddress::Ipv4(fidl_fuchsia_net::Ipv4Address { |
| addr: a.octets(), |
| }), |
| prefix_len: self.prefix, |
| }, |
| IpAddr::V6(a) => fidl_fuchsia_net_stack::InterfaceAddress { |
| ip_address: fidl_fuchsia_net::IpAddress::Ipv6(fidl_fuchsia_net::Ipv6Address { |
| addr: a.octets(), |
| }), |
| prefix_len: self.prefix, |
| }, |
| } |
| } |
| } |
| |
| #[derive(Eq, PartialEq, Debug, Clone, Default)] |
| pub struct LIFProperties { |
| pub dhcp: bool, |
| pub address: Option<LifIpAddr>, |
| pub enabled: bool, |
| } |
| |
| impl LIFProperties { |
| pub fn to_fidl_wan(&self) -> fidl_fuchsia_router_config::LifProperties { |
| fidl_fuchsia_router_config::LifProperties::Wan(fidl_fuchsia_router_config::WanProperties { |
| address_method: Some(if self.dhcp { |
| fidl_fuchsia_router_config::WanAddressMethod::Automatic |
| } else { |
| fidl_fuchsia_router_config::WanAddressMethod::Manual |
| }), |
| address_v4: self.address.as_ref().map(|x| x.to_fidl_address_and_prefix()), |
| gateway_v4: None, |
| address_v6: None, |
| gateway_v6: None, |
| enable: Some(self.enabled), |
| metric: None, |
| mtu: None, |
| hostname: None, |
| clone_mac: None, |
| connection_parameters: None, |
| connection_type: Some(fidl_fuchsia_router_config::WanConnection::Direct), |
| connection_v6_mode: Some( |
| fidl_fuchsia_router_config::WanIpV6ConnectionMode::Passthrough, |
| ), |
| }) |
| } |
| pub fn to_fidl_lan(&self) -> fidl_fuchsia_router_config::LifProperties { |
| fidl_fuchsia_router_config::LifProperties::Lan(fidl_fuchsia_router_config::LanProperties { |
| address_v4: self.address.as_ref().map(|x| x.to_fidl_address_and_prefix()), |
| address_v6: None, |
| enable: Some(self.enabled), |
| dhcp_config: None, |
| enable_dhcp_server: Some(false), |
| enable_dns_forwarder: Some(false), |
| }) |
| } |
| } |
| |
| /// `LIFManager` keeps track of Logical interfaces. |
| pub struct LIFManager { |
| lifs: HashMap<UUID, LIF>, |
| lif_names: HashSet<String>, |
| lif_vlans: HashSet<u16>, |
| } |
| |
| impl LIFManager { |
| //! Create a new LIF database. |
| pub fn new() -> Self { |
| LIFManager { lifs: HashMap::new(), lif_names: HashSet::new(), lif_vlans: HashSet::new() } |
| } |
| /// `add_lif` adds a lif to be managed by network manager. |
| /// It verifies LIF is valid and does not colide with an exisiting one. |
| pub fn add_lif(&mut self, l: &LIF) -> error::Result<()> { |
| if self.lifs.contains_key(&l.id.uuid) { |
| return Err(error::NetworkManager::LIF(error::Lif::DuplicateLIF)); |
| } |
| if self.lif_names.contains(&l.name) { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidName)); |
| } |
| if l.vlan != 0 && self.lif_vlans.contains(&l.vlan) { |
| return Err(error::NetworkManager::LIF(error::Lif::InvalidVlan)); |
| } |
| // TODO(dpradilla): Verify ports not in use by other lif and ports actually exist. |
| // This will change if switch trunk ports are supported, in that case, a trunk port can be |
| // part of multiple LANs as long as its different vlans. |
| |
| self.lif_names.insert(l.name.clone()); |
| self.lif_vlans.insert(l.vlan); |
| self.lifs.insert(l.id.uuid, l.clone()); |
| Ok(()) |
| } |
| /// `remove_lif` removes a lif from lif manager. |
| pub fn remove_lif(&mut self, id: UUID) -> Option<LIF> { |
| let l = self.lifs.remove(&id)?; |
| self.lif_vlans.remove(&l.vlan); |
| self.lif_names.remove(&l.name); |
| Some(l) |
| } |
| |
| /// `lif` gets a reference to a lif in lif manager. |
| pub fn lif(&self, id: &UUID) -> Option<&LIF> { |
| self.lifs.get(id) |
| } |
| |
| /// `lif_mut` gets a mutable reference to a lif in lif manager. |
| pub fn lif_mut(&mut self, id: &UUID) -> Option<&mut LIF> { |
| self.lifs.get_mut(id) |
| } |
| |
| /// `lifs` gets all LIFs of a given type. |
| pub fn lifs(&self, lt: LIFType) -> impl Iterator<Item = &LIF> { |
| self.lifs.iter().filter_map(move |(_, l)| if l.l_type == lt { Some(l) } else { None }) |
| } |
| |
| /// `all_lifs` gets all LIFs. |
| pub fn all_lifs(&self) -> impl Iterator<Item = &LIF> { |
| self.lifs.iter().map(|(_, l)| l) |
| } |
| |
| pub fn update_lif_at_port(&mut self, port: u64, properties: LIFProperties) { |
| if let Some((_, lif)) = self.lifs.iter_mut().find(|(_, lif)| lif.pid.to_u64() == port) { |
| let dhcp = lif.properties.dhcp; |
| lif.properties = properties; |
| lif.properties.dhcp = dhcp; |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| #![allow(unused)] |
| use super::*; |
| use crate::portmgr::{Port, PortManager}; |
| use fidl_fuchsia_net::Ipv4Address; |
| |
| fn create_ports() -> PortManager { |
| let mut pm = PortManager::new(); |
| pm.add_port(Port::new(PortId::from(1), "port1", 1)); |
| pm.add_port(Port::new(PortId::from(2), "port2", 1)); |
| pm.add_port(Port::new(PortId::from(3), "port3", 1)); |
| pm.add_port(Port::new(PortId::from(4), "port4", 1)); |
| pm |
| } |
| |
| #[test] |
| fn test_new_lif() { |
| let pm = create_ports(); |
| let d = LIF::new(3, LIFType::WAN, "name", PortId::from(0), vec![PortId::from(3)], 0, None); |
| assert!(d.is_ok()); |
| let d = LIF::new(3, LIFType::LAN, "name", PortId::from(0), vec![PortId::from(1)], 0, None); |
| assert!(d.is_ok()); |
| let d = LIF::new( |
| 3, |
| LIFType::LAN, |
| "name", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ); |
| assert!(d.is_ok()); |
| } |
| #[test] |
| fn test_new_lif_wrong_number_ports() { |
| let pm = create_ports(); |
| let d = LIF::new(3, LIFType::GRE, "name", PortId::from(0), Vec::new(), 0, None); |
| assert!(d.is_err()); |
| let d = LIF::new(3, LIFType::WAN, "name", PortId::from(0), Vec::new(), 0, None); |
| assert!(d.is_err()); |
| let d = LIF::new( |
| 3, |
| LIFType::WAN, |
| "name", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ); |
| assert!(d.is_err()); |
| let d = LIF::new(3, LIFType::WAN, "name", PortId::from(0), vec![], 0, None); |
| assert!(d.is_err()); |
| let d = LIF::new(3, LIFType::LAN, "name", PortId::from(0), Vec::new(), 0, None); |
| assert!(d.is_err()); |
| let d = LIF::new(3, LIFType::LAN, "name", PortId::from(0), vec![], 0, None); |
| assert!(d.is_err()); |
| } |
| #[test] |
| fn test_new_lif_inexisting_port() { |
| let pm = create_ports(); |
| let d = LIF::new(3, LIFType::WAN, "name", PortId::from(0), vec![PortId::from(5)], 0, None); |
| assert!(d.is_ok()); |
| let d = LIF::new( |
| 3, |
| LIFType::LAN, |
| "name", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(6)], |
| 0, |
| None, |
| ); |
| assert!(d.is_ok()); |
| } |
| #[test] |
| fn test_new_lif_reusing_port() { |
| let pm = create_ports(); |
| let d = LIF::new(3, LIFType::WAN, "name", PortId::from(0), vec![PortId::from(1)], 0, None); |
| assert!(d.is_ok()); |
| let d = LIF::new( |
| 3, |
| LIFType::LAN, |
| "name", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ); |
| assert!(d.is_ok()); |
| } |
| |
| #[test] |
| fn test_lif_manager_new() { |
| let lm = LIFManager::new(); |
| assert_eq!(lm.lifs.len(), 0); |
| } |
| |
| #[test] |
| fn test_lif_manager_add() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| lm.add_lif( |
| &LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| assert_eq!(lm.lifs.len(), 3); |
| } |
| // TODO(dpradilla): verify a port cant be part of multiple LIFs except for trunk switchport ports |
| |
| #[test] |
| fn test_lif_manager_add_existing() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| lm.add_lif(&l); |
| assert_eq!(lm.lifs.len(), 1); |
| } |
| |
| #[test] |
| fn test_lif_manager_add_same_name() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new(3, LIFType::LAN, "lan1", PortId::from(0), vec![PortId::from(1)], 0, None) |
| .unwrap(); |
| lm.add_lif(&l); |
| let l = LIF::new(4, LIFType::LAN, "lan1", PortId::from(0), vec![PortId::from(2)], 0, None) |
| .unwrap(); |
| lm.add_lif(&l); |
| assert_eq!(lm.lifs.len(), 1); |
| } |
| |
| #[test] |
| #[ignore] // TODO(dpradilla): enable test once LIF actually checks for this. |
| fn test_lif_manager_add_same_port() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan2", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| assert_eq!(lm.lifs.len(), 1); |
| } |
| |
| #[test] |
| fn test_lif_manager_get_existing() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| let got = lm.lif(&l.id.uuid); |
| assert_eq!(got, Some(&l)) |
| } |
| |
| #[test] |
| fn test_lif_manager_get_inexisting() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| let got = lm.lif(&9); |
| assert_eq!(got, None) |
| } |
| |
| #[test] |
| fn test_lif_manager_remove_existing() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| assert_eq!(lm.lifs.len(), 3); |
| let got = lm.remove_lif(l.id.uuid); |
| assert_eq!(lm.lifs.len(), 2); |
| assert_eq!(got, Some(l)) |
| } |
| |
| #[test] |
| fn test_lif_manager_reuse_name_and_port_after_remove() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let l = LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(); |
| lm.add_lif(&l); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| assert_eq!(lm.lifs.len(), 3); |
| let got = lm.remove_lif(l.id.uuid); |
| assert_eq!(lm.lifs.len(), 2); |
| assert_eq!(got, Some(l)); |
| lm.add_lif( |
| &LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(), |
| ); |
| assert_eq!(lm.lifs.len(), 3) |
| } |
| |
| #[test] |
| fn test_lif_manager_remove_inexisting() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| lm.add_lif( |
| &LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(0), |
| vec![PortId::from(1), PortId::from(2)], |
| 0, |
| None, |
| ) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::LAN, "lan2", PortId::from(0), vec![PortId::from(3)], 0, None) |
| .unwrap(), |
| ); |
| lm.add_lif( |
| &LIF::new(3, LIFType::WAN, "wan", PortId::from(0), vec![PortId::from(4)], 0, None) |
| .unwrap(), |
| ); |
| assert_eq!(lm.lifs.len(), 3); |
| let got = lm.remove_lif(5 as UUID); |
| assert_eq!(lm.lifs.len(), 3); |
| assert_eq!(got, None); |
| } |
| |
| #[test] |
| fn test_update_lif_at_port() { |
| let pm = create_ports(); |
| let mut lm = LIFManager::new(); |
| let lif = &LIF::new( |
| 3, |
| LIFType::LAN, |
| "lan1", |
| PortId::from(33), |
| vec![PortId::from(1), PortId::from(2), PortId::from(33)], |
| 0, |
| Some(LIFProperties { |
| dhcp: true, |
| address: Some(LifIpAddr { address: IpAddr::from([4, 3, 2, 1]), prefix: 24 }), |
| enabled: true, |
| }), |
| ) |
| .unwrap(); |
| lm.add_lif(lif); |
| lm.update_lif_at_port( |
| 33, |
| LIFProperties { |
| dhcp: false, |
| address: Some(LifIpAddr { address: IpAddr::from([1, 2, 3, 4]), prefix: 24 }), |
| enabled: false, |
| }, |
| ); |
| // DHCP field must not be updated, but all other fields should have the new value. |
| assert_eq!( |
| lm.lif(&lif.id.uuid).unwrap().properties, |
| LIFProperties { |
| dhcp: true, |
| address: Some(LifIpAddr { address: IpAddr::from([1, 2, 3, 4]), prefix: 24 }), |
| enabled: false, |
| } |
| ); |
| } |
| |
| fn build_lif_subnet( |
| lifip_addr: &str, |
| expected_addr: &str, |
| prefix_len: u8, |
| ) -> (LifIpAddr, fidl_fuchsia_net::Subnet) { |
| let lifip = LifIpAddr { address: lifip_addr.parse().unwrap(), prefix: prefix_len }; |
| |
| let ip: IpAddr = expected_addr.parse().unwrap(); |
| let expected_subnet = fidl_fuchsia_net::Subnet { |
| addr: fidl_fuchsia_net::IpAddress::Ipv4(Ipv4Address { |
| addr: match ip { |
| std::net::IpAddr::V4(v4addr) => v4addr.octets(), |
| std::net::IpAddr::V6(_) => panic!("unexpected ipv6 address"), |
| }, |
| }), |
| prefix_len, |
| }; |
| (lifip, expected_subnet) |
| } |
| |
| #[test] |
| fn test_fidl_subnet_math() { |
| let (lifip, expected_subnet) = build_lif_subnet("169.254.10.10", "169.254.10.10", 32); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| |
| let (lifip, expected_subnet) = build_lif_subnet("169.254.10.10", "169.254.10.0", 24); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| |
| let (lifip, expected_subnet) = build_lif_subnet("169.254.10.10", "169.254.0.0", 16); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| |
| let (lifip, expected_subnet) = build_lif_subnet("169.254.10.10", "169.0.0.0", 8); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| |
| let (lifip, expected_subnet) = build_lif_subnet("169.254.127.254", "169.254.124.0", 22); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| |
| let (lifip, expected_subnet) = build_lif_subnet("16.25.12.25", "16.16.0.0", 12); |
| assert_eq!(lifip.to_fidl_subnet(), expected_subnet); |
| } |
| } |
