Merge branch '2.2' into 3.0

# Conflicts:
#	gns3server/compute/builtin/nodes/cloud.py
#	gns3server/compute/vmware/vmware_vm.py
#	gns3server/controller/link.py
#	gns3server/controller/snapshot.py
#	gns3server/handlers/api/compute/dynamips_vm_handler.py
#	gns3server/handlers/api/compute/iou_handler.py
#	gns3server/handlers/api/compute/qemu_handler.py
#	gns3server/handlers/api/controller/link_handler.py
#	gns3server/schemas/link.py
#	gns3server/utils/path.py
#	gns3server/version.py
#	requirements.txt

gns3server/compute/builtin/nodes/cloud.py

@@ -430,6 +430,7 @@ class Cloud(BaseNode):
             await self._add_ubridge_connection(nio, port_number)
             self._nios[port_number] = nio
         except (NodeError, UbridgeError) as e:
+            log.error('Cannot add NIO on cloud "{name}": {error}'.format(name=self._name, error=e))
             await self._stop_ubridge()
             self.status = "stopped"
             self._nios[port_number] = nio

gns3server/compute/vmware/__init__.py

@@ -26,6 +26,7 @@ import asyncio
 import subprocess
 import logging
 import codecs
+import ipaddress
 
 from collections import OrderedDict
 from gns3server.utils.interfaces import interfaces
@@ -50,6 +51,7 @@ class VMware(BaseManager):
         self._vmrun_path = None
         self._host_type = None
         self._vmnets = []
+        self._vmnets_info = {}
         self._vmnet_start_range = 2
         if sys.platform.startswith("win"):
             self._vmnet_end_range = 19
@@ -277,7 +279,7 @@ class VMware(BaseManager):
         else:
             # location on Linux
             vmware_networking_file = "/etc/vmware/networking"
-        vmnet_interfaces = []
+        vmnet_interfaces = {}
         try:
             with open(vmware_networking_file, encoding="utf-8") as f:
                 for line in f.read().splitlines():
@@ -285,7 +287,20 @@ class VMware(BaseManager):
                     if match:
                         vmnet = f"vmnet{match.group(1)}"
                         if vmnet not in ("vmnet0", "vmnet1", "vmnet8"):
-                            vmnet_interfaces.append(vmnet)
+                            vmnet_interfaces[vmnet] = {}
+            with open(vmware_networking_file, "r", encoding="utf-8") as f:
+                for line in f.read().splitlines():
+                    match = re.search(r"VNET_([0-9]+)_HOSTONLY_SUBNET\s+(.*)", line)
+                    if match:
+                        vmnet = "vmnet{}".format(match.group(1))
+                        if vmnet in vmnet_interfaces.keys():
+                            vmnet_interfaces[vmnet]["subnet"] = match.group(2)
+                    match = re.search(r"VNET_([0-9]+)_HOSTONLY_NETMASK\s+(.*)", line)
+                    if match:
+                        vmnet = "vmnet{}".format(match.group(1))
+                        if vmnet in vmnet_interfaces.keys():
+                            vmnet_interfaces[vmnet]["netmask"] = match.group(2)
+
         except OSError as e:
             raise VMwareError(f"Cannot open {vmware_networking_file}: {e}")
         return vmnet_interfaces
@@ -330,6 +345,25 @@ class VMware(BaseManager):
             )
         return self._vmnets.pop(0)
 
+    def find_bridge_interface(self, vmnet_interface):
+        """
+        Find the bridge interface that is used for the vmnet interface in VMware.
+        """
+
+        if vmnet_interface in self._vmnets_info.keys():
+            subnet = self._vmnets_info[vmnet_interface].get("subnet", None)
+            netmask = self._vmnets_info[vmnet_interface].get("netmask", None)
+            if subnet and netmask:
+                for interface in interfaces():
+                    try:
+                        network = ipaddress.ip_network(f"{subnet}/{netmask}")
+                        ip = ipaddress.ip_address(interface["ip_address"])
+                    except ValueError:
+                        continue
+                    if ip in network:
+                        return interface["name"]
+        return None
+
     def refresh_vmnet_list(self, ubridge=True):
 
         if ubridge:
@@ -338,6 +372,8 @@ class VMware(BaseManager):
         else:
             vmnet_interfaces = self._get_vmnet_interfaces()
 
+        self._vmnets_info = vmnet_interfaces.copy()
+        vmnet_interfaces = list(vmnet_interfaces.keys())
         # remove vmnets already in use
         for vmware_vm in self._nodes.values():
             for used_vmnet in vmware_vm.vmnets:
@@ -754,5 +790,4 @@ class VMware(BaseManager):
 if __name__ == "__main__":
     loop = asyncio.get_event_loop()
     vmware = VMware.instance()
-    print("=> Check version")
     loop.run_until_complete(asyncio.ensure_future(vmware.check_vmware_version()))

gns3server/compute/vmware/vmware_vm.py

@@ -22,9 +22,11 @@ import sys
 import os
 import asyncio
 import tempfile
+import platform
 
 from gns3server.utils.asyncio.telnet_server import AsyncioTelnetServer
 from gns3server.utils.asyncio.serial import asyncio_open_serial
+from gns3server.utils import parse_version
 from gns3server.utils.asyncio import locking
 from collections import OrderedDict
 from .vmware_error import VMwareError
@@ -260,8 +262,13 @@ class VMwareVM(BaseNode):
             if self._get_vmx_setting(connected):
                 del self._vmx_pairs[connected]
 
+        use_ubridge = True
+        # use alternative method to find vmnet interfaces on macOS >= 11.0 (BigSur)
+        # because "bridge" interfaces are used instead and they are only created on the VM starts
+        if sys.platform.startswith("darwin") and parse_version(platform.mac_ver()[0]) >= parse_version("11.0.0"):
+            use_ubridge = False
+        self.manager.refresh_vmnet_list(ubridge=use_ubridge)
         # then configure VMware network adapters
-        self.manager.refresh_vmnet_list()
         for adapter_number in range(0, self._adapters):
 
             custom_adapter = self._get_custom_adapter_settings(adapter_number)
@@ -347,8 +354,17 @@ class VMwareVM(BaseNode):
         vmnet_interface = os.path.basename(self._vmx_pairs[vnet])
 
         if sys.platform.startswith("darwin"):
-            # special case on OSX, we cannot bind VMnet interfaces using the libpcap
-            await self._ubridge_send(f'bridge add_nio_fusion_vmnet {vnet} "{vmnet_interface}"')
+            if parse_version(platform.mac_ver()[0]) >= parse_version("11.0.0"):
+                # a bridge interface (bridge100, bridge101 etc.) is used instead of a vmnet interface
+                # on macOS >= 11.0 (Big Sur)
+                vmnet_interface = self.manager.find_bridge_interface(vmnet_interface)
+                if not vmnet_interface:
+                    raise VMwareError(f"Could not find bridge interface linked with {vmnet_interface}")
+                block_host_traffic = self.manager.config.get_section_config("VMware").getboolean("block_host_traffic", False)
+                await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)
+            else:
+                # special case on macOS, we cannot bind VMnet interfaces using the libpcap
+                await self._ubridge_send('bridge add_nio_fusion_vmnet {name} "{interface}"'.format(name=vnet, interface=vmnet_interface))
         else:
             block_host_traffic = self.manager.config.VMware.block_host_traffic
             await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)