feat(dhcp): include the host's IPv6 DNS resolvers in the agent's DHCP config

The agent reads a host's nameservers from the DPU's dual-stack `ServiceAddresses`, then builds the `DhcpConfig` it sends to `forge-dhcp-server`. It now splits those nameservers by family at both build sites -- the gRPC control path (`update_dhcp_via_grpc`) and the on-disk config path (`write_dhcp_v4_server_config`) -- and fills `carbide_nameservers_v6` with the IPv6 set, threaded through `from_forge_dhcp_config` and `build_server_config`.

The agent used to filter these nameservers to IPv4 and drop the IPv6 ones, with a TODO marking exactly this gap. The IPv4 path is unchanged -- it still drives the DHCPv4 option-6 nameservers -- and the IPv6 set stays inert until a delivery channel consumes it (RA RDNSS or DHCPv6, see #2644 / #1263).

Tests extend the file-path builder test to assert an IPv6 nameserver round-trips through the written config, alongside the builder's own dual-stack case.

This supports #2640.

Signed-off-by: Chet Nichols III <chetn@nvidia.com>

Author: chet

crates/agent/src/dhcp.rs

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-use std::net::Ipv4Addr;
+use std::net::{Ipv4Addr, Ipv6Addr};
 
 use ::rpc::forge as rpc;
 use carbide_rpc_utils::dhcp::HostConfig;
@@ -64,12 +64,14 @@ pub fn build_server_config(
     pxe_ip: Ipv4Addr,
     ntpservers: Vec<Ipv4Addr>,
     nameservers: Vec<Ipv4Addr>,
+    nameservers_v6: Vec<Ipv6Addr>,
     loopback_ip: Ipv4Addr,
 ) -> Result<String, eyre::Report> {
     let dhcp_config = carbide_rpc_utils::dhcp::DhcpConfig::from_forge_dhcp_config(
         pxe_ip,
         ntpservers,
         nameservers,
+        nameservers_v6,
         loopback_ip,
     )?;
 

crates/agent/src/ethernet_virtualization.rs

@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::ffi::CStr;
 use std::fs::File;
 use std::io::Read;
-use std::net::{IpAddr, Ipv4Addr};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::Duration;
@@ -138,6 +138,20 @@ pub struct ServiceAddresses {
     pub nameservers: Vec<IpAddr>,
 }
 
+/// Split a dual-stack nameserver list into its IPv4 and IPv6 members, so the
+/// gRPC and file-write DHCP-config paths derive both families the same way.
+fn split_nameservers_by_family(nameservers: &[IpAddr]) -> (Vec<Ipv4Addr>, Vec<Ipv6Addr>) {
+    let mut v4 = Vec::new();
+    let mut v6 = Vec::new();
+    for addr in nameservers {
+        match addr {
+            IpAddr::V4(v4_addr) => v4.push(*v4_addr),
+            IpAddr::V6(v6_addr) => v6.push(*v6_addr),
+        }
+    }
+    (v4, v6)
+}
+
 fn build_dhcp_ntp_servers(
     nc: &rpc::ManagedHostNetworkConfigResponse,
     service_addrs: &ServiceAddresses,
@@ -1066,14 +1080,7 @@ async fn update_dhcp_via_grpc(
     };
     let loopback_ip: Ipv4Addr = mh_nc.loopback_ip.parse()?;
 
-    let nameservers_v4 = service_addrs
-        .nameservers
-        .iter()
-        .filter_map(|x| match x {
-            IpAddr::V4(x) => Some(*x),
-            _ => None,
-        })
-        .collect::<Vec<Ipv4Addr>>();
+    let (nameservers_v4, nameservers_v6) = split_nameservers_by_family(&service_addrs.nameservers);
 
     let ntpservers_v4 = build_dhcp_ntp_servers(network_config, service_addrs);
 
@@ -1095,6 +1102,7 @@ async fn update_dhcp_via_grpc(
         pxe_ip_v4,
         ntpservers_v4,
         nameservers_v4,
+        nameservers_v6,
         loopback_ip,
     )?;
     let mut host_config = carbide_rpc_utils::dhcp::HostConfig::try_from(
@@ -1471,18 +1479,9 @@ fn write_dhcp_v4_server_config(
 
     let loopback_ip = mh_nc.loopback_ip.parse()?;
 
-    // Filter to IPv4, since this is specifically for the DHCPv4 server
-    // config, and the input ServiceAddresses holds both families.
-    // Again, we'll eventually have a specific builder for a DHCPv6
-    // that does similar things with ServiceAddresses, but for IPv6.
-    let nameservers_v4 = service_addrs
-        .nameservers
-        .iter()
-        .filter_map(|x| match x {
-            IpAddr::V4(x) => Some(*x),
-            _ => None,
-        })
-        .collect::<Vec<Ipv4Addr>>();
+    // The IPv4 set drives the DHCPv4 options written here; the IPv6 set is held
+    // in the config for the eventual DHCPv6 / RA consumer (inert in this path).
+    let (nameservers_v4, nameservers_v6) = split_nameservers_by_family(&service_addrs.nameservers);
 
     let ntpservers_v4 = build_dhcp_ntp_servers(nc, service_addrs);
 
@@ -1517,8 +1516,13 @@ fn write_dhcp_v4_server_config(
         Err(err) => tracing::error!("Write DHCP server {}: {err:#}", dhcp_server_path.server),
     }
 
-    let next_contents =
-        dhcp::build_server_config(pxe_ip_v4, ntpservers_v4, nameservers_v4, loopback_ip)?;
+    let next_contents = dhcp::build_server_config(
+        pxe_ip_v4,
+        ntpservers_v4,
+        nameservers_v4,
+        nameservers_v6,
+        loopback_ip,
+    )?;
     match write(
         next_contents,
         &dhcp_server_path.config,
@@ -3467,7 +3471,7 @@ mod tests {
             rebinding_time_secs: 432000,
             carbide_api_url: None,
             carbide_dhcp_server: Ipv4Addr::from([10, 217, 5, 39]),
-            carbide_nameservers_v6: vec![],
+            carbide_nameservers_v6: vec!["2001:db8::53".parse().unwrap()],
         };
 
         let mut network_config = rpc::ManagedHostNetworkConfigResponse {
@@ -3565,7 +3569,7 @@ mod tests {
                 IpAddr::from([127, 0, 0, 2]),
                 IpAddr::from([127, 0, 0, 3]),
             ],
-            nameservers: vec![IpAddr::from([10, 1, 1, 1])],
+            nameservers: vec![IpAddr::from([10, 1, 1, 1]), "2001:db8::53".parse().unwrap()],
         };
 
         let mut host_config_str =

crates/rpc-utils/src/dhcp.rs

@@ -88,10 +88,12 @@ impl DhcpConfig {
         carbide_provisioning_server_ipv4: Ipv4Addr,
         carbide_ntpservers: Vec<Ipv4Addr>,
         carbide_nameservers: Vec<Ipv4Addr>,
+        carbide_nameservers_v6: Vec<Ipv6Addr>,
         loopback_ip: Ipv4Addr,
     ) -> Result<Self, DhcpDataError> {
         Ok(DhcpConfig {
             carbide_nameservers,
+            carbide_nameservers_v6,
             carbide_ntpservers,
             carbide_provisioning_server_ipv4,
             carbide_dhcp_server: loopback_ip,
@@ -303,7 +305,7 @@ impl IntoIterator for DhcpTimestamps {
 
 #[cfg(test)]
 mod tests {
-    use std::net::Ipv4Addr;
+    use std::net::{Ipv4Addr, Ipv6Addr};
 
     use carbide_test_support::Outcome::*;
     use carbide_test_support::{scenarios, value_scenarios};
@@ -323,6 +325,7 @@ mod tests {
         dhcp_server: Ipv4Addr,
         ntpservers: Vec<Ipv4Addr>,
         nameservers: Vec<Ipv4Addr>,
+        nameservers_v6: Vec<Ipv6Addr>,
         lease_time_secs: u32,
     }
 
@@ -413,24 +416,27 @@ mod tests {
     }
 
     fn summarize_dhcp_config(
-        (provisioning_server, ntpservers, nameservers, dhcp_server): (
+        (provisioning_server, ntpservers, nameservers, nameservers_v6, dhcp_server): (
             Ipv4Addr,
             Vec<Ipv4Addr>,
             Vec<Ipv4Addr>,
+            Vec<Ipv6Addr>,
             Ipv4Addr,
         ),
     ) -> Result<DhcpConfigSummary, &'static str> {
         DhcpConfig::from_forge_dhcp_config(
             provisioning_server,
             ntpservers,
             nameservers,
+            nameservers_v6,
             dhcp_server,
         )
         .map(|config| DhcpConfigSummary {
             provisioning_server: config.carbide_provisioning_server_ipv4,
             dhcp_server: config.carbide_dhcp_server,
             ntpservers: config.carbide_ntpservers,
             nameservers: config.carbide_nameservers,
+            nameservers_v6: config.carbide_nameservers_v6,
             lease_time_secs: config.lease_time_secs,
         })
         .map_err(dhcp_error_kind)
@@ -463,12 +469,14 @@ mod tests {
                     Ipv4Addr::new(192, 0, 2, 10),
                     vec![Ipv4Addr::new(192, 0, 2, 20)],
                     vec![Ipv4Addr::new(192, 0, 2, 53)],
+                    vec!["2001:db8::53".parse::<Ipv6Addr>().unwrap()],
                     Ipv4Addr::new(127, 0, 0, 2),
                 ) => Yields(DhcpConfigSummary {
                     provisioning_server: Ipv4Addr::new(192, 0, 2, 10),
                     dhcp_server: Ipv4Addr::new(127, 0, 0, 2),
                     ntpservers: vec![Ipv4Addr::new(192, 0, 2, 20)],
                     nameservers: vec![Ipv4Addr::new(192, 0, 2, 53)],
+                    nameservers_v6: vec!["2001:db8::53".parse::<Ipv6Addr>().unwrap()],
                     lease_time_secs: DEFAULT_LEASE_TIME_SECS,
                 }),
             }