gns3-server/gns3server/compute/iou/iou_vm.py

#
# Copyright (C) 2015 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/>.

"""
IOU VM management (creates command line, processes, files etc.) in
order to run an IOU VM.
"""

import os
import socket
import re
import asyncio
import subprocess
import shutil
import configparser
import struct
import hashlib
import glob
import binascii
import functools

from .iou_error import IOUError
from ..adapters.ethernet_adapter import EthernetAdapter
from ..adapters.serial_adapter import SerialAdapter
from ..nios.nio_udp import NIOUDP
from ..base_node import BaseNode
from .utils.iou_import import nvram_import
from .utils.iou_export import nvram_export
from gns3server.compute.ubridge.ubridge_error import UbridgeError
from gns3server.utils.file_watcher import FileWatcher
from gns3server.utils.asyncio.telnet_server import AsyncioTelnetServer
from gns3server.utils.hostname import is_ios_hostname_valid
from gns3server.utils.asyncio import locking
import gns3server.utils.asyncio
import gns3server.utils.images

import logging
import sys

log = logging.getLogger(__name__)


class IOUVM(BaseNode):
    module_name = "iou"

    """
    IOU VM implementation.

    :param name: IOU VM name
    :param node_id: Node identifier
    :param project: Project instance
    :param manager: Manager instance
    :param console: TCP console port
    :param console_type: console type
    """

    def __init__(
        self, name, node_id, project, manager, application_id=None, path=None, console=None, console_type="telnet"
    ):

        if not is_ios_hostname_valid(name):
            raise IOUError(f"'{name}' is an invalid name to create an IOU node")

        super().__init__(name, node_id, project, manager, console=console, console_type=console_type)

        log.info(
            'IOU "{name}" [{id}]: assigned with application ID {application_id}'.format(
                name=self._name, id=self._id, application_id=application_id
            )
        )

        self._iou_process = None
        self._telnet_server = None
        self._iou_stdout_file = ""
        self._started = False
        self._nvram_watcher = None
        self._path = self.manager.get_abs_image_path(path, project.path)
        self._lib_base = self.manager.get_images_directory()
        self._loader = None
        self._license_check = True

        # IOU settings
        self._ethernet_adapters = []
        self._serial_adapters = []
        self.ethernet_adapters = 2  # one adapter = 4 interfaces
        self.serial_adapters = 2  # one adapter = 4 interfaces
        self._use_default_iou_values = True  # for RAM & NVRAM values
        self._nvram = 128  # Kilobytes
        self._startup_config = ""
        self._private_config = ""
        self._ram = 256  # Megabytes
        self._application_id = application_id
        self._l1_keepalives = False  # used to overcome the always-up Ethernet interfaces (not supported by all IOSes).

    def _nvram_changed(self, path):
        """
        Called when the NVRAM file has changed
        """
        log.debug(f"NVRAM changed: {path}")
        self.save_configs()
        self.updated()

    async def close(self):
        """
        Closes this IOU VM.
        """

        if not (await super().close()):
            return False

        adapters = self._ethernet_adapters + self._serial_adapters
        for adapter in adapters:
            if adapter is not None:
                for nio in adapter.ports.values():
                    if nio and isinstance(nio, NIOUDP):
                        self.manager.port_manager.release_udp_port(nio.lport, self._project)

        await self.stop()

    @property
    def path(self):
        """
        Path of the IOU executable.

        :returns: path to the IOU image executable
        """

        return self._path

    @path.setter
    def path(self, path):
        """
        Path of the IOU executable.

        :param path: path to the IOU image executable
        """

        self._path = self.manager.get_abs_image_path(path, self.project.path)
        self._loader = None
        log.info(f'IOU "{self._name}" [{self._id}]: IOU image updated to "{self._path}"')

    @property
    def use_default_iou_values(self):
        """
        Returns if this device uses the default IOU image values.

        :returns: boolean
        """

        return self._use_default_iou_values

    @use_default_iou_values.setter
    def use_default_iou_values(self, state):
        """
        Sets if this device uses the default IOU image values.

        :param state: boolean
        """

        self._use_default_iou_values = state
        if state:
            log.info(f'IOU "{self._name}" [{self._id}]: uses the default IOU image values')
        else:
            log.info(f'IOU "{self._name}" [{self._id}]: does not use the default IOU image values')

    async def update_default_iou_values(self):
        """
        Finds the default RAM and NVRAM values for the IOU image.
        """

        await self._check_requirements()
        try:
            output = await gns3server.utils.asyncio.subprocess_check_output(
                *self._loader, self._path, "-h", cwd=self.working_dir, stderr=True
            )
            match = re.search(r"-n <n>\s+Size of nvram in Kb \(default ([0-9]+)KB\)", output)
            if match:
                self.nvram = int(match.group(1))
            match = re.search(r"-m <n>\s+Megabytes of router memory \(default ([0-9]+)MB\)", output)
            if match:
                self.ram = int(match.group(1))
        except (ValueError, OSError, subprocess.SubprocessError) as e:
            log.warning(f"could not find default RAM and NVRAM values for {os.path.basename(self._path)}: {e}")

    async def create(self):

        await self.update_default_iou_values()

    async def _check_requirements(self):
        """
        Checks the IOU image.
        """

        if self._loader is not None:
            return  # image already checked
        if not self._path:
            raise IOUError("IOU image is not configured")
        if not os.path.isfile(self._path) or not os.path.exists(self._path):
            if os.path.islink(self._path):
                raise IOUError(f"IOU image '{self._path}' linked to '{os.path.realpath(self._path)}' is not accessible")
            else:
                raise IOUError(f"IOU image '{self._path}' is not accessible")

        try:
            with open(self._path, "rb") as f:
                # read the first 7 bytes of the file.
                elf_header_start = f.read(7)
        except OSError as e:
            raise IOUError(f"Cannot read ELF header for IOU image '{self._path}': {e}")

        # IOU images must start with the ELF magic number, be 32-bit or 64-bit, little endian
        # and have an ELF version of 1 normal IOS image are big endian!
        if elf_header_start != b"\x7fELF\x01\x01\x01" and elf_header_start != b"\x7fELF\x02\x01\x01":
            raise IOUError(f"'{self._path}' is not a valid IOU image")

        if not os.access(self._path, os.X_OK):
            raise IOUError(f"IOU image '{self._path}' is not executable")

        # set loader command
        if elf_header_start[4] == 1:
            # 32-bit loader
            loader = os.path.join(self._lib_base, "lib", "ld-linux.so.2")
            lib_path = (os.path.join(self._lib_base, "lib"),
                        os.path.join(self._lib_base, "lib", "i386-linux-gnu"))
        else:
            # 64-bit loader
            loader = os.path.join(self._lib_base, "lib64", "ld-linux-x86-64.so.2")
            lib_path = (os.path.join(self._lib_base, "lib64"),
                        os.path.join(self._lib_base, "lib", "x86_64-linux-gnu"))
        self._loader = []
        if os.path.isfile(loader):
            try:
                proc = await asyncio.create_subprocess_exec(loader, "--verify", self._path)
                if await proc.wait() == 0:
                    self._loader = [loader, "--library-path", ":".join(lib_path)]
                else:
                    log.warning(f"Loader {loader} incompatible with '{self._path}'")
            except (OSError, subprocess.SubprocessError) as e:
                log.warning(f"Could not use loader {loader}: {e}")

    def asdict(self):

        iou_vm_info = {
            "name": self.name,
            "usage": self.usage,
            "node_id": self.id,
            "node_directory": self.working_path,
            "console": self._console,
            "console_type": self._console_type,
            "status": self.status,
            "project_id": self.project.id,
            "path": self.path,
            "md5sum": gns3server.utils.images.md5sum(self.path, self.working_path),
            "ethernet_adapters": len(self._ethernet_adapters),
            "serial_adapters": len(self._serial_adapters),
            "ram": self._ram,
            "nvram": self._nvram,
            "l1_keepalives": self._l1_keepalives,
            "use_default_iou_values": self._use_default_iou_values,
            "command_line": self.command_line,
            "application_id": self.application_id,
        }

        iou_vm_info["path"] = self.manager.get_relative_image_path(self.path, self.project.path)
        return iou_vm_info

    @property
    def iourc_path(self):
        """
        Returns the IOURC file path.

        :returns: path to IOURC
        """

        iourc_path = self._manager.config.settings.IOU.iourc_path
        if not iourc_path:
            # look for the iourc file in the temporary  dir.
            path = os.path.join(self.temporary_directory, "iourc")
            if os.path.exists(path):
                return path
            # look for the iourc file in the user home dir.
            path = os.path.join(os.path.expanduser("~/"), ".iourc")
            if os.path.exists(path):
                return path
            # look for the iourc file in the current working dir.
            path = os.path.join(self.working_dir, "iourc")
            if os.path.exists(path):
                return path
        return iourc_path

    @property
    def ram(self):
        """
        Returns the amount of RAM allocated to this IOU VM.

        :returns: amount of RAM in MBytes (integer)
        """

        return self._ram

    @ram.setter
    def ram(self, ram):
        """
        Sets amount of RAM allocated to this IOU instance.

        :param ram: amount of RAM in MBytes (integer)
        """

        if self._ram == ram:
            return

        log.info(
            'IOU "{name}" [{id}]: RAM updated from {old_ram}MB to {new_ram}MB'.format(
                name=self._name, id=self._id, old_ram=self._ram, new_ram=ram
            )
        )

        self._ram = ram

    @property
    def nvram(self):
        """
        Returns the mount of NVRAM allocated to this IOU instance.

        :returns: amount of NVRAM in KBytes (integer)
        """

        return self._nvram

    @nvram.setter
    def nvram(self, nvram):
        """
        Sets amount of NVRAM allocated to this IOU instance.

        :param nvram: amount of NVRAM in KBytes (integer)
        """

        if self._nvram == nvram:
            return

        log.info(
            'IOU "{name}" [{id}]: NVRAM updated from {old_nvram}KB to {new_nvram}KB'.format(
                name=self._name, id=self._id, old_nvram=self._nvram, new_nvram=nvram
            )
        )
        self._nvram = nvram

    @BaseNode.name.setter
    def name(self, new_name):
        """
        Sets the name of this IOU VM.

        :param new_name: name
        """

        if not is_ios_hostname_valid(new_name):
            raise IOUError(f"'{new_name}' is an invalid name to rename IOU node '{self._name}'")
        if self.startup_config_file:
            content = self.startup_config_content
            content = re.sub(r"hostname .+$", "hostname " + new_name, content, flags=re.MULTILINE)
            self.startup_config_content = content

        super(IOUVM, IOUVM).name.__set__(self, new_name)

    @property
    def iourc_content(self):

        try:
            with open(os.path.join(self.temporary_directory, "iourc"), "rb") as f:
                return f.read().decode("utf-8")
        except OSError:
            return None

    @iourc_content.setter
    def iourc_content(self, value):

        if value:
            # If we don't save the value in the ~/ the licence is lost at project
            # reload
            path = os.path.join(os.path.expanduser("~/"), ".iourc")
            try:
                with open(path, "wb") as f:
                    f.write(value.encode("utf-8"))
            except OSError as e:
                raise IOUError(f"Could not write the iourc file {path}: {e}")

            path = os.path.join(self.temporary_directory, "iourc")
            try:
                with open(path, "wb") as f:
                    f.write(value.encode("utf-8"))
            except OSError as e:
                raise IOUError(f"Could not write the iourc file {path}: {e}")

    @property
    def license_check(self):

        return self._license_check

    @license_check.setter
    def license_check(self, value):

        self._license_check = value

    async def _library_check(self):
        """
        Checks for missing shared library dependencies in the IOU image.
        """

        env = os.environ.copy()
        env["LD_TRACE_LOADED_OBJECTS"] = "1"
        try:
            output = await gns3server.utils.asyncio.subprocess_check_output(*self._loader, self._path, env=env)
        except (OSError, subprocess.SubprocessError) as e:
            log.warning(f"Could not determine the shared library dependencies for {self._path}: {e}")
            return

        p = re.compile(r"([\.\w]+)\s=>\s+not found")
        missing_libs = p.findall(output)
        if missing_libs:
            raise IOUError(
                "The following shared library dependencies cannot be found for IOU image {}: {}".format(
                    self._path, ", ".join(missing_libs)
                )
            )

    async def _check_iou_licence(self):
        """
        Checks for a valid IOU key in the iourc file (paranoid mode).
        """

        # license check is sent by the controller
        if self.license_check is False:
            return

        try:
            # we allow license check to be disabled server wide
            server_wide_license_check = self._manager.config.settings.IOU.license_check
        except ValueError:
            raise IOUError("Invalid licence check setting")

        if server_wide_license_check is False:
            log.warning("License check is explicitly disabled on this server")
            return

        config = configparser.ConfigParser()
        try:
            log.info(f"Checking IOU license in '{self.iourc_path}'")
            with open(self.iourc_path, encoding="utf-8") as f:
                config.read_file(f)
        except OSError as e:
            raise IOUError(f"Could not open iourc file {self.iourc_path}: {e}")
        except configparser.Error as e:
            raise IOUError(f"Could not parse iourc file {self.iourc_path}: {e}")
        except UnicodeDecodeError as e:
            raise IOUError(f"Non ascii characters in iourc file {self.iourc_path}, please remove them: {e}")
        if "license" not in config:
            raise IOUError(f"License section not found in iourc file {self.iourc_path}")
        hostname = socket.gethostname()
        if len(hostname) > 15:
            log.warning(f"Older IOU images may not boot because hostname '{hostname}' length is above 15 characters")
        if hostname not in config["license"]:
            raise IOUError(f'Hostname "{hostname}" not found in iourc file {self.iourc_path}')
        user_ioukey = config["license"][hostname]
        if user_ioukey[-1:] != ";":
            raise IOUError(f"IOU key not ending with ; in iourc file {self.iourc_path}")
        if len(user_ioukey) != 17:
            raise IOUError(f"IOU key length is not 16 characters in iourc file {self.iourc_path}")
        user_ioukey = user_ioukey[:16]

        # We can't test this because it's mean distributing a valid licence key
        # in tests or generating one
        if not hasattr(sys, "_called_from_test"):
            try:
                hostid = (await gns3server.utils.asyncio.subprocess_check_output("hostid")).strip()
            except FileNotFoundError as e:
                raise IOUError(f"Could not find hostid: {e}")
            except (OSError, subprocess.SubprocessError) as e:
                raise IOUError(f"Could not execute hostid: {e}")

            try:
                ioukey = int(hostid, 16)
            except ValueError:
                raise IOUError(f"Invalid hostid detected: {hostid}")
            for x in hostname:
                ioukey += ord(x)
            pad1 = b"\x4B\x58\x21\x81\x56\x7B\x0D\xF3\x21\x43\x9B\x7E\xAC\x1D\xE6\x8A"
            pad2 = b"\x80" + 39 * b"\0"
            ioukey = hashlib.md5(pad1 + pad2 + struct.pack("!I", ioukey) + pad1).hexdigest()[:16]
            if ioukey != user_ioukey:
                raise IOUError(
                    "Invalid IOU license key {} detected in iourc file {} for host {}".format(
                        user_ioukey, self.iourc_path, hostname
                    )
                )

    def _nvram_file(self):
        """
        Path to the nvram file
        """
        return os.path.join(self.working_dir, f"nvram_{self.application_id:05d}")

    def _push_configs_to_nvram(self):
        """
        Push the startup-config and private-config content to the NVRAM.
        """

        startup_config_content = self.startup_config_content
        if startup_config_content:
            nvram_file = self._nvram_file()
            try:
                if not os.path.exists(nvram_file):
                    open(nvram_file, "a").close()
                    nvram_content = None
                else:
                    with open(nvram_file, "rb") as file:
                        nvram_content = file.read()
            except OSError as e:
                raise IOUError(f"Cannot read nvram file {nvram_file}: {e}")

            startup_config_content = startup_config_content.encode("utf-8")
            private_config_content = self.private_config_content
            if private_config_content is not None:
                private_config_content = private_config_content.encode("utf-8")
            try:
                nvram_content = nvram_import(nvram_content, startup_config_content, private_config_content, self.nvram)
            except ValueError as e:
                raise IOUError(f"Cannot push configs to nvram {nvram_file}: {e}")
            try:
                with open(nvram_file, "wb") as file:
                    file.write(nvram_content)
            except OSError as e:
                raise IOUError(f"Cannot write nvram file {nvram_file}: {e}")

    async def start(self):
        """
        Starts the IOU process.
        """

        await self._check_requirements()
        if not self.is_running():

            await self._library_check()

            try:
                self._rename_nvram_file()
            except OSError as e:
                raise IOUError(f"Could not rename nvram files: {e}")

            iourc_path = self.iourc_path
            if not iourc_path:
                raise IOUError("Could not find an iourc file (IOU license), please configure an IOU license")
            if not os.path.isfile(iourc_path):
                raise IOUError(f"The iourc path '{iourc_path}' is not a regular file")

            await self._check_iou_licence()
            await self._start_ubridge()

            self._create_netmap_config()
            if self.use_default_iou_values:
                # make sure we have the default nvram amount to correctly push the configs
                await self.update_default_iou_values()
            self._push_configs_to_nvram()

            # check if there is enough RAM to run
            self.check_available_ram(self.ram)

            self._nvram_watcher = FileWatcher(self._nvram_file(), self._nvram_changed, delay=2)

            # created a environment variable pointing to the iourc file.
            env = os.environ.copy()
            if "IOURC" not in os.environ and iourc_path:
                env["IOURC"] = iourc_path

            # create a symbolic link to the image to avoid IOU error "failed code signing checks"
            # on newer images, see https://github.com/GNS3/gns3-server/issues/1484
            try:
                iou_image_path = os.path.basename(self.path)
                if len(iou_image_path) > 63:
                    # IOU file basename length must be <= 63 chars
                    iou_file_name, iou_file_ext = os.path.splitext(iou_image_path)
                    iou_image_path = iou_file_name[:63 - len(iou_file_ext)] + iou_file_ext
                symlink = os.path.join(self.working_dir, iou_image_path)
                if os.path.islink(symlink):
                    os.unlink(symlink)
                os.symlink(self.path, symlink)
            except OSError as e:
                raise IOUError(f"Could not create symbolic link: {e}")

            command = await self._build_command()
            try:
                if self._loader:
                    log.info(f"Starting IOU: {command} with loader {self._loader}")
                else:
                    log.info(f"Starting IOU: {command}")
                self.command_line = " ".join(command)
                self._iou_process = await asyncio.create_subprocess_exec(
                    *self._loader, *command,
                    stdout=asyncio.subprocess.PIPE,
                    stdin=asyncio.subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    cwd=self.working_dir,
                    env=env,
                )
                log.info(f"IOU instance {self._id} started PID={self._iou_process.pid}")
                self._started = True
                self.status = "started"
                callback = functools.partial(self._termination_callback, "IOU")
                gns3server.utils.asyncio.monitor_process(self._iou_process, callback)
            except FileNotFoundError as e:
                raise IOUError(f"Could not start IOU: {e}: 32-bit binary support is probably not installed")
            except (OSError, subprocess.SubprocessError) as e:
                iou_stdout = self.read_iou_stdout()
                log.error(f"Could not start IOU {self._path}: {e}\n{iou_stdout}")
                raise IOUError(f"Could not start IOU {self._path}: {e}\n{iou_stdout}")

            await self.start_console()

            # configure networking support
            await self._networking()

    async def start_console(self):
        """
        Start the Telnet server to provide console access.
        """

        if self.console and self.console_type == "telnet":
            server = AsyncioTelnetServer(
                reader=self._iou_process.stdout, writer=self._iou_process.stdin, binary=True, echo=True
            )
            try:
                self._telnet_server = await asyncio.start_server(
                    server.run, self._manager.port_manager.console_host, self.console
                )
            except OSError as e:
                await self.stop()
                raise IOUError(
                    "Could not start Telnet server on socket {}:{}: {}".format(
                        self._manager.port_manager.console_host, self.console, e
                    )
                )

    async def reset_console(self):
        """
        Reset the console.
        """

        if self._telnet_server:
            self._telnet_server.close()
            await self._telnet_server.wait_closed()
            self._telnet_server = None
        if self.is_running():
            await self.start_console()

    @locking
    async def _networking(self):
        """
        Configures the IOL bridge in uBridge.
        """

        bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
        try:
            # delete any previous bridge if it exists
            await self._ubridge_send(f"iol_bridge delete {bridge_name}")
        except UbridgeError:
            pass
        await self._ubridge_send(f"iol_bridge create {bridge_name} {self.application_id + 512}")

        bay_id = 0
        for adapter in self._adapters:
            unit_id = 0
            for unit in adapter.ports.keys():
                nio = adapter.get_nio(unit)
                if nio and isinstance(nio, NIOUDP):
                    await self._ubridge_send(
                        "iol_bridge add_nio_udp {name} {iol_id} {bay} {unit} {lport} {rhost} {rport}".format(
                            name=bridge_name,
                            iol_id=self.application_id,
                            bay=bay_id,
                            unit=unit_id,
                            lport=nio.lport,
                            rhost=nio.rhost,
                            rport=nio.rport,
                        )
                    )
                    if nio.capturing:
                        await self._ubridge_send(
                            'iol_bridge start_capture {name} "{output_file}" {data_link_type}'.format(
                                name=bridge_name,
                                output_file=nio.pcap_output_file,
                                data_link_type=re.sub(r"^DLT_", "", nio.pcap_data_link_type),
                            )
                        )

                    await self._ubridge_apply_filters(bay_id, unit_id, nio.filters)
                unit_id += 1
            bay_id += 1

        await self._ubridge_send(f"iol_bridge start {bridge_name}")

    def _termination_callback(self, process_name, returncode):
        """
        Called when the process has stopped.

        :param returncode: Process returncode
        """

        self._terminate_process_iou()
        if returncode != 0:
            if returncode == -11:
                message = 'IOU VM "{}" process has stopped with return code: {} (segfault). This could be an issue with the IOU image, using a different image may fix this.\n{}'.format(
                    self.name, returncode, self.read_iou_stdout()
                )
            else:
                message = (
                    f'IOU VM "{self.name}" process has stopped with return code: {returncode}\n{self.read_iou_stdout()}'
                )
            log.warning(message)
            self.project.emit("log.error", {"message": message})
        if self._telnet_server:
            self._telnet_server.close()
            self._telnet_server = None

    def _rename_nvram_file(self):
        """
        Before starting the VM, rename the nvram and vlan.dat files with the correct IOU application identifier.
        """

        destination = self._nvram_file()
        for file_path in glob.glob(os.path.join(glob.escape(self.working_dir), "nvram_*")):
            shutil.move(file_path, destination)
        destination = os.path.join(self.working_dir, f"vlan.dat-{self.application_id:05d}")
        for file_path in glob.glob(os.path.join(glob.escape(self.working_dir), "vlan.dat-*")):
            shutil.move(file_path, destination)

    async def stop(self):
        """
        Stops the IOU process.
        """

        await self._stop_ubridge()
        if self._nvram_watcher:
            self._nvram_watcher.close()
            self._nvram_watcher = None

        if self._telnet_server:
            self._telnet_server.close()
            self._telnet_server = None

        if self.is_running():
            self._terminate_process_iou()
            if self._iou_process.returncode is None:
                try:
                    await gns3server.utils.asyncio.wait_for_process_termination(self._iou_process, timeout=3)
                except asyncio.TimeoutError:
                    if self._iou_process.returncode is None:
                        log.warning(f"IOU process {self._iou_process.pid} is still running... killing it")
                        try:
                            self._iou_process.kill()
                        except ProcessLookupError:
                            pass
            self._iou_process = None

        try:
            symlink = os.path.join(self.working_dir, os.path.basename(self.path))
            if os.path.islink(symlink):
                os.unlink(symlink)
        except OSError as e:
            log.warning(f"Could not delete symbolic link: {e}")

        self._started = False
        self.save_configs()

    def _terminate_process_iou(self):
        """
        Terminate the IOU process if running
        """

        if self._iou_process:
            log.info(f'Stopping IOU process for IOU VM "{self.name}" PID={self._iou_process.pid}')
            try:
                self._iou_process.terminate()
            # Sometime the process can already be dead when we garbage collect
            except ProcessLookupError:
                pass
        self._started = False
        self.status = "stopped"

    async def reload(self):
        """
        Reloads the IOU process (stop & start).
        """

        await self.stop()
        await self.start()

    def is_running(self):
        """
        Checks if the IOU process is running

        :returns: True or False
        """

        if self._iou_process and self._iou_process.returncode is None:
            return True
        return False

    @BaseNode.console_type.setter
    def console_type(self, new_console_type):
        """
        Sets the console type for this IOU VM.

        :param new_console_type: console type (string)
        """

        if self.is_running() and self.console_type != new_console_type:
            raise IOUError(f'"{self._name}" must be stopped to change the console type to {new_console_type}')

        super(IOUVM, IOUVM).console_type.__set__(self, new_console_type)

    def _create_netmap_config(self):
        """
        Creates the NETMAP file.
        """

        netmap_path = os.path.join(self.working_dir, "NETMAP")
        try:
            with open(netmap_path, "w", encoding="utf-8") as f:
                for bay in range(0, 16):
                    for unit in range(0, 4):
                        f.write(
                            "{ubridge_id}:{bay}/{unit}{iou_id:>5d}:{bay}/{unit}\n".format(
                                ubridge_id=str(self.application_id + 512),
                                bay=bay,
                                unit=unit,
                                iou_id=self.application_id,
                            )
                        )
            log.info("IOU {name} [id={id}]: NETMAP file created".format(name=self._name, id=self._id))
        except OSError as e:
            raise IOUError(f"Could not create {netmap_path}: {e}")

    async def _build_command(self):
        """
        Command to start the IOU process.
        (to be passed to subprocess.Popen())

        IOU command line:
        Usage: <image> [options] <application id>
        <image>: unix-js-m | unix-is-m | unix-i-m | ...
        <application id>: instance identifier (0 < id <= 1024)
        Options:
        -e <n>        Number of Ethernet interfaces (default 2)
        -s <n>        Number of Serial interfaces (default 2)
        -n <n>        Size of nvram in Kb (default 64KB)
        -b <string>   IOS debug string
        -c <name>     Configuration file name
        -d            Generate debug information
        -t            Netio message trace
        -q            Suppress informational messages
        -h            Display this help
        -C            Turn off use of host clock
        -m <n>        Megabytes of router memory (default 256MB)
        -L            Disable local console, use remote console
        -l            Enable Layer 1 keepalive messages
        -u <n>        UDP port base for distributed networks
        -R            Ignore options from the IOURC file
        -U            Disable unix: file system location
        -W            Disable watchdog timer
        -N            Ignore the NETMAP file
        """

        command = [self._path]
        if len(self._ethernet_adapters) != 2:
            command.extend(["-e", str(len(self._ethernet_adapters))])
        if len(self._serial_adapters) != 2:
            command.extend(["-s", str(len(self._serial_adapters))])
        if not self.use_default_iou_values:
            command.extend(["-n", str(self._nvram)])
            command.extend(["-m", str(self._ram)])

        # do not let IOU create the NVRAM anymore
        # startup_config_file = self.startup_config_file
        # if startup_config_file:
        #    command.extend(["-c", os.path.basename(startup_config_file)])

        if self._l1_keepalives:
            await self._enable_l1_keepalives(command)
        command.extend([str(self.application_id)])
        return command

    def read_iou_stdout(self):
        """
        Reads the standard output of the IOU process.
        Only use when the process has been stopped or has crashed.
        """

        output = ""
        if self._iou_stdout_file:
            try:
                with open(self._iou_stdout_file, "rb") as file:
                    output = file.read().decode("utf-8", errors="replace")
            except OSError as e:
                log.warning(f"could not read {self._iou_stdout_file}: {e}")
        return output

    @property
    def adapters(self):
        return self._adapters

    @property
    def ethernet_adapters(self):
        """
        Returns the number of Ethernet adapters for this IOU VM.

        :returns: number of adapters
        """

        return len(self._ethernet_adapters)

    @ethernet_adapters.setter
    def ethernet_adapters(self, ethernet_adapters):
        """
        Sets the number of Ethernet adapters for this IOU VM.

        :param ethernet_adapters: number of adapters
        """

        self._ethernet_adapters.clear()
        for _ in range(0, ethernet_adapters):
            self._ethernet_adapters.append(EthernetAdapter(interfaces=4))

        log.info(
            'IOU "{name}" [{id}]: number of Ethernet adapters changed to {adapters}'.format(
                name=self._name, id=self._id, adapters=len(self._ethernet_adapters)
            )
        )

        self._adapters = self._ethernet_adapters + self._serial_adapters

    @property
    def serial_adapters(self):
        """
        Returns the number of Serial adapters for this IOU VM.

        :returns: number of adapters
        """

        return len(self._serial_adapters)

    @serial_adapters.setter
    def serial_adapters(self, serial_adapters):
        """
        Sets the number of Serial adapters for this IOU VM.

        :param serial_adapters: number of adapters
        """

        self._serial_adapters.clear()
        for _ in range(0, serial_adapters):
            self._serial_adapters.append(SerialAdapter(interfaces=4))

        log.info(
            'IOU "{name}" [{id}]: number of Serial adapters changed to {adapters}'.format(
                name=self._name, id=self._id, adapters=len(self._serial_adapters)
            )
        )

        self._adapters = self._ethernet_adapters + self._serial_adapters

    async def adapter_add_nio_binding(self, adapter_number, port_number, nio):
        """
        Adds an adapter NIO binding.

        :param adapter_number: adapter number
        :param port_number: port number
        :param nio: NIO instance to add to the adapter/port
        """

        try:
            adapter = self._adapters[adapter_number]
        except IndexError:
            raise IOUError(
                'Adapter {adapter_number} does not exist for IOU "{name}"'.format(
                    name=self._name, adapter_number=adapter_number
                )
            )

        if not adapter.port_exists(port_number):
            raise IOUError(
                "Port {port_number} does not exist on adapter {adapter}".format(
                    adapter=adapter, port_number=port_number
                )
            )

        adapter.add_nio(port_number, nio)
        log.info(
            'IOU "{name}" [{id}]: {nio} added to {adapter_number}/{port_number}'.format(
                name=self._name, id=self._id, nio=nio, adapter_number=adapter_number, port_number=port_number
            )
        )

        if self.ubridge:
            bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
            await self._ubridge_send(
                "iol_bridge add_nio_udp {name} {iol_id} {bay} {unit} {lport} {rhost} {rport}".format(
                    name=bridge_name,
                    iol_id=self.application_id,
                    bay=adapter_number,
                    unit=port_number,
                    lport=nio.lport,
                    rhost=nio.rhost,
                    rport=nio.rport,
                )
            )
            await self._ubridge_apply_filters(adapter_number, port_number, nio.filters)

    async def adapter_update_nio_binding(self, adapter_number, port_number, nio):
        """
        Updates an adapter NIO binding.

        :param adapter_number: adapter number
        :param port_number: port number
        :param nio: NIO instance to add to the adapter
        """

        if self.ubridge:
            await self._ubridge_apply_filters(adapter_number, port_number, nio.filters)

    async def _ubridge_apply_filters(self, adapter_number, port_number, filters):
        """
        Apply filter like rate limiting

        :param adapter_number: adapter number
        :param port_number: port number
        :param filters: Array of filter dictionnary
        """
        bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
        location = "{bridge_name} {bay} {unit}".format(bridge_name=bridge_name, bay=adapter_number, unit=port_number)
        await self._ubridge_send("iol_bridge reset_packet_filters " + location)
        for filter in self._build_filter_list(filters):
            cmd = "iol_bridge add_packet_filter {} {}".format(location, filter)
            await self._ubridge_send(cmd)

    async def adapter_remove_nio_binding(self, adapter_number, port_number):
        """
        Removes an adapter NIO binding.

        :param adapter_number: adapter number
        :param port_number: port number

        :returns: NIO instance
        """

        try:
            adapter = self._adapters[adapter_number]
        except IndexError:
            raise IOUError(
                'Adapter {adapter_number} does not exist on IOU "{name}"'.format(
                    name=self._name, adapter_number=adapter_number
                )
            )

        if not adapter.port_exists(port_number):
            raise IOUError(
                "Port {port_number} does not exist on adapter {adapter}".format(
                    adapter=adapter, port_number=port_number
                )
            )

        nio = adapter.get_nio(port_number)
        if isinstance(nio, NIOUDP):
            self.manager.port_manager.release_udp_port(nio.lport, self._project)
        adapter.remove_nio(port_number)
        log.info(
            'IOU "{name}" [{id}]: {nio} removed from {adapter_number}/{port_number}'.format(
                name=self._name, id=self._id, nio=nio, adapter_number=adapter_number, port_number=port_number
            )
        )

        if self.ubridge:
            bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
            await self._ubridge_send(
                "iol_bridge delete_nio_udp {name} {bay} {unit}".format(
                    name=bridge_name, bay=adapter_number, unit=port_number
                )
            )

        return nio

    def get_nio(self, adapter_number, port_number):
        """
        Gets an adapter NIO binding.

        :param adapter_number: adapter number
        :param port_number: port number

        :returns: NIO instance
        """

        try:
            adapter = self._adapters[adapter_number]
        except IndexError:
            raise IOUError(
                'Adapter {adapter_number} does not exist on IOU "{name}"'.format(
                    name=self._name, adapter_number=adapter_number
                )
            )

        if not adapter.port_exists(port_number):
            raise IOUError(
                "Port {port_number} does not exist on adapter {adapter}".format(
                    adapter=adapter, port_number=port_number
                )
            )

        nio = adapter.get_nio(port_number)

        if not nio:
            raise IOUError(
                "NIO {port_number} does not exist on adapter {adapter}".format(adapter=adapter, port_number=port_number)
            )
        return nio

    @property
    def l1_keepalives(self):
        """
        Returns either layer 1 keepalive messages option is enabled or disabled.

        :returns: boolean
        """

        return self._l1_keepalives

    @l1_keepalives.setter
    def l1_keepalives(self, state):
        """
        Enables or disables layer 1 keepalive messages.

        :param state: boolean
        """

        self._l1_keepalives = state
        if state:
            log.info(f'IOU "{self._name}" [{self._id}]: has activated layer 1 keepalive messages')
        else:
            log.info(f'IOU "{self._name}" [{self._id}]: has deactivated layer 1 keepalive messages')

    async def _enable_l1_keepalives(self, command):
        """
        Enables L1 keepalive messages if supported.

        :param command: command line
        """

        env = os.environ.copy()
        if "IOURC" not in os.environ:
            env["IOURC"] = self.iourc_path
        try:
            output = await gns3server.utils.asyncio.subprocess_check_output(
                *self._loader, self._path, "-h", cwd=self.working_dir, env=env, stderr=True
            )
            if re.search(r"-l\s+Enable Layer 1 keepalive messages", output):
                command.extend(["-l"])
            else:
                raise IOUError(f"layer 1 keepalive messages are not supported by {os.path.basename(self._path)}")
        except (OSError, subprocess.SubprocessError) as e:
            log.warning(
                f"could not determine if layer 1 keepalive messages are supported by {os.path.basename(self._path)}: {e}"
            )

    @property
    def startup_config_content(self):
        """
        Returns the content of the current startup-config file.
        """

        config_file = self.startup_config_file
        if config_file is None:
            return None

        try:
            with open(config_file, "rb") as f:
                return f.read().decode("utf-8", errors="replace")
        except OSError as e:
            raise IOUError(f"Can't read startup-config file '{config_file}': {e}")

    @startup_config_content.setter
    def startup_config_content(self, startup_config):
        """
        Update the startup config

        :param startup_config: content of the startup configuration file
        """

        try:
            startup_config_path = os.path.join(self.working_dir, "startup-config.cfg")

            if startup_config is None:
                startup_config = ""

            # We disallow erasing the startup config file
            if len(startup_config) == 0 and os.path.exists(startup_config_path):
                return

            with open(startup_config_path, "w+", encoding="utf-8") as f:
                if len(startup_config) == 0:
                    f.write("")
                else:
                    startup_config = startup_config.replace("%h", self._name)
                    f.write(startup_config)

            vlan_file = os.path.join(self.working_dir, f"vlan.dat-{self.application_id:05d}")
            if os.path.exists(vlan_file):
                try:
                    os.remove(vlan_file)
                except OSError as e:
                    log.error(f"Could not delete VLAN file '{vlan_file}': {e}")

        except OSError as e:
            raise IOUError(f"Can't write startup-config file '{startup_config_path}': {e}")

    @property
    def private_config_content(self):
        """
        Returns the content of the current private-config file.
        """

        config_file = self.private_config_file
        if config_file is None:
            return None

        try:
            with open(config_file, "rb") as f:
                return f.read().decode("utf-8", errors="replace")
        except OSError as e:
            raise IOUError(f"Can't read private-config file '{config_file}': {e}")

    @private_config_content.setter
    def private_config_content(self, private_config):
        """
        Update the private config

        :param private_config: content of the private configuration file
        """

        try:
            private_config_path = os.path.join(self.working_dir, "private-config.cfg")

            if private_config is None:
                private_config = ""

            # We disallow erasing the private config file
            if len(private_config) == 0 and os.path.exists(private_config_path):
                return

            with open(private_config_path, "w+", encoding="utf-8") as f:
                if len(private_config) == 0:
                    f.write("")
                else:
                    private_config = private_config.replace("%h", self._name)
                    f.write(private_config)
        except OSError as e:
            raise IOUError(f"Can't write private-config file '{private_config_path}': {e}")

    @property
    def startup_config_file(self):
        """
        Returns the startup-config file for this IOU VM.

        :returns: path to config file. None if the file doesn't exist
        """

        path = os.path.join(self.working_dir, "startup-config.cfg")
        if os.path.exists(path):
            return path
        else:
            return None

    @property
    def private_config_file(self):
        """
        Returns the private-config file for this IOU VM.

        :returns: path to config file. None if the file doesn't exist
        """

        path = os.path.join(self.working_dir, "private-config.cfg")
        if os.path.exists(path):
            return path
        else:
            return None

    @property
    def relative_startup_config_file(self):
        """
        Returns the startup-config file relative to the project directory.
        It's compatible with pre 1.3 projects.

        :returns: path to startup-config file. None if the file doesn't exist
        """

        path = os.path.join(self.working_dir, "startup-config.cfg")
        if os.path.exists(path):
            return "startup-config.cfg"
        else:
            return None

    @property
    def relative_private_config_file(self):
        """
        Returns the private-config file relative to the project directory.

        :returns: path to private-config file. None if the file doesn't exist
        """

        path = os.path.join(self.working_dir, "private-config.cfg")
        if os.path.exists(path):
            return "private-config.cfg"
        else:
            return None

    @property
    def application_id(self):
        """
        Returns application_id which unique identifier for IOU running script. Value is between 1 and 512.
        When it's not set returns value from the local manager.

        :returns: integer between 1 and 512
        """

        return self._application_id

    @application_id.setter
    def application_id(self, application_id):
        """
        Sets application_id for IOU.

        :param: integer between 1 and 512
        """
        self._application_id = application_id

    def extract_configs(self):
        """
        Gets the contents of the config files
        startup-config and private-config from NVRAM.

        :returns: tuple (startup-config, private-config)
        """

        nvram_file = os.path.join(self.working_dir, f"nvram_{self.application_id:05d}")
        if not os.path.exists(nvram_file):
            return None, None
        try:
            with open(nvram_file, "rb") as file:
                nvram_content = file.read()
        except OSError as e:
            log.warning(f"Cannot read nvram file {nvram_file}: {e}")
            return None, None

        try:
            startup_config_content, private_config_content = nvram_export(nvram_content)
        except ValueError as e:
            log.warning(f"Could not export configs from nvram file {nvram_file}: {e}")
            return None, None

        return startup_config_content, private_config_content

    def save_configs(self):
        """
        Saves the startup-config and private-config to files.
        """

        if self.startup_config_content or self.private_config_content:
            startup_config_content, private_config_content = self.extract_configs()
            if startup_config_content:
                config_path = os.path.join(self.working_dir, "startup-config.cfg")
                try:
                    config = startup_config_content.decode("utf-8", errors="replace")
                    with open(config_path, "wb") as f:
                        log.info(f"saving startup-config to {config_path}")
                        f.write(config.encode("utf-8"))
                except (binascii.Error, OSError) as e:
                    raise IOUError(f"Could not save the startup configuration {config_path}: {e}")

            if private_config_content and private_config_content != b"\nend\n":
                config_path = os.path.join(self.working_dir, "private-config.cfg")
                try:
                    config = private_config_content.decode("utf-8", errors="replace")
                    with open(config_path, "wb") as f:
                        log.info(f"saving private-config to {config_path}")
                        f.write(config.encode("utf-8"))
                except (binascii.Error, OSError) as e:
                    raise IOUError(f"Could not save the private configuration {config_path}: {e}")

    async def start_capture(self, adapter_number, port_number, output_file, data_link_type="DLT_EN10MB"):
        """
        Starts a packet capture.

        :param adapter_number: adapter number
        :param port_number: port number
        :param output_file: PCAP destination file for the capture
        :param data_link_type: PCAP data link type (DLT_*), default is DLT_EN10MB
        """

        nio = self.get_nio(adapter_number, port_number)
        if nio.capturing:
            raise IOUError(
                "Packet capture is already activated on {adapter_number}/{port_number}".format(
                    adapter_number=adapter_number, port_number=port_number
                )
            )

        nio.start_packet_capture(output_file, data_link_type)
        log.info(
            'IOU "{name}" [{id}]: starting packet capture on {adapter_number}/{port_number} to {output_file}'.format(
                name=self._name,
                id=self._id,
                adapter_number=adapter_number,
                port_number=port_number,
                output_file=output_file,
            )
        )

        if self.ubridge:
            bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
            await self._ubridge_send(
                'iol_bridge start_capture {name} {bay} {unit} "{output_file}" {data_link_type}'.format(
                    name=bridge_name,
                    bay=adapter_number,
                    unit=port_number,
                    output_file=output_file,
                    data_link_type=re.sub(r"^DLT_", "", data_link_type),
                )
            )

    async def stop_capture(self, adapter_number, port_number):
        """
        Stops a packet capture.

        :param adapter_number: adapter number
        :param port_number: port number
        """

        nio = self.get_nio(adapter_number, port_number)
        if not nio.capturing:
            return
        nio.stop_packet_capture()
        log.info(
            'IOU "{name}" [{id}]: stopping packet capture on {adapter_number}/{port_number}'.format(
                name=self._name, id=self._id, adapter_number=adapter_number, port_number=port_number
            )
        )
        if self.ubridge:
            bridge_name = f"IOL-BRIDGE-{self.application_id + 512}"
            await self._ubridge_send(
                "iol_bridge stop_capture {name} {bay} {unit}".format(
                    name=bridge_name, bay=adapter_number, unit=port_number
                )
            )