Merge pull request #893 from jcronenberg/general-mac-address

Add mac assigning to network base connection

rust/agama-dbus-server/Cargo.toml

@@ -24,3 +24,4 @@ tokio-stream = "0.1.14"
 gettext-rs = { version = "0.7.0", features = ["gettext-system"] }
 regex = "1.10.2"
 once_cell = "1.18.0"
+macaddr = "1.0"

rust/agama-dbus-server/src/network/dbus/interfaces.rs

@@ -6,11 +6,13 @@ use super::ObjectsRegistry;
 use crate::network::{
  action::Action,
  error::NetworkStateError,
- model::{Connection as NetworkConnection, Device as NetworkDevice, WirelessConnection},
+ model::{
+ Connection as NetworkConnection, Device as NetworkDevice, MacAddress, WirelessConnection,
+ },
 };
 
 use agama_lib::network::types::SSID;
-use std::sync::Arc;
+use std::{str::FromStr, sync::Arc};
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::{MappedMutexGuard, Mutex, MutexGuard};
 use zbus::{
@@ -238,6 +240,19 @@ impl Connection {
  connection.set_interface(name);
  self.update_connection(connection).await
  }
+
+ /// Custom mac-address
+ #[dbus_interface(property)]
+ pub async fn mac_address(&self) -> String {
+ self.get_connection().await.mac_address()
+ }
+
+ #[dbus_interface(property)]
+ pub async fn set_mac_address(&mut self, mac_address: &str) -> zbus::fdo::Result<()> {
+ let mut connection = self.get_connection().await;
+ connection.set_mac_address(MacAddress::from_str(mac_address)?);
+ self.update_connection(connection).await
+ }
 }
 
 /// D-Bus interface for Match settings

rust/agama-dbus-server/src/network/model.rs

@@ -310,12 +310,25 @@ impl Connection {
  pub fn is_loopback(&self) -> bool {
  matches!(self, Connection::Loopback(_))
  }
+
+ pub fn is_ethernet(&self) -> bool {
+ matches!(self, Connection::Loopback(_)) || matches!(self, Connection::Ethernet(_))
+ }
+
+ pub fn mac_address(&self) -> String {
+ self.base().mac_address.to_string()
+ }
+
+ pub fn set_mac_address(&mut self, mac_address: MacAddress) {
+ self.base_mut().mac_address = mac_address;
+ }
 }
 
 #[derive(Debug, Default, Clone)]
 pub struct BaseConnection {
  pub id: String,
  pub uuid: Uuid,
+ pub mac_address: MacAddress,
  pub ip_config: IpConfig,
  pub status: Status,
  pub interface: String,
@@ -328,6 +341,59 @@ impl PartialEq for BaseConnection {
  }
 }
 
+#[derive(Debug, Error)]
+#[error("Invalid MAC address: {0}")]
+pub struct InvalidMacAddress(String);
+
+#[derive(Debug, Default, Clone)]
+pub enum MacAddress {
+ MacAddress(macaddr::MacAddr6),
+ Preserve,
+ Permanent,
+ Random,
+ Stable,
+ #[default]
+ Unset,
+}
+
+impl FromStr for MacAddress {
+ type Err = InvalidMacAddress;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "preserve" => Ok(Self::Preserve),
+ "permanent" => Ok(Self::Permanent),
+ "random" => Ok(Self::Random),
+ "stable" => Ok(Self::Stable),
+ "" => Ok(Self::Unset),
+ _ => Ok(Self::MacAddress(match macaddr::MacAddr6::from_str(s) {
+ Ok(mac) => mac,
+ Err(e) => return Err(InvalidMacAddress(e.to_string())),
+ })),
+ }
+ }
+}
+
+impl fmt::Display for MacAddress {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let output = match &self {
+ Self::MacAddress(mac) => mac.to_string(),
+ Self::Preserve => "preserve".to_string(),
+ Self::Permanent => "permanent".to_string(),
+ Self::Random => "random".to_string(),
+ Self::Stable => "stable".to_string(),
+ Self::Unset => "".to_string(),
+ };
+ write!(f, "{}", output)
+ }
+}
+
+impl From<InvalidMacAddress> for zbus::fdo::Error {
+ fn from(value: InvalidMacAddress) -> Self {
+ zbus::fdo::Error::Failed(value.to_string())
+ }
+}
+
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub enum Status {
  #[default]

rust/agama-dbus-server/src/network/nm/dbus.rs

@@ -33,8 +33,12 @@ pub fn connection_to_dbus(conn: &Connection) -> NestedHash {
  result.insert("ipv6", ip_config_to_ipv6_dbus(conn.ip_config()));
  result.insert("match", match_config_to_dbus(conn.match_config()));
 
- if let Connection::Wireless(wireless) = conn {
- connection_dbus.insert("type", "802-11-wireless".into());
+ if conn.is_ethernet() {
+ let ethernet_config =
+ HashMap::from([("assigned-mac-address", Value::new(conn.mac_address()))]);
+ result.insert(ETHERNET_KEY, ethernet_config);
+ } else if let Connection::Wireless(wireless) = conn {
+ connection_dbus.insert("type", WIRELESS_KEY.into());
  let wireless_dbus = wireless_config_to_dbus(wireless);
  for (k, v) in wireless_dbus {
  result.insert(k, v);
@@ -227,6 +231,10 @@ fn wireless_config_to_dbus(conn: &WirelessConnection) -> NestedHash {
  let wireless: HashMap<&str, zvariant::Value> = HashMap::from([
  ("mode", Value::new(config.mode.to_string())),
  ("ssid", Value::new(config.ssid.to_vec())),
+ (
+ "assigned-mac-address",
+ Value::new(conn.base.mac_address.to_string()),
+ ),
  ]);
 
  let mut security: HashMap<&str, zvariant::Value> =
@@ -300,11 +308,31 @@ fn base_connection_from_dbus(conn: &OwnedNestedHash) -> Option<BaseConnection> {
  base_connection.match_config = match_config_from_dbus(match_config)?;
  }
 
+ if let Some(ethernet_config) = conn.get(ETHERNET_KEY) {
+ base_connection.mac_address = mac_address_from_dbus(ethernet_config)?;
+ } else if let Some(wireless_config) = conn.get(WIRELESS_KEY) {
+ base_connection.mac_address = mac_address_from_dbus(wireless_config)?;
+ }
+
  base_connection.ip_config = ip_config_from_dbus(&conn)?;
 
  Some(base_connection)
 }
 
+fn mac_address_from_dbus(config: &HashMap<String, OwnedValue>) -> Option<MacAddress> {
+ if let Some(mac_address) = config.get("assigned-mac-address") {
+ match MacAddress::from_str(mac_address.downcast_ref::<str>()?) {
+ Ok(mac) => Some(mac),
+ Err(e) => {
+ log::warn!("Couldn't parse MAC: {}", e);
+ None
+ }
+ }
+ } else {
+ Some(MacAddress::Unset)
+ }
+}
+
 fn match_config_from_dbus(
  match_config: &HashMap<String, zvariant::OwnedValue>,
 ) -> Option<MatchConfig> {
@@ -594,6 +622,8 @@ mod test {
  let match_config = connection.match_config();
  assert_eq!(match_config.kernel, vec!["pci-0000:00:19.0"]);
 
+ assert_eq!(connection.mac_address(), "12:34:56:78:9A:BC");
+
  assert_eq!(
  ip_config.addresses,
  vec![
@@ -649,6 +679,10 @@ mod test {
  "ssid".to_string(),
  Value::new("agama".as_bytes()).to_owned(),
  ),
+ (
+ "assigned-mac-address".to_string(),
+ Value::new("13:45:67:89:AB:CD").to_owned(),
+ ),
  ]);
 
  let security_section =
@@ -661,6 +695,7 @@ mod test {
  ]);
 
  let connection = connection_from_dbus(dbus_conn).unwrap();
+ assert_eq!(connection.mac_address(), "13:45:67:89:AB:CD".to_string());
  assert!(matches!(connection, Connection::Wireless(_)));
  if let Connection::Wireless(connection) = connection {
  assert_eq!(connection.wireless.ssid, SSID(vec![97, 103, 97, 109, 97]));
@@ -688,6 +723,12 @@ mod test {
  let wireless = wireless_dbus.get("802-11-wireless").unwrap();
  let mode: &str = wireless.get("mode").unwrap().downcast_ref().unwrap();
  assert_eq!(mode, "infrastructure");
+ let mac_address: &str = wireless
+ .get("assigned-mac-address")
+ .unwrap()
+ .downcast_ref()
+ .unwrap();
+ assert_eq!(mac_address, "FD:CB:A9:87:65:43");
 
  let ssid: &zvariant::Array = wireless.get("ssid").unwrap().downcast_ref().unwrap();
  let ssid: Vec<u8> = ssid
@@ -813,19 +854,33 @@ mod test {
  Value::new("eth0".to_string()).to_owned(),
  ),
  ]);
+ let ethernet = HashMap::from([(
+ "assigned-mac-address".to_string(),
+ Value::new("12:34:56:78:9A:BC".to_string()).to_owned(),
+ )]);
  original.insert("connection".to_string(), connection);
+ original.insert(ETHERNET_KEY.to_string(), ethernet);
 
  let mut updated = Connection::Ethernet(EthernetConnection::default());
  updated.set_interface("");
+ updated.set_mac_address(MacAddress::Unset);
  let updated = connection_to_dbus(&updated);
 
  let merged = merge_dbus_connections(&original, &updated);
  let connection = merged.get("connection").unwrap();
  assert_eq!(connection.get("interface-name"), None);
+ let ethernet = merged.get(ETHERNET_KEY).unwrap();
+ assert_eq!(ethernet.get("assigned-mac-address"), Some(&Value::from("")));
  }
 
  fn build_ethernet_section_from_dbus() -> HashMap<String, OwnedValue> {
- HashMap::from([("auto-negotiate".to_string(), true.into())])
+ HashMap::from([
+ ("auto-negotiate".to_string(), true.into()),
+ (
+ "assigned-mac-address".to_string(),
+ Value::new("12:34:56:78:9A:BC").to_owned(),
+ ),
+ ])
  }
 
  fn build_base_connection() -> BaseConnection {
@@ -849,9 +904,11 @@ mod test {
  }]),
  ..Default::default()
  };
+ let mac_address = MacAddress::from_str("FD:CB:A9:87:65:43").unwrap();
  BaseConnection {
  id: "agama".to_string(),
  ip_config,
+ mac_address,
  ..Default::default()
  }
  }
@@ -868,6 +925,14 @@ mod test {
  let id: &str = connection_dbus.get("id").unwrap().downcast_ref().unwrap();
  assert_eq!(id, "agama");
 
+ let ethernet_connection = conn_dbus.get(ETHERNET_KEY).unwrap();
+ let mac_address: &str = ethernet_connection
+ .get("assigned-mac-address")
+ .unwrap()
+ .downcast_ref()
+ .unwrap();
+ assert_eq!(mac_address, "FD:CB:A9:87:65:43");
+
  let ipv4_dbus = conn_dbus.get("ipv4").unwrap();
  let gateway4: &str = ipv4_dbus.get("gateway").unwrap().downcast_ref().unwrap();
  assert_eq!(gateway4, "192.168.0.1");

rust/agama-dbus-server/tests/network.rs

@@ -62,6 +62,7 @@ async fn test_add_connection() -> Result<(), Box<dyn Error>> {
  let addresses: Vec<IpInet> = vec!["192.168.0.2/24".parse()?, "::ffff:c0a8:7ac7/64".parse()?];
  let wlan0 = settings::NetworkConnection {
  id: "wlan0".to_string(),
+ mac_address: Some("FD:CB:A9:87:65:43".to_string()),
  method4: Some("auto".to_string()),
  method6: Some("disabled".to_string()),
  addresses: addresses.clone(),
@@ -80,6 +81,7 @@ async fn test_add_connection() -> Result<(), Box<dyn Error>> {
 
  let conn = conns.first().unwrap();
  assert_eq!(conn.id, "wlan0");
+ assert_eq!(conn.mac_address, Some("FD:CB:A9:87:65:43".to_string()));
  assert_eq!(conn.device_type(), DeviceType::Wireless);
  assert_eq!(&conn.addresses, &addresses);
  let method4 = conn.method4.as_ref().unwrap();

rust/agama-lib/share/profile.schema.json

@@ -36,6 +36,10 @@
  "description": "The name of the network interface bound to this connection",
  "type": "string"
  },
+ "mac-address": {
+ "description": "Custom mac-address (can also be 'preserve', 'permanent', 'random' or 'stable')",
+ "type": "string"
+ },
  "method4": {
  "description": "IPv4 configuration method (e.g., 'auto')",
  "type": "string",

rust/agama-lib/src/network/client.rs

@@ -67,6 +67,10 @@ impl<'a> NetworkClient<'a> {
  "" => None,
  value => Some(value.to_string()),
  };
+ let mac_address = match connection_proxy.mac_address().await?.as_str() {
+ "" => None,
+ value => Some(value.to_string()),
+ };
 
  let ip_proxy = IPProxy::builder(&self.connection)
  .path(path)?
@@ -91,6 +95,7 @@ impl<'a> NetworkClient<'a> {
  addresses,
  nameservers,
  interface,
+ mac_address,
  ..Default::default()
  })
  }
@@ -189,6 +194,9 @@ impl<'a> NetworkClient<'a> {
  let interface = conn.interface.as_deref().unwrap_or("");
  proxy.set_interface(interface).await?;
 
+ let mac_address = conn.mac_address.as_deref().unwrap_or("");
+ proxy.set_mac_address(mac_address).await?;
+
  self.update_ip_settings(path, conn).await?;
 
  if let Some(ref wireless) = conn.wireless {

rust/agama-lib/src/network/proxies.rs

@@ -83,6 +83,10 @@ trait Connection {
  fn interface(&self) -> zbus::Result<String>;
  #[dbus_proxy(property)]
  fn set_interface(&self, interface: &str) -> zbus::Result<()>;
+ #[dbus_proxy(property)]
+ fn mac_address(&self) -> zbus::Result<String>;
+ #[dbus_proxy(property)]
+ fn set_mac_address(&self, mac_address: &str) -> zbus::Result<()>;
 }
 
 #[dbus_proxy(

rust/agama-lib/src/network/settings.rs

@@ -69,6 +69,8 @@ pub struct NetworkConnection {
  pub interface: Option<String>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub match_settings: Option<MatchSettings>,
+ #[serde(rename = "mac-address", skip_serializing_if = "Option::is_none")]
+ pub mac_address: Option<String>,
 }
 
 impl NetworkConnection {

rust/package/agama-cli.changes

@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Tue Dec 5 11:18:41 UTC 2023 - Jorik Cronenberg <jorik.cronenberg@suse.com>
+
+- Add ability to assign a custom MAC address for network
+ connections (gh#openSUSE/agama#893)
+
 -------------------------------------------------------------------
 Tue Dec 5 09:46:48 UTC 2023 - José Iván López González <jlopez@suse.com>