vmnet_test.go: Add TestVmnetNetworkShareModeSharingOverXpc

- Add `TestVmnetNetworkShareModeSharingOverXpc` to `vmnet_test.go`
`TestVmnetNetworkShareModeSharingOverXpc` tests sharing `VmnetNetwork` in `SharedMode` over XPC communication.
This test registers test executable as an Mach service and launches it using `launchctl`.
The launched Mach service provides `VmnetNetwork` serialization to clients upon request, after booting
a VM using the provided `VmnetNetwork` to ensure the network is functional on the server side.
The client boots VM using the provided `VmnetNetwork` serialization.

This test uses `pkg/xpc` package to implement XPC communication.

- Add `pkg/xpc` package that providing `<xpc/xpc.h>` APIs to support implementing Mach service server and client

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

Author: norio-nomura

pkg/xpc/array.go

@@ -0,0 +1,82 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"iter"
+	"runtime/cgo"
+	"unsafe"
+)
+
+// Array represents an XPC array([XPC_TYPE_ARRAY]) object. [TypeArray]
+//
+// [XPC_TYPE_ARRAY]: https://developer.apple.com/documentation/xpc/xpc_type_array-c.macro?language=objc
+type Array struct {
+	*XpcObject
+}
+
+var _ Object = &Array{}
+
+// NewArray creates a new [Array] from the given [Object]s.
+//
+//   - https://developer.apple.com/documentation/xpc/xpc_array_create(_:_:)?language=objc
+func NewArray(objects ...Object) *Array {
+	cObjects := make([]unsafe.Pointer, len(objects))
+	for i, obj := range objects {
+		cObjects[i] = obj.Raw()
+	}
+	xpcObject := &XpcObject{C.xpcArrayCreate(
+		(*unsafe.Pointer)(unsafe.Pointer(&cObjects[0])),
+		C.size_t(len(cObjects)),
+	)}
+	a := &Array{XpcObject: xpcObject}
+	return a
+}
+
+// Count returns the number of elements in the [Array].
+//
+//   - https://developer.apple.com/documentation/xpc/xpc_array_get_count(_:)?language=objc
+func (a *Array) Count() int {
+	return int(C.xpcArrayGetCount(a.Raw()))
+}
+
+// ArrayApplier is a function type for applying to each element in the Array.
+type ArrayApplier func(uint64, Object) bool
+
+// callArrayApplier is called from C to apply a function to each element in the Array.
+//
+//export callArrayApplier
+func callArrayApplier(cgoApplier uintptr, index C.size_t, cgoValue uintptr) C.bool {
+	applier := unwrapHandler[ArrayApplier](cgoApplier)
+	value := unwrapObject[Object](cgoValue)
+	result := applier(uint64(index), value)
+	return C.bool(result)
+}
+
+// All iterates over all elements in the [Array].
+//
+//   - https://developer.apple.com/documentation/xpc/xpc_array_apply(_:_:)?language=objc
+func (a *Array) All() iter.Seq2[uint64, Object] {
+	return func(yieald func(uint64, Object) bool) {
+		cgoApplier := cgo.NewHandle(ArrayApplier(yieald))
+		defer cgoApplier.Delete()
+		_ = C.xpcArrayApply(
+			a.Raw(),
+			C.uintptr_t(cgoApplier),
+		)
+	}
+}
+
+// Values iterates over all values in the [Array] using [Array.All].
+func (a *Array) Values() iter.Seq[Object] {
+	return func(yieald func(Object) bool) {
+		for _, value := range a.All() {
+			if !yieald(value) {
+				return
+			}
+		}
+	}
+}

pkg/xpc/cgo_handle.go

@@ -0,0 +1,42 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import "runtime/cgo"
+
+// cgoHandler holds a cgo.Handle for an Object.
+// It provides methods to hold and release the handle.
+// handle will released when cgoHandler.release is called.
+type cgoHandler struct {
+	handle cgo.Handle
+}
+
+// release releases the cgo.Handle.
+func (h *cgoHandler) release() {
+	if h.handle != 0 {
+		h.handle.Delete()
+		h.handle = 0
+	}
+}
+
+// newCgoHandler creates a new cgoHandler and holds the given value.
+func newCgoHandler(v any) (*cgoHandler, C.uintptr_t) {
+	if v == nil {
+		return nil, 0
+	}
+	h := &cgoHandler{cgo.NewHandle(v)}
+	return ReleaseInFinalizer(h), C.uintptr_t(h.handle)
+}
+
+// unwrapHandler unwraps the cgo.Handle from the given uintptr and returns the associated value.
+// It does NOT delete the handle; it expects the handle to be managed by cgoHandler or caller.
+func unwrapHandler[T any](handle uintptr) T {
+	if handle == 0 {
+		var zero T
+		return zero
+	}
+	return cgo.Handle(handle).Value().(T)
+}

pkg/xpc/dictionary.go

@@ -0,0 +1,169 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"fmt"
+	"iter"
+	"runtime/cgo"
+	"unsafe"
+)
+
+// Dictionary represents an XPC dictionary (XPC_TYPE_DICTIONARY) object. [TypeDictionary]
+//   - https://developer.apple.com/documentation/xpc/xpc_type_dictionary-c.macro?language=objc
+type Dictionary struct {
+	*XpcObject
+}
+
+var _ Object = &Dictionary{}
+
+// NewDictionary creates a new empty [Dictionary] object and applies the given entries.
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_create_empty()?language=objc
+//
+// The entries can be created using [DictionaryEntry] functions such as [KeyValue].
+func NewDictionary(entries ...DictionaryEntry) *Dictionary {
+	d := &Dictionary{XpcObject: &XpcObject{C.xpcDictionaryCreateEmpty()}}
+	for _, e := range entries {
+		e(d)
+	}
+	return d
+}
+
+// DictionaryEntry defines a function type for customizing [NewDictionary] or [Dictionary.CreateReply].
+type DictionaryEntry func(*Dictionary)
+
+// KeyValue sets a [Object] value for the given key in the [Dictionary].
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_set_value(_:_:_:)?language=objc
+func KeyValue(key string, val Object) DictionaryEntry {
+	return func(o *Dictionary) {
+		o.SetValue(key, val)
+	}
+}
+
+// DictionaryApplier is a function type for applying to each key-value pair in the XPC dictionary.
+type DictionaryApplier func(string, Object) bool
+
+// callDictionaryApplier is called from C to apply a function to each key-value pair in the XPC dictionary object.
+//
+//export callDictionaryApplier
+func callDictionaryApplier(cgoApplier uintptr, cKey *C.char, cgoValue uintptr) C.bool {
+	applier := unwrapHandler[DictionaryApplier](cgoApplier)
+	return C.bool(applier(C.GoString(cKey), unwrapObject[Object](cgoValue)))
+}
+
+// All iterates over all key-value pairs in the [Dictionary].
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_apply(_:_:)?language=objc
+func (o *Dictionary) All() iter.Seq2[string, Object] {
+	return func(yieald func(string, Object) bool) {
+		cgoApplier := cgo.NewHandle(DictionaryApplier(yieald))
+		defer cgoApplier.Delete()
+		C.xpcDictionaryApply(o.Raw(), C.uintptr_t(cgoApplier))
+	}
+}
+
+// Keys iterates over all keys in the [Dictionary] using [Dictionary.All].
+func (o *Dictionary) Keys() iter.Seq[string] {
+	return func(yieald func(string) bool) {
+		for key := range o.All() {
+			if !yieald(key) {
+				return
+			}
+		}
+	}
+}
+
+// Values iterates over all [Object] values in the [Dictionary] using [Dictionary.All].
+func (o *Dictionary) Values() iter.Seq[Object] {
+	return func(yieald func(Object) bool) {
+		for _, value := range o.All() {
+			if !yieald(value) {
+				return
+			}
+		}
+	}
+}
+
+// Entries iterates over all [DictionaryEntry] entries in the [Dictionary] using [Dictionary.All].
+func (o *Dictionary) Entries() iter.Seq[DictionaryEntry] {
+	return func(yieald func(DictionaryEntry) bool) {
+		for key, value := range o.All() {
+			if !yieald(KeyValue(key, value)) {
+				return
+			}
+		}
+	}
+}
+
+// GetData retrieves a byte slice value from the [Dictionary] by key.
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_get_data(_:_:_:)?language=objc
+//
+// Returns nil if the key does not exist.
+func (o *Dictionary) GetData(key string) []byte {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	var n C.size_t
+	p := C.xpcDictionaryGetData(o.Raw(), cKey, &n)
+	if p == nil || n == 0 {
+		return nil
+	}
+	return C.GoBytes(p, C.int(n))
+}
+
+// GetString retrieves a string value from the [Dictionary] by key.
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_get_string(_:_:)?language=objc
+//
+// Returns an empty string if the key does not exist.
+func (o *Dictionary) GetString(key string) string {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	val := C.xpcDictionaryGetString(o.Raw(), cKey)
+	return C.GoString(val)
+}
+
+// SetValue sets an [Object] value for the given key in the [Dictionary].
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_set_value(_:_:_:)?language=objc
+func (o *Dictionary) SetValue(key string, val Object) {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	C.xpcDictionarySetValue(o.Raw(), cKey, val.Raw())
+}
+
+// GetValue retrieves an [Object] value from the [Dictionary] by key.
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_get_value(_:_:)?language=objc
+//
+// Returns nil if the key does not exist.
+func (o *Dictionary) GetValue(key string) Object {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	val := C.xpcDictionaryGetValue(o.Raw(), cKey)
+	if val == nil {
+		return nil
+	}
+	return NewObject(val)
+}
+
+// DictionaryCreateReply creates a new reply [Dictionary] based on the current [Dictionary].
+//   - https://developer.apple.com/documentation/xpc/xpc_dictionary_create_reply(_:)?language=objc
+//
+// The entries can be created using [DictionaryEntry] functions such as [KeyValue].
+func (o *Dictionary) CreateReply(entries ...DictionaryEntry) *Dictionary {
+	d := &Dictionary{XpcObject: &XpcObject{C.xpcDictionaryCreateReply(o.Raw())}}
+	for _, entry := range entries {
+		entry(d)
+	}
+	return d
+}
+
+// SenderSatisfies checks if the sender of the message [Dictionary] satisfies the given [PeerRequirement].
+//   - https://developer.apple.com/documentation/xpc/xpc_peer_requirement_match_received_message?language=objc
+func (d *Dictionary) SenderSatisfies(requirement *PeerRequirement) (bool, error) {
+	var err_out unsafe.Pointer
+	res := C.xpcPeerRequirementMatchReceivedMessage(requirement.Raw(), d.Raw(), &err_out)
+	if err_out != nil {
+		return false, fmt.Errorf("error matching peer requirement: %w", newRichError(err_out))
+	}
+	return bool(res), nil
+}

pkg/xpc/error.go

@@ -0,0 +1,46 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+// RichError represents an XPC rich error. ([XPC_TYPE_RICH_ERROR]) [TypeRichError]
+//
+// [XPC_TYPE_RICH_ERROR]: https://developer.apple.com/documentation/xpc/xpc_rich_error_t?language=objc
+type RichError struct {
+	*XpcObject
+}
+
+var _ Object = &RichError{}
+
+var _ error = RichError{}
+
+// newRichError creates a new RichError from an existing xpc_rich_error_t.
+// internal use only.
+func newRichError(richErr unsafe.Pointer) *RichError {
+	if richErr == nil {
+		return nil
+	}
+	return &RichError{XpcObject: &XpcObject{richErr}}
+}
+
+// CanRetry indicates whether the operation that caused the [RichError] can be retried.
+//
+//   - https://developer.apple.com/documentation/xpc/xpc_rich_error_can_retry(_:)?language=objc
+func (e RichError) CanRetry() bool {
+	return bool(C.xpcRichErrorCanRetry(e.Raw()))
+}
+
+// Error implements the [error] interface.
+//
+//   - https://developer.apple.com/documentation/xpc/xpc_rich_error_copy_description(_:)?language=objc
+func (e RichError) Error() string {
+	desc := C.xpcRichErrorCopyDescription(e.Raw())
+	defer C.free(unsafe.Pointer(desc))
+	return C.GoString(desc)
+}