address: Support dynamic IPv6 address and its flags

cathay4t · cathay4t · commit 21f5d8ca32c9 · 2026-05-16T20:40:49.000+08:00
* Fix valid_lft and preferred_lft of dynamic(kernel_ra) IP address
 * Complete rewrite on ip address flag processing

Unit test case expanded for this.

Signed-off-by: Gris Ge &lt;cnfourt@gmail.com&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,6 +20,8 @@ path = "src/ip/main.rs"
 [dependencies]
 clap = { version = "4.5.40", features = ["cargo"] }
 futures-util = "0.3.31"
+indexmap = { version = "2.14.0", features = ["serde"] }
+log = { version = "0.4.29", features = ["std"] }
 rtnetlink = { git = "https://github.com/rust-netlink/rtnetlink" }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = "1.0.140"
diff --git a/src/ip/address/cli.rs b/src/ip/address/cli.rs
@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: MIT
 
-use iproute_rs::CliError;
-
 use super::show::handle_show;
-use crate::link::CliLinkInfo;
+use crate::{CliError, link::CliLinkInfo};
 
 pub(crate) struct AddressCommand;
 
diff --git a/src/ip/address/show.rs b/src/ip/address/show.rs
@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 
 use futures_util::TryStreamExt;
+use indexmap::IndexMap;
 use iproute_rs::{CanDisplay, CanOutput, CliColor, write_with_color};
 use rtnetlink::packet_route::{
     AddressFamily,
@@ -22,8 +23,8 @@ pub(crate) struct CliAddressInfo {
     #[serde(skip_serializing_if = "Option::is_none")]
     broadcast: Option<String>,
     scope: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    tentative: Option<bool>,
+    #[serde(flatten, skip_serializing_if = "IndexMap::is_empty")]
+    flags: IndexMap<String, bool>,
     #[serde(skip_serializing_if = "String::is_empty")]
     protocol: String,
     #[serde(skip_serializing_if = "String::is_empty")]
@@ -32,6 +33,68 @@ pub(crate) struct CliAddressInfo {
     preferred_life_time: u32,
 }
 
+#[derive(Clone, Copy)]
+struct AddressFlagData {
+    name: &'static str,
+    mask: AddressFlags,
+}
+
+// equal to iproute2 `struct ifa_flag_data_t` in `ipaddress.c`
+const ADDRESS_FLAG_DATA: &[AddressFlagData] = &[
+    AddressFlagData {
+        name: "secondary",
+        mask: AddressFlags::Secondary,
+    },
+    AddressFlagData {
+        name: "temporary",
+        mask: AddressFlags::Secondary,
+    },
+    AddressFlagData {
+        name: "nodad",
+        mask: AddressFlags::Nodad,
+    },
+    AddressFlagData {
+        name: "optimistic",
+        mask: AddressFlags::Optimistic,
+    },
+    AddressFlagData {
+        name: "dadfailed",
+        mask: AddressFlags::Dadfailed,
+    },
+    AddressFlagData {
+        name: "home",
+        mask: AddressFlags::Homeaddress,
+    },
+    AddressFlagData {
+        name: "deprecated",
+        mask: AddressFlags::Deprecated,
+    },
+    AddressFlagData {
+        name: "tentative",
+        mask: AddressFlags::Tentative,
+    },
+    AddressFlagData {
+        name: "permanent",
+        mask: AddressFlags::Permanent,
+    },
+    AddressFlagData {
+        name: "mngtmpaddr",
+        mask: AddressFlags::Managetempaddr,
+    },
+    AddressFlagData {
+        name: "noprefixroute",
+        mask: AddressFlags::Noprefixroute,
+    },
+    AddressFlagData {
+        name: "autojoin",
+        mask: AddressFlags::Mcautojoin,
+    },
+    AddressFlagData {
+        name: "stable-privacy",
+        mask: AddressFlags::StablePrivacy,
+    },
+];
+
 impl std::fmt::Display for CliAddressInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{} ", self.family)?;
@@ -52,9 +115,7 @@ impl std::fmt::Display for CliAddressInfo {
             )?;
         }
         write!(f, " scope {} ", self.scope)?;
-        if Some(true) == self.tentative {
-            write!(f, "tentative ")?;
-        }
+        self.write_flags(f)?;
 
         if !self.protocol.is_empty() {
             write!(f, "proto {} ", self.protocol)?;
@@ -68,18 +129,29 @@ impl std::fmt::Display for CliAddressInfo {
             if self.valid_life_time == u32::MAX {
                 "forever".to_string()
             } else {
-                self.valid_life_time.to_string()
+                format!("{}sec", self.valid_life_time)
             },
             if self.preferred_life_time == u32::MAX {
                 "forever".to_string()
             } else {
-                self.preferred_life_time.to_string()
+                format!("{}sec", self.preferred_life_time)
             }
         )?;
         Ok(())
     }
 }
 
+impl CliAddressInfo {
+    fn write_flags(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for flag_name in self.flags.iter().filter_map(|(flag_name, value)| {
+            if *value { Some(flag_name) } else { None }
+        }) {
+            write!(f, "{} ", flag_name)?;
+        }
+        Ok(())
+    }
+}
+
 impl CanDisplay for CliAddressInfo {
     fn gen_string(&self) -> String {
         self.to_string()
@@ -95,6 +167,39 @@ fn addr_scope_to_cli_string(addr_scope: &AddressScope) -> String {
     }
 }
 
+fn get_address_flags(
+    family: AddressFamily,
+    flags: AddressFlags,
+) -> IndexMap<String, bool> {
+    let mut ret = IndexMap::new();
+    let mut flags = flags;
+
+    for flag_data in ADDRESS_FLAG_DATA {
+        if flag_data.mask == AddressFlags::Permanent {
+            if !flags.contains(flag_data.mask) {
+                ret.insert("dynamic".to_string(), true);
+            }
+        } else if flags.contains(flag_data.mask) {
+            if flag_data.mask == AddressFlags::Secondary
+                && family == AddressFamily::Inet6
+            {
+                ret.insert("temporary".to_string(), true);
+            } else {
+                ret.insert(flag_data.name.to_string(), true);
+            }
+        }
+        flags.remove(flag_data.mask);
+    }
+    // iproute2 shows unknown flags in hex format, to support so
+    // the IndexMap<String, bool> need to be changed to IndexMap<String, String>
+    // which is overskill for this unknown flags. Let's just log a debug info
+    // and wait bug report.
+    if !flags.is_empty() {
+        log::debug!("Unknown address flags: {:02x}", flags.bits());
+    }
+    ret
+}
+
 fn parse_nl_msg_to_address(
     nl_msg: AddressMessage,
 ) -> Result<CliAddressInfo, CliError> {
@@ -104,7 +209,8 @@ fn parse_nl_msg_to_address(
     let prefixlen = nl_msg.header.prefix_len;
     let mut broadcast = None;
     let scope = addr_scope_to_cli_string(&nl_msg.header.scope);
-    let mut tentative = None;
+    let mut flags =
+        AddressFlags::from_bits_retain(nl_msg.header.flags.bits().into());
     let mut label = String::new();
     let mut valid_life_time = u32::MAX;
     let mut preferred_life_time = u32::MAX;
@@ -129,10 +235,7 @@ fn parse_nl_msg_to_address(
                 preferred_life_time = c.ifa_preferred;
             }
             AddressAttribute::Flags(f) => {
-                // If there is no tentative flag the field should be None
-                tentative = (nl_msg.header.family == AddressFamily::Inet6
-                    && f.contains(AddressFlags::Tentative))
-                .then_some(true);
+                flags = f;
             }
             AddressAttribute::Protocol(p) => {
                 protocol = p.to_string();
@@ -143,19 +246,21 @@ fn parse_nl_msg_to_address(
         }
     }
 
-    Ok(CliAddressInfo {
+    let cli_addr_info = CliAddressInfo {
         index,
         family,
         local,
         prefixlen,
         broadcast,
         scope,
-        tentative,
+        flags: get_address_flags(nl_msg.header.family, flags),
         label,
         valid_life_time,
         preferred_life_time,
         protocol,
-    })
+    };
+
+    Ok(cli_addr_info)
 }
 
 pub(crate) async fn handle_show(
diff --git a/src/ip/address/tests/address.rs b/src/ip/address/tests/address.rs
@@ -82,7 +82,42 @@ where
     exec_cmd(&["ip", "link", "set", dummy_name, "up"]);
 
     exec_cmd(&["ip", "addr", "add", "192.168.1.1/24", "dev", dummy_name]);
+    exec_cmd(&["ip", "addr", "add", "192.168.1.2/24", "dev", dummy_name]);
     exec_cmd(&["ip", "addr", "add", "ff::ab:cd/64", "dev", dummy_name]);
+    exec_cmd(&[
+        "ip",
+        "addr",
+        "add",
+        "2001:db8:beef::1/64",
+        "dev",
+        dummy_name,
+        "valid_lft",
+        "21384",
+        "preferred_lft",
+        "21384",
+        "scope",
+        "global",
+        "mngtmpaddr",
+        "proto",
+        "kernel_ra",
+    ]);
+    exec_cmd(&[
+        "ip",
+        "addr",
+        "add",
+        "2001:db8:beef::2/64",
+        "dev",
+        dummy_name,
+        "valid_lft",
+        "21381",
+        "preferred_lft",
+        "21381",
+        "scope",
+        "global",
+        "home",
+        "proto",
+        "kernel_ra",
+    ]);
 
     // Wait 2 seconds for interface to be up and addresses to be assigned
     std::thread::sleep(std::time::Duration::from_secs(2));
