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/error.go

@@ -0,0 +1,49 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"runtime/cgo"
+	"unsafe"
+)
+
+// Error represents an XPC rich error.
+// see: https://developer.apple.com/documentation/xpc/xpc_rich_error_t?language=objc
+type Error struct {
+	Object
+}
+
+var _ error = Error{}
+
+// newError creates a new Error from an existing xpc_rich_error_t.
+// internal use only.
+func newError(richErr unsafe.Pointer) *Error {
+	return &Error{
+		Object: Object{XpcObject: richErr},
+	}
+}
+
+// wrapError wraps an existing xpc_rich_error_t into an Error and returns a handle.
+// intended to be called from C.
+//
+//export wrapError
+func wrapError(richErr unsafe.Pointer) uintptr {
+	obj := newError(richErr)
+	obj.handle = cgo.NewHandle(obj)
+	return uintptr(obj.handle)
+}
+
+// unwrapError unwraps a handle into an *Error.
+func unwrapError(handle uintptr) *Error {
+	return cgo.Handle(handle).Value().(*Error)
+}
+
+// Error implements the error interface.
+func (e Error) Error() string {
+	desc := C.xpcRichErrorCopyDescription(e.XpcObject)
+	defer C.free(unsafe.Pointer(desc))
+	return C.GoString(desc)
+}

pkg/xpc/listener.go

@@ -0,0 +1,99 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"runtime/cgo"
+	"unsafe"
+)
+
+// Listener represents an XPC listener.
+type Listener struct {
+	// Exported for use in other packages since unimplemented XPC API may require direct access to xpc_listener_t.
+	XpcListener    unsafe.Pointer
+	queue          unsafe.Pointer
+	sessionHandler cgo.Handle
+}
+
+// SessionHandler is a function that handles incoming sessions.
+type SessionHandler func(session *Session)
+
+type listenerOption struct {
+	sessionHandler      SessionHandler
+	messageHandler      MessageHandler
+	cancellationHandler CancellationHandler
+	peerRequirement     *PeerRequirement
+}
+
+// NewListener creates a new XPC listener for the given service name.
+// You need to call [Listener.Activate] to start accepting incoming connections.
+func NewListener(service string, handler SessionHandler) (*Listener, error) {
+	cname := C.CString(service)
+	defer C.free(unsafe.Pointer(cname))
+	// Use a serial dispatch queue for the listener,
+	// because the vmnet framework API does not seem to work well with concurrent queues.
+	// For example, vmnet_network_create fails when using a concurrent queue.
+	queue := C.dispatchQueueCreateSerial(cname)
+	cgoSessionHandler := cgo.NewHandle(handler)
+
+	var err_out unsafe.Pointer
+	ptr := C.xpcListenerCreate(
+		cname,
+		queue,
+		C.XPC_LISTENER_CREATE_INACTIVE,
+		C.uintptr_t(cgoSessionHandler),
+		&err_out,
+	)
+	if err_out != nil {
+		C.dispatchRelease(queue)
+		cgoSessionHandler.Delete()
+		return nil, newError(err_out)
+	}
+	return &Listener{
+		XpcListener:    ptr,
+		queue:          queue,
+		sessionHandler: cgoSessionHandler,
+	}, nil
+}
+
+// Activate starts the listener to accept incoming connections.
+// see: https://developer.apple.com/documentation/xpc/xpc_listener_activate
+func (l *Listener) Activate() error {
+	var err_out unsafe.Pointer
+	C.xpcListenerActivate(l.XpcListener, &err_out)
+	if err_out != nil {
+		return newError(err_out)
+	}
+	return nil
+}
+
+// Close stops the listener from accepting incoming connections.
+// see: https://developer.apple.com/documentation/xpc/xpc_listener_cancel
+func (l *Listener) Close() error {
+	C.xpcListenerCancel(l.XpcListener)
+
+	C.xpcRelease(l.XpcListener)
+	if l.sessionHandler != 0 {
+		l.sessionHandler.Delete()
+		l.sessionHandler = 0
+	}
+	C.dispatchRelease(l.queue)
+	return nil
+}
+
+// SetPeerRequirement sets the peer requirement for the listener.
+// see: https://developer.apple.com/documentation/xpc/xpc_listener_set_peer_requirement
+func (l *Listener) SetPeerRequirement(req *PeerRequirement) {
+	C.xpcListenerSetPeerRequirement(l.XpcListener, req.XpcObject)
+}
+
+// String returns a description of the listener.
+// see: https://developer.apple.com/documentation/xpc/xpc_listener_copy_description
+func (l *Listener) String() string {
+	desc := C.xpcListenerCopyDescription(l.XpcListener)
+	defer C.free(unsafe.Pointer(desc))
+	return C.GoString(desc)
+}

pkg/xpc/object.go

@@ -0,0 +1,124 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=11 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import (
+	"runtime/cgo"
+	"unsafe"
+)
+
+// Object represents a generic XPC object.
+// see: https://developer.apple.com/documentation/xpc/xpc_object_t?language=objc
+type Object struct {
+	// Exported for use in other packages since unimplemented XPC API may require direct access to xpc_object_t.
+	XpcObject unsafe.Pointer
+	handle    cgo.Handle
+}
+
+// NewObject creates a new Object from an existing xpc_object_t.
+func NewObject(xpcObj unsafe.Pointer) *Object {
+	return &Object{XpcObject: xpcObj}
+}
+
+// wrapObject wraps an existing xpc_object_t into an Object and returns a handle.
+// intended to be called from C.
+//
+//export wrapObject
+func wrapObject(o unsafe.Pointer) uintptr {
+	obj := &Object{XpcObject: o}
+	obj.handle = cgo.NewHandle(obj)
+	return uintptr(obj.handle)
+}
+
+// unwrapObject unwraps a handle into an *Object.
+func unwrapObject(handle uintptr) *Object {
+	return cgo.Handle(handle).Value().(*Object)
+}
+
+// NewDictionary creates a new empty XPC dictionary object.
+// You can customize the dictionary object using DictionaryEntry.
+func NewDictionary(entries ...DictionaryEntry) *Object {
+	obj := &Object{XpcObject: C.xpcDictionaryCreateEmpty()}
+	for _, e := range entries {
+		e(obj)
+	}
+	return obj
+}
+
+// Retain retains the XPC object and returns itself.
+// see: https://developer.apple.com/documentation/xpc/xpc_retain?language=objc
+func (o *Object) Retain() *Object {
+	C.xpcRetain(o.XpcObject)
+	return o
+}
+
+// Release releases the XPC object.
+// see: https://developer.apple.com/documentation/xpc/xpc_release?language=objc
+func (o *Object) Release() {
+	if o.handle != 0 {
+		o.handle.Delete()
+		o.handle = 0
+	}
+	C.xpcRelease(o.XpcObject)
+}
+
+// DisctionaryGetString retrieves a string value from the XPC dictionary object by key.
+// Returns an empty string if the key does not exist.
+// see: https://developer.apple.com/documentation/xpc/xpc_dictionary_get_string(_:_:)?language=objc
+func (o *Object) DisctionaryGetString(key string) string {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	val := C.xpcDictionaryGetString(o.XpcObject, cKey)
+	return C.GoString(val)
+}
+
+// DisctionaryGetValue retrieves a value from the XPC dictionary object by key.
+// Returns nil if the key does not exist.
+// see: https://developer.apple.com/documentation/xpc/xpc_dictionary_get_value(_:_:)?language=objc
+func (o *Object) DisctionaryGetValue(key string) *Object {
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	val := C.xpcDictionaryGetValue(o.XpcObject, cKey)
+	if val == nil {
+		return nil
+	}
+	return NewObject(val)
+}
+
+// DictionaryEntry defines a function type for customizing reply objects.
+type DictionaryEntry func(*Object)
+
+// WithString sets a string value in the reply dictionary.
+func WithString(key, value string) DictionaryEntry {
+	return func(o *Object) {
+		cKey := C.CString(key)
+		defer C.free(unsafe.Pointer(cKey))
+		cValue := C.CString(value)
+		defer C.free(unsafe.Pointer(cValue))
+		C.xpcDictionarySetString(o.XpcObject, cKey, cValue)
+	}
+}
+
+// WithValue sets a value in the reply dictionary.
+func WithValue(key string, val *Object) DictionaryEntry {
+	return func(o *Object) {
+		cKey := C.CString(key)
+		defer C.free(unsafe.Pointer(cKey))
+		C.xpcDictionarySetValue(o.XpcObject, cKey, val.XpcObject)
+	}
+}
+
+// DisctionaryCreateReply creates a new reply XPC dictionary object based on the current object.
+// see: https://developer.apple.com/documentation/xpc/xpc_dictionary_create_reply(_:)?language=objc
+// You can customize the reply object using ReplyOption.
+func (o *Object) DisctionaryCreateReply(entries ...DictionaryEntry) *Object {
+	reply := C.xpcDictionaryCreateReply(o.XpcObject)
+	obj := NewObject(unsafe.Pointer(reply))
+	for _, entry := range entries {
+		entry(obj)
+	}
+	return obj
+}

pkg/xpc/peer_requirement.go

@@ -0,0 +1,31 @@
+package xpc
+
+/*
+#cgo darwin CFLAGS: -mmacosx-version-min=14 -x objective-c -fno-objc-arc
+# include "xpc.h"
+*/
+import "C"
+import "unsafe"
+
+// PeerRequirement represents an xpc_peer_requirement_t.
+// see: https://developer.apple.com/documentation/xpc/xpc_peer_requirement_t?language=objc
+type PeerRequirement struct {
+	Object
+}
+
+// CreatePeerRequirementLwcr creates a peer requirement from a LWCR object.
+// see: https://developer.apple.com/documentation/xpc/xpc_peer_requirement_create_lwcr
+// see: https://developer.apple.com/documentation/security/defining-launch-environment-and-library-constraints?language=objc
+func CreatePeerRequirementLwcr(lwcr *Object) (*PeerRequirement, error) {
+	var err_out unsafe.Pointer
+	ptr := C.xpcPeerRequirementCreateLwcr(
+		lwcr.XpcObject,
+		&err_out,
+	)
+	if err_out != nil {
+		return nil, newError(err_out)
+	}
+	return &PeerRequirement{
+		Object: Object{XpcObject: ptr},
+	}, nil
+}