Use "192.168.x.1" to IPv4 subnet address instead of "192.168.x.0"

change `VmnetNetworkConfiguration.SetIPv4Subnet()`

Signed-off-by: Norio Nomura <[email protected]>

Author: norio-nomura

vmnet.go

@@ -163,7 +163,12 @@ func (c *VmnetNetworkConfiguration) SetIPv4Subnet(subnet netip.Prefix) error {
 	if !subnet.Addr().Is4() {
 		return fmt.Errorf("subnet is not ipv4")
 	}
-	ip := subnet.Addr().As4()
+	if !netip.MustParsePrefix("192.168.0.0/16").Overlaps(subnet) {
+		return fmt.Errorf("subnet %s is out of range", subnet.String())
+	}
+	// Use the first assignable address as the subnet address to avoid
+	// Virtualization fails with error "Internal Virtualization error. Internal Network Error.".
+	ip := subnet.Masked().Addr().Next().As4()
 	mask := net.CIDRMask(subnet.Bits(), 32)
 	var cSubnet C.struct_in_addr
 	var cMask C.struct_in_addr

vmnet_test.go

@@ -2,6 +2,9 @@ package vz_test
 
 import (
 	"log"
+	"net"
+	"net/netip"
+	"slices"
 	"testing"
 
 	"github.com/Code-Hex/vz/v3"
@@ -11,17 +14,31 @@ func TestVmnetSharedModeAllowsCommunicationBetweenMultipleVMs(t *testing.T) {
 	if vz.Available(26.0) {
 		t.Skip("VmnetSharedMode is supported from macOS 26")
 	}
+
+	// Create VmnetNetwork instance from configuration
 	config, err := vz.NewVmnetNetworkConfiguration(vz.SharedMode)
 	if err != nil {
 		t.Fatal(err)
 	}
-	network, err := vz.NewVmnetNetwork(config)
+	network1, err := vz.NewVmnetNetwork(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	macaddress1 := randomMACAddress(t)
+
+	// Create another VmnetNetwork instance from serialization of the first one
+	serialization, err := network1.CopySerialization()
+	if err != nil {
+		t.Fatal(err)
+	}
+	network2, err := vz.NewVmnetNetworkWithSerialization(serialization)
 	if err != nil {
 		t.Fatal(err)
 	}
+	macaddress2 := randomMACAddress(t)
 
-	container1 := newVirtualizationMachine(t, ConfigureNetworkDeviceWithNetwork(network))
-	container2 := newVirtualizationMachine(t, ConfigureNetworkDeviceWithNetwork(network))
+	container1 := newVirtualizationMachine(t, configureNetworkDevice(network1, macaddress1))
+	container2 := newVirtualizationMachine(t, configureNetworkDevice(network2, macaddress2))
 	t.Cleanup(func() {
 		if err := container1.Shutdown(); err != nil {
 			log.Println(err)
@@ -32,12 +49,12 @@ func TestVmnetSharedModeAllowsCommunicationBetweenMultipleVMs(t *testing.T) {
 	})
 
 	// Log network information
-	ipv4Subnet, err := network.IPv4Subnet()
+	ipv4Subnet, err := network1.IPv4Subnet()
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Logf("Vmnet network IPv4 subnet: %s", ipv4Subnet.String())
-	prefix, err := network.IPv6Prefix()
+	prefix, err := network1.IPv6Prefix()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -52,7 +69,68 @@ func TestVmnetSharedModeAllowsCommunicationBetweenMultipleVMs(t *testing.T) {
 	container2.exec(t, "ping "+container1IPv4)
 }
 
-func ConfigureNetworkDeviceWithNetwork(network *vz.VmnetNetwork) func(cfg *vz.VirtualMachineConfiguration) error {
+func TestVmnetSharedModeWithConfiguringIPv4(t *testing.T) {
+	if vz.Available(26.0) {
+		t.Skip("VmnetSharedMode is supported from macOS 26")
+	}
+	// Create VmnetNetwork instance from configuration
+	config, err := vz.NewVmnetNetworkConfiguration(vz.SharedMode)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Configure IPv4 subnet
+	ipv4Subnet := detectFreeIPv4Subnet(t, netip.MustParsePrefix("192.168.5.0/24"))
+	if err := config.SetIPv4Subnet(ipv4Subnet); err != nil {
+		t.Fatal(err)
+	}
+	// Configure DHCP reservation
+	macaddress := randomMACAddress(t)
+	ipv4 := "192.168.5.15"
+	config.AddDhcpReservation(macaddress, netip.MustParseAddr(ipv4))
+
+	// Create VmnetNetwork instance
+	network, err := vz.NewVmnetNetwork(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create VirtualizationMachine instance
+	container := newVirtualizationMachine(t, configureNetworkDevice(network, macaddress))
+	t.Cleanup(func() {
+		if err := container.Shutdown(); err != nil {
+			log.Println(err)
+		}
+	})
+
+	// Log network information
+	ipv4SubnetConfigured, err := network.IPv4Subnet()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("Vmnet network IPv4 subnet: %s", ipv4SubnetConfigured.String())
+
+	// Verify the configured subnet
+	// Compare with masked value to ignore host bits since Vmnet prefers to use first address as network address.
+	if ipv4Subnet != ipv4SubnetConfigured.Masked() {
+		t.Fatalf("expected IPv4 subnet %s, but got %s", ipv4Subnet.String(), ipv4SubnetConfigured.Masked().String())
+	}
+
+	// Log IPv6 prefix
+	prefix, err := network.IPv6Prefix()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("Vmnet network IPv6 prefix: %s", prefix.String())
+
+	// Detect IP address and verify DHCP reservation
+	containerIPv4 := container.DetectIPv4(t, "eth0")
+	t.Logf("Container IPv4: %s", containerIPv4)
+	if ipv4 != containerIPv4 {
+		t.Fatalf("expected IPv4 %s, but got %s", ipv4, containerIPv4)
+	}
+}
+
+func configureNetworkDevice(network *vz.VmnetNetwork, macAddress *vz.MACAddress) func(cfg *vz.VirtualMachineConfiguration) error {
 	return func(cfg *vz.VirtualMachineConfiguration) error {
 		var configurations []*vz.VirtioNetworkDeviceConfiguration
 		attachment, err := vz.NewVmnetNetworkDeviceAttachment(network)
@@ -63,8 +141,55 @@ func ConfigureNetworkDeviceWithNetwork(network *vz.VmnetNetwork) func(cfg *vz.Vi
 		if err != nil {
 			return err
 		}
+		config.SetMACAddress(macAddress)
 		configurations = append(configurations, config)
 		cfg.SetNetworkDevicesVirtualMachineConfiguration(configurations)
 		return nil
 	}
 }
+
+func detectFreeIPv4Subnet(t *testing.T, prefer netip.Prefix) netip.Prefix {
+	targetPrefix := netip.MustParsePrefix("192.168.0.0/16")
+	hostNetIfs, err := net.Interfaces()
+	if err != nil {
+		t.Fatal(err)
+	}
+	candidates := make([]netip.Prefix, len(hostNetIfs))
+	for _, hostNetIf := range hostNetIfs {
+		hostNetAddrs, err := hostNetIf.Addrs()
+		if err != nil {
+			continue
+		}
+		for _, hostNetAddr := range hostNetAddrs {
+			netIPNet, ok := hostNetAddr.(*net.IPNet)
+			if !ok {
+				continue
+			}
+			hostPrefix := netip.MustParsePrefix(netIPNet.String())
+			if targetPrefix.Overlaps(hostPrefix) {
+				candidates = append(candidates, hostPrefix)
+			}
+		}
+	}
+	slices.SortFunc(candidates, func(l, r netip.Prefix) int {
+		if l.Addr().Less(r.Addr()) {
+			return -1
+		}
+		return 1
+	})
+	for _, candidate := range candidates {
+		if prefer.Addr() != candidate.Addr() {
+			return prefer
+		}
+	}
+	t.Fatal("no free IPv4 subnet found")
+	return netip.Prefix{}
+}
+
+func randomMACAddress(t *testing.T) *vz.MACAddress {
+	mac, err := vz.NewRandomLocallyAdministeredMACAddress()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return mac
+}