Add Windows guest networking

.github/workflows/test.yml

@@ -132,18 +132,18 @@ jobs:
           done
           exit 1
 
-      - name: Test Windows guest control
+      - name: Test Windows lifecycle
         run: |
           make build-embedded
           TEST_PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH"
           for attempt in 1 2 3; do
             if sudo env \
               "PATH=$TEST_PATH" \
               "CI=true" \
-              "HYPEMAN_RUN_WINDOWS_GUEST_CONTROL_INTEGRATION=1" \
+              "HYPEMAN_RUN_WINDOWS_LIFECYCLE_INTEGRATION=1" \
               "HYPEMAN_WINDOWS_OVMF_CODE=$HYPEMAN_WINDOWS_OVMF_CODE" \
               "HYPEMAN_WINDOWS_OVMF_VARS=$HYPEMAN_WINDOWS_OVMF_VARS" \
-              go test -count=1 -run '^TestWindowsGuestAgentIntegration$' -timeout 2m ./lib/instances; then
+              go test -count=1 -run '^TestWindowsLifecycleIntegration$' -timeout 2m ./lib/instances; then
               exit 0
             fi
             test "$attempt" = 3 || sleep 5

docs/windows-networking.md

@@ -0,0 +1,7 @@
+# Windows networking
+
+Hypeman can attach a Windows 11 QEMU guest to its normal TAP/bridge network. The public instance model remains unchanged: `NetworkEnabled` allocates the address, MAC, gateway, netmask, DNS servers, and TAP device used for Linux guests.
+
+Create and start apply the current allocation before the instance becomes ready. A configuration failure fails the lifecycle operation rather than exposing a guest with partial networking.
+
+RDP is not a Hypeman API. A prepared image may enable RDP, and callers can reach TCP port 3389 through the instance's generic allocated IP after applying their normal ingress policy.

lib/guest/client.go

@@ -157,6 +157,7 @@ type ReconfigureNetworkOptions struct {
 	IPv4          string
 	Prefix        uint32
 	Gateway       string
+	DNSServers    []string
 	WaitForAgent  time.Duration
 }
 
@@ -240,6 +241,7 @@ func reconfigureNetworkOnce(ctx context.Context, dialer hypervisor.VsockDialer,
 		Ipv4:          opts.IPv4,
 		Prefix:        opts.Prefix,
 		Gateway:       opts.Gateway,
+		DnsServers:    opts.DNSServers,
 	})
 	finishGuestNetworkStepSpan(span, err)
 	if err != nil {

lib/guest/guest.proto

@@ -171,6 +171,7 @@ message ReconfigureNetworkRequest {
   string ipv4 = 3;            // New IPv4 address without prefix
   uint32 prefix = 4;          // IPv4 prefix length
   string gateway = 5;         // Default gateway IPv4 address
+  repeated string dns_servers = 6; // DNS server IPv4 addresses
 }
 
 // ReconfigureNetworkResponse acknowledges the network reconfiguration request

lib/instances/README.md

@@ -30,6 +30,12 @@ The launchable Windows image already defines its virtual disk size, so instance
 
 A Windows VM remains `Initializing` until its guest agent answers over VioSock. This avoids treating firmware completion as application readiness.
 
+### Windows networking
+
+Windows uses the same host-side TAP allocation as Linux. Once the guest agent is reachable, the manager sends the complete allocation through the typed `ReconfigureNetwork` RPC. The agent selects the virtio-net adapter by MAC address, replaces stale IPv4 addresses and default routes, and applies DNS through native Windows APIs. It never invokes the Linux shell-command fallback.
+
+Create treats network configuration as part of readiness and tears down a VM if it fails. Start reapplies the current allocation because a stopped instance may receive a different address or MAC before its next boot.
+
 ### Why Config Disk? (configdisk.go)
 
 **What:** Read-only erofs disk with instance configuration

lib/instances/create.go

@@ -575,6 +575,20 @@ func (m *manager) createInstance(
 		log.WarnContext(ctx, "failed to update metadata after VM start", "instance_id", id, "error", err)
 	}
 
+	if windows && netConfig != nil {
+		networkCtx, networkSpanEnd := m.startLifecycleStep(ctx, "configure_guest_network",
+			attribute.String("instance_id", id),
+			attribute.String("hypervisor", string(stored.HypervisorType)),
+			attribute.String("operation", "configure_guest_network"),
+		)
+		if err := reconfigureGuestNetworkConfig(networkCtx, stored, netConfig); err != nil {
+			networkSpanEnd(err)
+			_, _ = m.stopInstance(ctx, id)
+			return nil, fmt.Errorf("configure Windows guest network: %w", err)
+		}
+		networkSpanEnd(nil)
+	}
+
 	// Success - release cleanup stack (prevent cleanup)
 	cu.Release()
 

lib/instances/restore.go

@@ -474,26 +474,47 @@ func (m *manager) acquireRestoreSlot(ctx context.Context, hvType hypervisor.Type
 }
 
 func reconfigureGuestNetwork(ctx context.Context, stored *StoredMetadata, alloc *network.Allocation) error {
-	cfg, err := guestNetworkReconfigureConfig(alloc)
+	if alloc == nil {
+		return fmt.Errorf("missing network allocation")
+	}
+	return reconfigureGuestNetworkConfig(ctx, stored, &network.NetworkConfig{
+		IP: alloc.IP, MAC: alloc.MAC, Gateway: alloc.Gateway, Netmask: alloc.Netmask, DNS: alloc.DNS, TAPDevice: alloc.TAPDevice,
+	})
+}
+
+func reconfigureGuestNetworkConfig(ctx context.Context, stored *StoredMetadata, netConfig *network.NetworkConfig) error {
+	cfg, err := guestNetworkReconfigureConfig(netConfig)
 	if err != nil {
 		return err
 	}
+	if isWindowsPlatform(stored.Platform) {
+		cfg.dns, err = parseWindowsDNSServers(netConfig.DNS)
+		if err != nil {
+			return err
+		}
+	}
 
 	dialer, err := hypervisor.NewVsockDialer(stored.HypervisorType, stored.VsockSocket, stored.VsockCID)
 	if err != nil {
 		return fmt.Errorf("create vsock dialer: %w", err)
 	}
 
+	interfaceName := "eth0"
+	if isWindowsPlatform(stored.Platform) {
+		interfaceName = ""
+	}
 	err = guest.ReconfigureNetworkInInstance(ctx, dialer, guest.ReconfigureNetworkOptions{
-		InterfaceName: "eth0",
+		InterfaceName: interfaceName,
 		MAC:           cfg.mac,
 		IPv4:          cfg.ip,
 		Prefix:        uint32(cfg.prefix),
 		Gateway:       cfg.gateway,
+		DNSServers:    cfg.dns,
 		WaitForAgent:  120 * time.Second,
 	})
 	if err != nil {
-		if status.Code(err) == codes.Unimplemented {
+		if status.Code(err) == codes.Unimplemented && !isWindowsPlatform(stored.Platform) {
+			alloc := &network.Allocation{IP: netConfig.IP, MAC: netConfig.MAC, Gateway: netConfig.Gateway, Netmask: netConfig.Netmask}
 			return reconfigureGuestNetworkWithExec(ctx, dialer, alloc)
 		}
 		return fmt.Errorf("reconfigure guest network: %w", err)
@@ -528,37 +549,50 @@ type guestNetworkConfig struct {
 	ip      string
 	mac     string
 	gateway string
+	dns     []string
 	prefix  int
 }
 
-func guestNetworkReconfigureConfig(alloc *network.Allocation) (*guestNetworkConfig, error) {
-	if alloc == nil {
+func guestNetworkReconfigureConfig(netConfig *network.NetworkConfig) (*guestNetworkConfig, error) {
+	if netConfig == nil {
 		return nil, fmt.Errorf("missing network allocation")
 	}
-	ip := strings.TrimSpace(alloc.IP)
+	ip := strings.TrimSpace(netConfig.IP)
 	if ip == "" {
 		return nil, fmt.Errorf("missing network allocation IP")
 	}
-	mac := strings.ToLower(strings.TrimSpace(alloc.MAC))
+	mac := strings.ToLower(strings.TrimSpace(netConfig.MAC))
 	if mac == "" {
 		return nil, fmt.Errorf("missing network allocation MAC")
 	}
 	if _, err := net.ParseMAC(mac); err != nil {
-		return nil, fmt.Errorf("invalid network allocation MAC %q: %w", alloc.MAC, err)
+		return nil, fmt.Errorf("invalid network allocation MAC %q: %w", netConfig.MAC, err)
 	}
-	gateway := strings.TrimSpace(alloc.Gateway)
+	gateway := strings.TrimSpace(netConfig.Gateway)
 	if gateway == "" {
 		return nil, fmt.Errorf("missing network allocation gateway")
 	}
-	prefix, err := netmaskToPrefix(alloc.Netmask)
+	prefix, err := netmaskToPrefix(netConfig.Netmask)
 	if err != nil {
 		return nil, err
 	}
 	return &guestNetworkConfig{ip: ip, mac: mac, gateway: gateway, prefix: prefix}, nil
 }
 
+func parseWindowsDNSServers(value string) ([]string, error) {
+	var dns []string
+	for _, server := range strings.FieldsFunc(value, func(r rune) bool { return r == ',' || r == ' ' }) {
+		server = strings.TrimSpace(server)
+		if net.ParseIP(server).To4() == nil {
+			return nil, fmt.Errorf("invalid Windows DNS server %q", server)
+		}
+		dns = append(dns, server)
+	}
+	return dns, nil
+}
+
 func guestNetworkReconfigureCommand(alloc *network.Allocation) (string, error) {
-	cfg, err := guestNetworkReconfigureConfig(alloc)
+	cfg, err := guestNetworkReconfigureConfig(networkConfigFromAllocation(alloc))
 	if err != nil {
 		return "", err
 	}

lib/instances/restore_egress_test.go

@@ -30,6 +30,22 @@ func TestNetworkConfigFromAllocation_PreservesDNS(t *testing.T) {
 	assert.Equal(t, alloc.TAPDevice, cfg.TAPDevice)
 }
 
+func TestWindowsDNSServerParsingDoesNotAffectLinuxConfig(t *testing.T) {
+	t.Parallel()
+
+	dns, err := parseWindowsDNSServers("1.1.1.1, 8.8.8.8")
+	require.NoError(t, err)
+	assert.Equal(t, []string{"1.1.1.1", "8.8.8.8"}, dns)
+	_, err = parseWindowsDNSServers("2606:4700:4700::1111")
+	require.ErrorContains(t, err, "invalid Windows DNS server")
+
+	cfg, err := guestNetworkReconfigureConfig(&network.NetworkConfig{
+		IP: "10.102.146.62", MAC: "02:00:00:85:17:c8", Gateway: "10.102.0.1", Netmask: "255.255.0.0", DNS: "2606:4700:4700::1111",
+	})
+	require.NoError(t, err)
+	assert.Empty(t, cfg.dns)
+}
+
 func TestGuestNetworkReconfigureCommand_AppliesAllocatedMAC(t *testing.T) {
 	t.Parallel()
 

lib/instances/start.go

@@ -223,6 +223,20 @@ func (m *manager) startInstance(
 		log.WarnContext(ctx, "failed to update metadata after VM start", "instance_id", id, "error", err)
 	}
 
+	if isWindowsPlatform(stored.Platform) && netConfig != nil {
+		networkCtx, networkSpanEnd := m.startLifecycleStep(ctx, "configure_guest_network",
+			attribute.String("instance_id", id),
+			attribute.String("hypervisor", string(stored.HypervisorType)),
+			attribute.String("operation", "configure_guest_network"),
+		)
+		if err := reconfigureGuestNetworkConfig(networkCtx, stored, netConfig); err != nil {
+			networkSpanEnd(err)
+			_, _ = m.stopInstance(ctx, id)
+			return nil, fmt.Errorf("configure Windows guest network: %w", err)
+		}
+		networkSpanEnd(nil)
+	}
+
 	// Return instance state from current metadata without forcing a log scan.
 	finalInst := m.toInstanceWithoutHydration(ctx, meta)
 	// Record metrics

lib/instances/windows.go

@@ -34,9 +34,6 @@ func validateWindowsCreate(req CreateInstanceRequest, image *images.Image, caps
 	if req.Vcpus != 0 && req.Vcpus < 2 {
 		return fmt.Errorf("%w: Windows 11 requires at least 2 vCPUs", ErrInvalidRequest)
 	}
-	if req.NetworkEnabled {
-		return fmt.Errorf("%w: Windows networking is added in the networking phase", ErrInvalidRequest)
-	}
 	if len(req.Volumes) != 0 || len(req.Devices) != 0 || req.GPU != nil {
 		return fmt.Errorf("%w: Windows instances do not yet support volumes or device passthrough", ErrInvalidRequest)
 	}