vmnet: Add Interface related APIs and *FileAdaptorForInterfaces

Signed-off-by: Norio Nomura <norio.nomura@gmail.com>

Author: norio-nomura

cgoutil.go

@@ -1,7 +1,7 @@
 package vz
 
 /*
-#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
 #cgo darwin LDFLAGS: -lobjc -framework Foundation
 #import <Foundation/Foundation.h>
 

internal/cgohandler/cgohandler.go

@@ -1,9 +1,5 @@
 package cgohandler
 
-/*
-# include <stdint.h>
-*/
-import "C"
 import (
 	"runtime"
 	"runtime/cgo"

network.go

@@ -13,9 +13,9 @@ import (
 	"net"
 	"os"
 	"syscall"
-	"unsafe"
 
 	"github.com/Code-Hex/vz/v3/internal/objc"
+	"github.com/Code-Hex/vz/v3/vmnet"
 )
 
 // BridgedNetwork defines a network interface that bridges a physical interface with a virtual machine.
@@ -280,8 +280,9 @@ func (*VmnetNetworkDeviceAttachment) String() string {
 	return "VmnetNetworkDeviceAttachment"
 }
 
-func (v *VmnetNetworkDeviceAttachment) Network() unsafe.Pointer {
-	return C.VZVmnetNetworkDeviceAttachment_network(objc.Ptr(v))
+func (v *VmnetNetworkDeviceAttachment) Network() *vmnet.Network {
+	ptr := C.VZVmnetNetworkDeviceAttachment_network(objc.Ptr(v))
+	return vmnet.NewNetworkFromPointer(objc.NewPointer(ptr))
 }
 
 var _ NetworkDeviceAttachment = (*VmnetNetworkDeviceAttachment)(nil)
@@ -290,14 +291,14 @@ var _ NetworkDeviceAttachment = (*VmnetNetworkDeviceAttachment)(nil)
 //
 // This is only supported on macOS 26 and newer, error will
 // be returned on older versions.
-func NewVmnetNetworkDeviceAttachment(network unsafe.Pointer) (*VmnetNetworkDeviceAttachment, error) {
+func NewVmnetNetworkDeviceAttachment(network *vmnet.Network) (*VmnetNetworkDeviceAttachment, error) {
 	if err := macOSAvailable(26); err != nil {
 		return nil, err
 	}
 
 	attachment := &VmnetNetworkDeviceAttachment{
 		pointer: objc.NewPointer(
-			C.newVZVmnetNetworkDeviceAttachment(network),
+			C.newVZVmnetNetworkDeviceAttachment(objc.Ptr(network)),
 		),
 	}
 	objc.SetFinalizer(attachment, func(self *VmnetNetworkDeviceAttachment) {

vmnet/datagram_darwin.go

@@ -0,0 +1,246 @@
+package vmnet
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+#cgo darwin LDFLAGS: -lobjc -framework Foundation -framework vmnet
+# include "vmnet_darwin.h"
+*/
+import "C"
+import (
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"syscall"
+)
+
+// MARK: - DatagramFileAdaptorForInterface
+
+// DatagramFileAdaptorForInterface returns a file for the given [Network].
+//   - It starts goroutines to handle packet transfer between the vmnet interface and the file.
+//   - The context can be used to stop the goroutines and the interface.
+//   - The returned error channel can be used to receive errors from the goroutines.
+//
+// The returned file can be used as a file descriptor for QEMU's netdev datagram backend or VZ's [NewFileHandleNetworkDeviceAttachment]
+// QEMU:
+//
+//	-netdev datagram,id=net0,addr.type=fd,addr.str=<file descriptor>
+//
+// VZ:
+//
+//	file, errCh, err := DatagramFileAdaptorForInterface(ctx, iface)
+//	attachment := NewFileHandleNetworkDeviceAttachment(file)
+var DatagramFileAdaptorForInterface = FileAdaptorToInterface[*DatagramPacketForwarder, net.PacketConn]
+
+// MARK: - DatagramPacketForwarder for datagram file adaptor
+
+// DatagramPacketForwarder implements PacketForwarder for datagram file descriptor.
+type DatagramPacketForwarder struct {
+	readPktDescsManager  *pktDescsManager
+	writePktDescsManager *pktDescsManager
+}
+
+var _ PacketForwarder[net.PacketConn] = (*DatagramPacketForwarder)(nil)
+
+// New creates a new DatagramPacketForwarder.
+func (f *DatagramPacketForwarder) New() PacketForwarder[net.PacketConn] {
+	return &DatagramPacketForwarder{}
+}
+
+// Sockopts returns socket options for the given Interface and user desired options.
+// Default values are based on the following references:
+//   - https://developer.apple.com/documentation/virtualization/vzfilehandlenetworkdeviceattachment/maximumtransmissionunit?language=objc
+func (*DatagramPacketForwarder) Sockopts(iface *Interface, userOpts Sockopts) Sockopts {
+	return sockoptsForPacketConn(iface, userOpts)
+}
+
+// ConnAndFile creates a [net.PacketConn] and *[os.File] pair using [syscall.Socketpair].
+func (f *DatagramPacketForwarder) ConnAndFile(opts Sockopts) (net.PacketConn, *os.File, error) {
+	return packetConnAndFile(opts)
+}
+
+// AllocateBuffers allocates packet descriptor buffers for reading and writing packets.
+func (f *DatagramPacketForwarder) AllocateBuffers(iface *Interface) error {
+	f.readPktDescsManager = newPktDescsManager(iface.MaxReadPacketCount, iface.MaxPacketSize)
+	f.writePktDescsManager = newPktDescsManager(iface.MaxWritePacketCount, iface.MaxPacketSize)
+	return nil
+}
+
+// ReadPacketsFromInterface reads packets from the vmnet Interface.
+func (f *DatagramPacketForwarder) ReadPacketsFromInterface(iface *Interface, estimatedCount int) (int, error) {
+	f.readPktDescsManager.reset()
+	return iface.ReadPackets(f.readPktDescsManager.pktDescs, estimatedCount)
+}
+
+// WritePacketsToConn writes packets to the connection.
+func (f *DatagramPacketForwarder) WritePacketsToConn(conn net.PacketConn, packetCount int) (int, error) {
+	_, err := f.readPktDescsManager.writePacketsToPacketConn(conn, packetCount)
+	if err != nil {
+		return 0, err
+	}
+	return packetCount, nil
+}
+
+// ReadPacketsFromConn reads packets from the connection.
+func (f *DatagramPacketForwarder) ReadPacketsFromConn(conn net.PacketConn) (int, error) {
+	return f.writePktDescsManager.readPacketsFromPacketConn(conn)
+}
+
+// WritePacketsToInterface writes packets to the vmnet Interface.
+func (f *DatagramPacketForwarder) WritePacketsToInterface(iface *Interface, packetCount int) (int, error) {
+	return iface.WritePackets(f.writePktDescsManager.pktDescs, packetCount)
+}
+
+// sockoptsForPacketConn returns socket options for the given [Interface] and user desired options for [net.PacketConn].
+// Default values are based on the following references:
+//   - https://developer.apple.com/documentation/virtualization/vzfilehandlenetworkdeviceattachment/maximumtransmissionunit?language=objc
+func sockoptsForPacketConn(iface *Interface, userOpts Sockopts) Sockopts {
+	// Calculate minimum buffer sizes based on interface configuration
+	packetSize := int(iface.MaxPacketSize)
+	minPacketCount := max(iface.MaxReadPacketCount, iface.MaxWritePacketCount)
+	minSendBufSize := packetSize
+	minRecvBufSize := minSendBufSize * minPacketCount
+
+	// Default socket options
+	sockopts := Sockopts{
+		ReceiveBufferSize: minRecvBufSize * 4,
+		SendBufferSize:    packetSize,
+	}
+	// If user specified options, override with minimums as needed
+	if userOpts.ReceiveBufferSize > 0 {
+		sockopts.ReceiveBufferSize = max(userOpts.ReceiveBufferSize, minRecvBufSize)
+	}
+	if userOpts.SendBufferSize > 0 {
+		sockopts.SendBufferSize = max(userOpts.SendBufferSize, minSendBufSize)
+	}
+	return sockopts
+}
+
+// packetConnAndFile creates a [net.PacketConn] and *[os.File] pair using [syscall.Socketpair].
+func packetConnAndFile(opts Sockopts) (net.PacketConn, *os.File, error) {
+	sendBufSize, recvBufSize := opts.SendBufferSize, opts.ReceiveBufferSize
+	connFile, file, err := filePair(syscall.SOCK_DGRAM, sendBufSize, recvBufSize)
+	if err != nil {
+		return nil, nil, fmt.Errorf("ConnAndFile failed: %w", err)
+	}
+	conn, err := net.FilePacketConn(connFile)
+	if err != nil {
+		connFile.Close()
+		file.Close()
+		return nil, nil, fmt.Errorf("net.FilePacketConn failed: %w", err)
+	}
+	if err = connFile.Close(); err != nil {
+		conn.Close()
+		file.Close()
+		return nil, nil, fmt.Errorf("failed to close connFile: %w", err)
+	}
+	return conn, file, nil
+}
+
+// MARK: - pktDescsManager methods for datagram file adaptor
+
+// buffersForWritingToPacketConn returns [net.Buffers] to write to the [net.PacketConn]
+// adjusted their buffer sizes based vm_pkt_size in [VMPktDesc]s read from [Interface].
+// The 4-byte header is excluded.
+func (v *pktDescsManager) buffersForWritingToPacketConn(packetCount int) (net.Buffers, error) {
+	for i, vmPktDesc := range v.iter(packetCount) {
+		if uint64(vmPktDesc.vm_pkt_size) > v.maxPacketSize {
+			return nil, fmt.Errorf("vm_pkt_size %d exceeds maxPacketSize %d", vmPktDesc.vm_pkt_size, v.maxPacketSize)
+		}
+		// Resize buffer to exclude the 4-byte header
+		v.writingBuffers[i] = v.backingBuffers[i][headerSize : headerSize+uintptr(vmPktDesc.vm_pkt_size)]
+	}
+	return v.writingBuffers[:packetCount], nil
+}
+
+// writePacketsToPacketConn writes packets from VMPktDescs to the net.PacketConn.
+//   - It returns the number of packets written.
+func (v *pktDescsManager) writePacketsToPacketConn(conn net.PacketConn, packetCount int) (int64, error) {
+	buffers, err := v.buffersForWritingToPacketConn(packetCount)
+	if err != nil {
+		return 0, fmt.Errorf("buffersForWritingToPacketConn failed: %w", err)
+	}
+	// Get rawConn for syscall.Sendto
+	rawConn, _ := conn.(syscall.Conn).SyscallConn()
+
+	written := 0
+	for written < packetCount {
+		var sendtoErr error
+		rawConnWriteErr := rawConn.Write(func(fd uintptr) (done bool) {
+			for written < packetCount {
+				// send packet from buffer
+				if err := syscall.Sendmsg(int(fd), buffers[written], nil, nil, 0); err != nil {
+					if errors.Is(err, syscall.EAGAIN) {
+						return false // try again later
+					}
+					sendtoErr = fmt.Errorf("syscall.Sendmsg failed: %w", err)
+					return true
+				}
+				written++
+			}
+			return true
+		})
+		if rawConnWriteErr != nil {
+			return int64(written), fmt.Errorf("rawConn.Write failed: %w", rawConnWriteErr)
+		}
+		if sendtoErr != nil {
+			return int64(written), sendtoErr
+		}
+	}
+	return int64(packetCount), nil
+}
+
+// readPacketsFromPacketConn reads packets from the [net.PacketConn] into [VMPktDesc]s.
+//   - It returns the number of packets read.
+//   - The packets are expected to come one by one.
+//   - It receives all available packets until no more packets are available, packetCount reaches maxPacketCount, or an error occurs.
+//   - It waits for the connection to be ready for initial packet.
+func (v *pktDescsManager) readPacketsFromPacketConn(conn net.PacketConn) (int, error) {
+	var packetCount int
+	// Wait until 4-byte header is read
+	n, _, err := conn.ReadFrom(v.backingBuffers[packetCount][headerSize:])
+	if n == 0 {
+		// normal closure
+		return 0, errors.New("conn.ReadFrom: use of closed network connection")
+	}
+	if err != nil {
+		return 0, fmt.Errorf("conn.ReadFrom failed: %w", err)
+	}
+	v.at(packetCount).SetPacketSize(n)
+	packetCount++
+	// Get rawConn for syscall.Recvfrom
+	rawConn, _ := conn.(syscall.Conn).SyscallConn()
+	// Read available packets
+	for packetCount < v.maxPacketCount {
+		// Read packet from the connection
+		var bytesHasBeenRead int
+		var err error
+		rawConnReadErr := rawConn.Read(func(fd uintptr) (done bool) {
+			for packetCount < v.maxPacketCount {
+				// receive packet into buffer
+				bytesHasBeenRead, _, err = syscall.Recvfrom(int(fd), v.backingBuffers[packetCount][headerSize:], 0)
+				if err != nil {
+					return true
+				}
+				v.at(packetCount).SetPacketSize(bytesHasBeenRead)
+				packetCount++
+			}
+			return true
+		})
+		if rawConnReadErr != nil {
+			return 0, fmt.Errorf("rawConn.Read failed: %w", rawConnReadErr)
+		}
+		if err != nil {
+			if errors.Is(err, syscall.EAGAIN) {
+				// no more packets available, normal closure
+				break
+			}
+			return 0, fmt.Errorf("closure in rawConn.Read failed: %w", err)
+		}
+		if bytesHasBeenRead == 0 {
+			// no more packets available, normal closure
+			break
+		}
+	}
+	return packetCount, nil
+}