[applevz] Additional networks

src/platform/backends/applevz/CMakeLists.txt

@@ -21,18 +21,21 @@ add_library(applevz_backend STATIC
   applevz_bridge.mm
   applevz_wrapper.cpp
   applevz_utils.mm
+  applevz_vmnet.mm
 )
 
 set_source_files_properties(
   applevz_bridge.mm
   applevz_utils.mm
+  applevz_vmnet.mm
   PROPERTIES
   LANGUAGE OBJCXX
   COMPILE_FLAGS "-fobjc-arc"
 )
 
 find_library(FOUNDATION_FRAMEWORK Foundation REQUIRED)
 find_library(VIRTUALIZATION_FRAMEWORK Virtualization REQUIRED)
+find_library(VMNET_FRAMEWORK vmnet REQUIRED)
 
 target_link_libraries(applevz_backend
   PUBLIC
@@ -43,4 +46,5 @@ target_link_libraries(applevz_backend
     daemon
     ${FOUNDATION_FRAMEWORK}
     ${VIRTUALIZATION_FRAMEWORK}
+    ${VMNET_FRAMEWORK}
     Qt6::Core)

src/platform/backends/applevz/applevz_bridge.h

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <applevz/cf_error.h>
+#include <multipass/network_interface_info.h>
 #include <multipass/virtual_machine_description.h>
 
 #include <fmt/format.h>
@@ -63,6 +64,9 @@ bool can_stop(const VMHandle& vm_handle);
 bool can_request_stop(const VMHandle& vm_handle);
 
 bool is_supported();
+
+// Networking
+std::vector<NetworkInterfaceInfo> bridged_network_interfaces();
 } // namespace multipass::applevz
 
 template <>

src/platform/backends/applevz/applevz_bridge.mm

@@ -16,6 +16,7 @@
  */
 
 #include <applevz/applevz_bridge.h>
+#include <applevz/applevz_vmnet.h>
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <Foundation/Foundation.h>
@@ -29,13 +30,16 @@
 #include <QString>
 #include <QUrl>
 
+#include <cassert>
+
 namespace multipass::applevz
 {
 struct VirtualMachineHandle
 {
-    std::shared_ptr<void> vm; // Ownership transfer of VZVirtualMachine*
-    dispatch_queue_t queue;   // Dispatch queue for VM operations
-    uint64_t id;              // Unique VM ID
+    std::shared_ptr<void> vm;             // Ownership transfer of VZVirtualMachine*
+    dispatch_queue_t queue;               // Dispatch queue for VM operations
+    uint64_t id;                          // Unique VM ID
+    std::vector<VmnetRelayHandle> relays; // vmnet relay lifetime handles
 };
 } // namespace multipass::applevz
 
@@ -172,18 +176,40 @@ CFError init_with_configuration(const multipass::VirtualMachineDescription& desc
             [[VZVirtioEntropyDeviceConfiguration alloc] init];
         config.entropyDevices = @[ entropy ];
 
-        // Network device
+        // Network devices
+        // Primary NAT interface
+        NSMutableArray<VZNetworkDeviceConfiguration*>* networkDevices = [NSMutableArray array];
+
         VZVirtioNetworkDeviceConfiguration* netDevice =
             [[VZVirtioNetworkDeviceConfiguration alloc] init];
-
         VZNATNetworkDeviceAttachment* natAttachment = [[VZNATNetworkDeviceAttachment alloc] init];
         netDevice.attachment = natAttachment;
 
         VZMACAddress* mac =
             [[VZMACAddress alloc] initWithString:nsstring_from_stdstring(desc.default_mac_address)];
         [netDevice setMACAddress:mac];
+        [networkDevices addObject:netDevice];
+
+        // Extra bridged interfaces
+        std::vector<VmnetRelayHandle> relays;
+        for (const auto& extra : desc.extra_interfaces)
+        {
+            VmnetBridge bridge = create_vmnet_bridge(extra.id);
+
+            VZVirtioNetworkDeviceConfiguration* bridgedDevice =
+                [[VZVirtioNetworkDeviceConfiguration alloc] init];
+            bridgedDevice.attachment = bridge.attachment;
+            VZMACAddress* bridgedMac = [[VZMACAddress alloc]
+                initWithString:[NSString stringWithCString:extra.mac_address.c_str()
+                                                  encoding:NSUTF8StringEncoding]];
+            [bridgedDevice setMACAddress:bridgedMac];
+
+            [networkDevices addObject:bridgedDevice];
+
+            relays.push_back(std::move(bridge.relay));
+        }
 
-        config.networkDevices = @[ netDevice ];
+        config.networkDevices = networkDevices;
 
         // Memory balloon device
         VZVirtioTraditionalMemoryBalloonDeviceConfiguration* balloon =
@@ -197,7 +223,7 @@ CFError init_with_configuration(const multipass::VirtualMachineDescription& desc
         }
 
         out_handle = std::make_shared<VirtualMachineHandle>();
-
+        out_handle->relays = std::move(relays);
         out_handle->id = vmIDCounter.fetch_add(1, std::memory_order_relaxed);
 
         // Create dispatch queue
@@ -306,4 +332,20 @@ bool is_supported()
 {
     return [VZVirtualMachine isSupported];
 }
+
+std::vector<NetworkInterfaceInfo> bridged_network_interfaces()
+{
+    std::vector<NetworkInterfaceInfo> result;
+
+    for (VZBridgedNetworkInterface* iface in [VZBridgedNetworkInterface networkInterfaces])
+    {
+        result.emplace_back(/* id = */ iface.identifier.UTF8String,
+                            /* type = */ "N/A",
+                            /* description = */ iface.localizedDisplayName
+                                ? std::string(iface.localizedDisplayName.UTF8String)
+                                : iface.identifier.UTF8String);
+    }
+
+    return result;
+}
 } // namespace multipass::applevz

src/platform/backends/applevz/applevz_virtual_machine_factory.cpp

@@ -67,6 +67,16 @@ void AppleVZVirtualMachineFactory::remove_resources_for_impl(const std::string&
 {
 }
 
+std::vector<NetworkInterfaceInfo> AppleVZVirtualMachineFactory::networks() const
+{
+    return MP_APPLEVZ.bridged_network_interfaces();
+}
+
+std::string AppleVZVirtualMachineFactory::create_bridge_with(const NetworkInterfaceInfo& interface)
+{
+    return interface.id;
+}
+
 VirtualMachine::UPtr AppleVZVirtualMachineFactory::clone_vm_impl(
     const std::string& /*source_vm_name*/,
     const multipass::VMSpecs& /*src_vm_specs*/,

src/platform/backends/applevz/applevz_virtual_machine_factory.h

@@ -47,8 +47,11 @@ class AppleVZVirtualMachineFactory final : public BaseVirtualMachineFactory
         return "applevz";
     };
 
+    std::vector<NetworkInterfaceInfo> networks() const override;
+
 protected:
     void remove_resources_for_impl(const std::string& name) override;
+    std::string create_bridge_with(const NetworkInterfaceInfo& interface) override;
 
 private:
     VirtualMachine::UPtr clone_vm_impl(const std::string& source_vm_name,

src/platform/backends/applevz/applevz_vmnet.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <Virtualization/Virtualization.h>
+
+#include <memory>
+
+namespace multipass::applevz
+{
+
+// Opaque handle whose lifetime must exceed that of the attachment it was created with.
+using VmnetRelayHandle = std::shared_ptr<void>;
+
+struct VmnetBridge
+{
+    VZFileHandleNetworkDeviceAttachment* attachment;
+    VmnetRelayHandle relay;
+};
+
+VmnetBridge create_vmnet_bridge(const std::string& physical_iface);
+
+} // namespace multipass::applevz