Moves NIO creation to the base manager.

gns3server/modules/attic.py

@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 GNS3 Technologies Inc.
-#
-# 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, either version 3 of the License, or
-# (at your option) any later version.
-#
-# 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/>.
-
-"""
-Useful functions... in the attic ;)
-"""
-
-import sys
-import os
-import struct
-import socket
-import stat
-import time
-import aiohttp
-
-import logging
-log = logging.getLogger(__name__)
-
-
-def wait_socket_is_ready(host, port, wait=2.0, socket_timeout=10):
-    """
-    Waits for a socket to be ready for wait time.
-
-    :param host: host/address to connect to
-    :param port: port to connect to
-    :param wait: maximum wait time
-    :param socket_timeout: timeout for the socket
-
-    :returns: tuple with boolean indicating if the socket is ready and the last exception
-    that occurred when connecting to the socket
-    """
-
-    # connect to a local address by default
-    # if listening to all addresses (IPv4 or IPv6)
-    if host == "0.0.0.0":
-        host = "127.0.0.1"
-    elif host == "::":
-        host = "::1"
-
-    connection_success = False
-    begin = time.time()
-    last_exception = None
-    while time.time() - begin < wait:
-        time.sleep(0.01)
-        try:
-            with socket.create_connection((host, port), socket_timeout):
-                pass
-        except OSError as e:
-            last_exception = e
-            continue
-        connection_success = True
-        break
-
-    return connection_success, last_exception
-
-
-def has_privileged_access(executable):
-    """
-    Check if an executable can access Ethernet and TAP devices in
-    RAW mode.
-
-    :param executable: executable path
-
-    :returns: True or False
-    """
-
-    if sys.platform.startswith("win"):
-        # do not check anything on Windows
-        return True
-
-    if os.geteuid() == 0:
-        # we are root, so we should have privileged access.
-        return True
-    if os.stat(executable).st_mode & stat.S_ISUID or os.stat(executable).st_mode & stat.S_ISGID:
-        # the executable has set UID bit.
-        return True
-
-    # test if the executable has the CAP_NET_RAW capability (Linux only)
-    if sys.platform.startswith("linux") and "security.capability" in os.listxattr(executable):
-        try:
-            caps = os.getxattr(executable, "security.capability")
-            # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
-            if struct.unpack("<IIIII", caps)[1] & 1 << 13:
-                return True
-        except Exception as e:
-            log.error("could not determine if CAP_NET_RAW capability is set for {}: {}".format(executable, e))
-
-    return False

gns3server/modules/base_manager.py

@@ -15,14 +15,24 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
+import sys
+import os
+import struct
+import stat
 import asyncio
 import aiohttp
+import socket
+
+import logging
+log = logging.getLogger(__name__)
 
 from uuid import UUID, uuid4
 from ..config import Config
 from .project_manager import ProjectManager
 
+from .nios.nio_udp import NIO_UDP
+from .nios.nio_tap import NIO_TAP
+
 
 class BaseManager:
 
@@ -147,3 +157,66 @@ class BaseManager:
         else:
             vm.destroy()
         del self._vms[vm.uuid]
+
+    @staticmethod
+    def _has_privileged_access(executable):
+        """
+        Check if an executable can access Ethernet and TAP devices in
+        RAW mode.
+
+        :param executable: executable path
+
+        :returns: True or False
+        """
+
+        if sys.platform.startswith("win"):
+            # do not check anything on Windows
+            return True
+
+        if os.geteuid() == 0:
+            # we are root, so we should have privileged access.
+            return True
+        if os.stat(executable).st_mode & stat.S_ISUID or os.stat(executable).st_mode & stat.S_ISGID:
+            # the executable has set UID bit.
+            return True
+
+        # test if the executable has the CAP_NET_RAW capability (Linux only)
+        if sys.platform.startswith("linux") and "security.capability" in os.listxattr(executable):
+            try:
+                caps = os.getxattr(executable, "security.capability")
+                # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
+                if struct.unpack("<IIIII", caps)[1] & 1 << 13:
+                    return True
+            except Exception as e:
+                log.error("could not determine if CAP_NET_RAW capability is set for {}: {}".format(executable, e))
+
+        return False
+
+    def create_nio(self, executable, nio_settings):
+        """
+        Creates a new NIO.
+
+        :param nio_settings: information to create the NIO
+
+        :returns: a NIO object
+        """
+
+        nio = None
+        if nio_settings["type"] == "nio_udp":
+            lport = nio_settings["lport"]
+            rhost = nio_settings["rhost"]
+            rport = nio_settings["rport"]
+            try:
+                # TODO: handle IPv6
+                with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+                    sock.connect((rhost, rport))
+            except OSError as e:
+                raise aiohttp.web.HTTPInternalServerError(text="Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
+            nio = NIO_UDP(lport, rhost, rport)
+        elif nio_settings["type"] == "nio_tap":
+            tap_device = nio_settings["tap_device"]
+            if not self._has_privileged_access(executable):
+                raise aiohttp.web.HTTPForbidden(text="{} has no privileged access to {}.".format(executable, tap_device))
+            nio = NIO_TAP(tap_device)
+        assert nio is not None
+        return nio

gns3server/modules/nios/nio_tap.py

@@ -48,4 +48,5 @@ class NIO_TAP(object):
 
     def __json__(self):
 
-        return {"type": "nio_tap", "tap_device": self._tap_device}
+        return {"type": "nio_tap",
+                "tap_device": self._tap_device}

gns3server/modules/nios/nio_udp.py

@@ -74,4 +74,7 @@ class NIO_UDP(object):
 
     def __json__(self):
 
-        return {"type": "nio_udp", "lport": self._lport, "rport": self._rport, "rhost": self._rhost}
+        return {"type": "nio_udp",
+                "lport": self._lport,
+                "rport": self._rport,
+                "rhost": self._rhost}

gns3server/modules/vpcs/vpcs_vm.py

@@ -26,18 +26,14 @@ import subprocess
 import signal
 import re
 import asyncio
-import socket
 import shutil
 
 from pkg_resources import parse_version
 from .vpcs_error import VPCSError
 from ..adapters.ethernet_adapter import EthernetAdapter
-from ..nios.nio_udp import NIO_UDP
-from ..nios.nio_tap import NIO_TAP
-from ..attic import has_privileged_access
-
 from ..base_vm import BaseVM
 
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -116,6 +112,16 @@ class VPCSVM(BaseVM):
                 "script_file": self.script_file,
                 "startup_script": self.startup_script}
 
+    @property
+    def vpcs_path(self):
+        """
+        Returns the VPCS executable path.
+
+        :returns: path to VPCS
+        """
+
+        return self._path
+
     @property
     def console(self):
         """
@@ -303,7 +309,7 @@ class VPCSVM(BaseVM):
             return True
         return False
 
-    def port_add_nio_binding(self, port_id, nio_settings):
+    def port_add_nio_binding(self, port_id, nio):
         """
         Adds a port NIO binding.
 
@@ -315,26 +321,6 @@ class VPCSVM(BaseVM):
             raise VPCSError("Port {port_id} doesn't exist in adapter {adapter}".format(adapter=self._ethernet_adapter,
                                                                                        port_id=port_id))
 
-        nio = None
-        if nio_settings["type"] == "nio_udp":
-            lport = nio_settings["lport"]
-            rhost = nio_settings["rhost"]
-            rport = nio_settings["rport"]
-            try:
-                # TODO: handle IPv6
-                with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
-                    sock.connect((rhost, rport))
-            except OSError as e:
-                raise VPCSError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
-            nio = NIO_UDP(lport, rhost, rport)
-        elif nio_settings["type"] == "nio_tap":
-            tap_vm = nio_settings["tap_device"]
-            if not has_privileged_access(self._path):
-                raise VPCSError("{} has no privileged access to {}.".format(self._path, tap_vm))
-            nio = NIO_TAP(tap_vm)
-        if not nio:
-            raise VPCSError("Requested NIO does not exist or is not supported: {}".format(nio_settings["type"]))
-
         self._ethernet_adapter.add_nio(port_id, nio)
         log.info("VPCS {name} {uuid}]: {nio} added to port {port_id}".format(name=self._name,
                                                                              uuid=self.uuid,
@@ -404,13 +390,13 @@ class VPCSVM(BaseVM):
 
         nio = self._ethernet_adapter.get_nio(0)
         if nio:
-            if isinstance(nio, NIO_UDP):
+            if str(nio) == "NIO UDP":
                 # UDP tunnel
                 command.extend(["-s", str(nio.lport)])  # source UDP port
                 command.extend(["-c", str(nio.rport)])  # destination UDP port
                 command.extend(["-t", nio.rhost])  # destination host
 
-            elif isinstance(nio, NIO_TAP):
+            elif str(nio) == "NIO TAP":
                 # TAP interface
                 command.extend(["-e"])
                 command.extend(["-d", nio.tap_vm])