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

The dual-stack `DhcpConfig` added in #2672 has a `carbide_nameservers_v6` field, but nothing fills it -- `from_forge_dhcp_config` and the agent's config builders are IPv4-only, so a host's IPv6 DNS resolvers never reach the config. The agent already learns both families from the DPU's `ServiceAddresses`; this splits them by family and fills `carbide_nameservers_v6` at both DHCP-config build sites (the gRPC control path and the on-disk config path), threading the IPv6 set through `from_forge_dhcp_config` and `build_server_config`.

A `split_nameservers_by_family` helper does the split once, so the two build sites cannot diverge. The IPv4 DHCPv4 option-6 path is unchanged; the IPv6 set stays inert until a delivery channel consumes it (DHCPv6 or RA, tracked by the broader IPv6 effort).

Tests cover `from_forge_dhcp_config` populating the v6 field and the family split itself.

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,10 @@ 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>>();
+    // Split the dual-stack nameservers by family: the IPv4 set drives the
+    // DHCPv4 options written here, while the IPv6 set is held in the config for
+    // the eventual DHCPv6 / RA consumer (inert in this path for now).
+    let (nameservers_v4, nameservers_v6) = split_nameservers_by_family(&service_addrs.nameservers);
 
     let ntpservers_v4 = build_dhcp_ntp_servers(nc, service_addrs);
 
@@ -1517,8 +1517,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,
@@ -3305,6 +3310,23 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn split_nameservers_by_family_partitions_both_families() {
+        let (v4, v6) = split_nameservers_by_family(&[
+            IpAddr::from([10, 0, 0, 1]),
+            "2001:db8::1".parse().unwrap(),
+            IpAddr::from([10, 0, 0, 2]),
+        ]);
+        assert_eq!(
+            v4,
+            vec![Ipv4Addr::new(10, 0, 0, 1), Ipv4Addr::new(10, 0, 0, 2)]
+        );
+        assert_eq!(
+            v6,
+            vec!["2001:db8::1".parse::<std::net::Ipv6Addr>().unwrap()]
+        );
+    }
+
     fn validate_dhcp_config(received: DhcpConfig, expected: DhcpConfig) {
         assert_eq!(received.lease_time_secs, expected.lease_time_secs);
         assert_eq!(received.renewal_time_secs, expected.renewal_time_secs);

crates/rpc-utils/src/dhcp.rs

@@ -96,10 +96,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,
@@ -344,6 +346,7 @@ mod tests {
         dhcp_server: Ipv4Addr,
         ntpservers: Vec<Ipv4Addr>,
         nameservers: Vec<Ipv4Addr>,
+        nameservers_v6: Vec<Ipv6Addr>,
         lease_time_secs: u32,
     }
 
@@ -434,24 +437,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)
@@ -484,12 +490,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,
                 }),
             }