gns3-server 3.0.0__py3-none-any.whl

gns3server/utils/asyncio/telnet_server.py

@@ -0,0 +1,450 @@
+#
+# 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/>.
+
+import sys
+import socket
+import asyncio
+import asyncio.subprocess
+import struct
+
+import logging
+
+log = logging.getLogger(__name__)
+
+# Mostly from https://code.google.com/p/miniboa/source/browse/trunk/miniboa/telnet.py
+
+# Telnet Commands
+SE = 240  # End of sub-negotiation parameters
+NOP = 241  # No operation
+DATMK = 242  # Data stream portion of a sync.
+BREAK = 243  # NVT Character BRK
+IP = 244  # Interrupt Process
+AO = 245  # Abort Output
+AYT = 246  # Are you there
+EC = 247  # Erase Character
+EL = 248  # Erase Line
+GA = 249  # The Go Ahead Signal
+SB = 250  # Sub-option to follow
+WILL = 251  # Will; request or confirm option begin
+WONT = 252  # Wont; deny option request
+DO = 253  # Do = Request or confirm remote option
+DONT = 254  # Don't = Demand or confirm option halt
+IAC = 255  # Interpret as Command
+SEND = 1  # Sub-process negotiation SEND command
+IS = 0  # Sub-process negotiation IS command
+
+# Telnet Options
+BINARY = 0  # Transmit Binary
+ECHO = 1  # Echo characters back to sender
+RECON = 2  # Reconnection
+SGA = 3  # Suppress Go-Ahead
+TMARK = 6  # Timing Mark
+TTYPE = 24  # Terminal Type
+NAWS = 31  # Negotiate About Window Size
+LINEMO = 34  # Line Mode
+
+READ_SIZE = 1024
+
+
+class TelnetConnection:
+    """Default implementation of telnet connection which may but may not be used."""
+
+    def __init__(self, reader, writer, window_size_changed_callback=None):
+        self.is_closing = False
+        self._reader = reader
+        self._writer = writer
+        self._window_size_changed_callback = window_size_changed_callback
+
+    @property
+    def reader(self):
+        return self._reader
+
+    @property
+    def writer(self):
+        return self._writer
+
+    async def connected(self):
+        """Method called when client is connected"""
+        pass
+
+    async def disconnected(self):
+        """Method called when client is disconnecting"""
+        pass
+
+    async def window_size_changed(self, columns, rows):
+        """Method called when window size changed, only can occur when
+        `naws` flag is enable in server configuration."""
+
+        if self._window_size_changed_callback:
+            await self._window_size_changed_callback(columns, rows)
+
+    async def feed(self, data):
+        """
+        Handles incoming data
+        :return:
+        """
+
+    def send(self, data):
+        """
+        Sending data back to client
+        :return:
+        """
+        data = data.decode().replace("\n", "\r\n")
+        self.writer.write(data.encode())
+
+    def close(self):
+        """
+        Closes current connection
+        :return:
+        """
+        self.is_closing = True
+
+
+class AsyncioTelnetServer:
+    MAX_NEGOTIATION_READ = 10
+
+    def __init__(
+        self,
+        reader=None,
+        writer=None,
+        binary=True,
+        echo=False,
+        naws=False,
+        window_size_changed_callback=None,
+        connection_factory=None,
+    ):
+        """
+        Initializes telnet server
+        :param naws when True make a window size negotiation
+        :param connection_factory: when set it's possible to inject own implementation of connection
+        """
+        assert connection_factory is None or (
+            connection_factory is not None and reader is None and writer is None
+        ), "Please use either reader and writer either connection_factory, otherwise duplicate data may be produced."
+
+        self._reader = reader
+        self._writer = writer
+        self._connections = dict()
+        self._lock = asyncio.Lock()
+        self._reader_process = None
+        self._current_read = None
+        self._window_size_changed_callback = window_size_changed_callback
+
+        self._binary = binary
+        # If echo is true when the client send data
+        # the data is echo on his terminal by telnet otherwise
+        # it's our job (or the wrapped app) to send back the data
+        self._echo = echo
+        self._naws = naws
+
+        def default_connection_factory(reader, writer, window_size_changed_callback):
+            return TelnetConnection(reader, writer, window_size_changed_callback)
+
+        if connection_factory is None:
+            connection_factory = default_connection_factory
+
+        self._connection_factory = connection_factory
+
+    @staticmethod
+    async def write_client_intro(writer, echo=False):
+        # Send initial telnet session opening
+        if echo:
+            writer.write(bytes([IAC, WILL, ECHO]))
+        else:
+            writer.write(bytes([IAC, WONT, ECHO, IAC, DONT, ECHO]))
+        await writer.drain()
+
+    async def _write_intro(self, writer, binary=False, echo=False, naws=False):
+        # Send initial telnet session opening
+        if echo:
+            writer.write(bytes([IAC, WILL, ECHO]))
+        else:
+            writer.write(bytes([IAC, WONT, ECHO, IAC, DONT, ECHO]))
+
+        if binary:
+            writer.write(bytes([IAC, WILL, SGA, IAC, WILL, BINARY, IAC, DO, BINARY]))
+        else:
+            writer.write(bytes([IAC, WONT, SGA, IAC, DONT, SGA, IAC, WONT, BINARY, IAC, DONT, BINARY]))
+
+        if naws:
+            writer.write(bytes([IAC, DO, NAWS]))
+        await writer.drain()
+
+    async def run(self, network_reader, network_writer):
+
+        sock = network_writer.get_extra_info("socket")
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        # 60 sec keep alives, close tcp session after 4 missed
+        # Will keep a firewall from aging out telnet console.
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 60)
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 10)
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 4)
+        #log.debug("New connection from {}".format(sock.getpeername()))
+
+        # Keep track of connected clients
+        connection = self._connection_factory(network_reader, network_writer, self._window_size_changed_callback)
+        self._connections[network_writer] = connection
+
+        try:
+            await self._write_intro(network_writer, echo=self._echo, binary=self._binary, naws=self._naws)
+            await connection.connected()
+            await self._process(network_reader, network_writer, connection)
+        except ConnectionError:
+            async with self._lock:
+                network_writer.close()
+                # await network_writer.wait_closed()  # this doesn't work in Python 3.6
+                if self._reader_process == network_reader:
+                    self._reader_process = None
+                    # Cancel current read from this reader
+                    if self._current_read is not None:
+                        self._current_read.cancel()
+
+            await connection.disconnected()
+            del self._connections[network_writer]
+
+    async def close(self):
+        for writer, connection in self._connections.items():
+            try:
+                writer.write_eof()
+                await writer.drain()
+                writer.close()
+                # await writer.wait_closed()  # this doesn't work in Python 3.6
+            except (AttributeError, ConnectionError):
+                continue
+
+    async def client_connected_hook(self):
+        pass
+
+    async def _get_reader(self, network_reader):
+        """
+        Get a reader or None if another reader is already reading.
+        """
+        async with self._lock:
+            if self._reader_process is None:
+                self._reader_process = network_reader
+            if self._reader:
+                if self._reader_process == network_reader:
+                    self._current_read = asyncio.ensure_future(self._reader.read(READ_SIZE))
+                    return self._current_read
+        return None
+
+    async def _process(self, network_reader, network_writer, connection):
+        network_read = asyncio.ensure_future(network_reader.read(READ_SIZE))
+        reader_read = await self._get_reader(network_reader)
+
+        while True:
+            if reader_read is None:
+                reader_read = await self._get_reader(network_reader)
+            if reader_read is None:
+                done, pending = await asyncio.wait(
+                    [
+                        network_read,
+                    ],
+                    timeout=1,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+            else:
+                done, pending = await asyncio.wait([network_read, reader_read], return_when=asyncio.FIRST_COMPLETED)
+            for coro in done:
+                data = coro.result()
+                if coro == network_read:
+                    if network_reader.at_eof():
+                        raise ConnectionResetError()
+
+                    network_read = asyncio.ensure_future(network_reader.read(READ_SIZE))
+
+                    if IAC in data:
+                        data = await self._IAC_parser(data, network_reader, network_writer, connection)
+
+                    if len(data) == 0:
+                        continue
+
+                    if not self._binary:
+                        data = data.replace(b"\r\n", b"\n")
+
+                    if self._writer:
+                        self._writer.write(data)
+                        await self._writer.drain()
+
+                    await connection.feed(data)
+                    if connection.is_closing:
+                        raise ConnectionResetError()
+
+                elif coro == reader_read:
+                    if self._reader and self._reader.at_eof():
+                        raise ConnectionResetError()
+
+                    reader_read = await self._get_reader(network_reader)
+
+                    # Replicate the output on all clients
+                    for connection_key in list(self._connections.keys()):
+                        client_info = connection_key.get_extra_info("socket").getpeername()
+                        connection = self._connections[connection_key]
+
+                        try:
+                            connection.writer.write(data)
+                            await asyncio.wait_for(connection.writer.drain(), timeout=10)
+                        except:
+                            log.debug(f"Timeout while sending data to client: {client_info}, closing and removing from connection table.")
+                            connection.close()
+                            del self._connections[connection_key]
+
+    async def _read(self, cmd, buffer, location, reader):
+        """ Reads next op from the buffer or reader"""
+        try:
+            op = buffer[location]
+            cmd.append(op)
+            return op
+        except IndexError:
+            op = await reader.read(1)
+            buffer.extend(op)
+            cmd.append(buffer[location])
+            return op
+
+    async def _negotiate(self, data, connection):
+        """ Performs negotiation commands"""
+
+        command, payload = data[0], data[1:]
+        if command == NAWS:
+            if len(payload) == 4:
+                columns, rows = struct.unpack("!HH", bytes(payload))
+                await connection.window_size_changed(columns, rows)
+            else:
+                log.warning("Wrong number of NAWS bytes")
+        else:
+            log.debug("Not supported negotiation sequence, received {} bytes", len(data))
+
+    async def _IAC_parser(self, buf, network_reader, network_writer, connection):
+        """
+        Processes and removes any Telnet commands from the buffer.
+
+        :param buf: buffer
+        :returns: buffer minus Telnet commands
+        """
+
+        skip_to = 0
+        while True:
+            # Locate an IAC to process
+            iac_loc = buf.find(IAC, skip_to)
+            if iac_loc < 0:
+                break
+
+            # Get the TELNET command
+            iac_cmd = bytearray([IAC])
+            try:
+                iac_cmd.append(buf[iac_loc + 1])
+            except IndexError:
+                d = await network_reader.read(1)
+                buf.extend(d)
+                iac_cmd.append(buf[iac_loc + 1])
+
+            # Is this just a 2-byte TELNET command?
+            if iac_cmd[1] not in [WILL, WONT, DO, DONT, SB]:
+                if iac_cmd[1] == AYT:
+                    log.debug("Telnet server received Are-You-There (AYT)")
+                    network_writer.write(b"\r\nYour Are-You-There received. I am here.\r\n")
+                elif iac_cmd[1] == IAC:
+                    # It's data, not an IAC
+                    iac_cmd.pop()
+                    # This prevents the 0xff from being
+                    # interrupted as yet another IAC
+                    skip_to = iac_loc + 1
+                    log.debug("Received IAC IAC")
+                elif iac_cmd[1] == NOP:
+                    pass
+                else:
+                    log.debug("Unhandled telnet command: " "{:#x} {:#x}".format(*iac_cmd))
+            elif iac_cmd[1] == SB:  # starts negotiation commands
+                negotiation = []
+                for pos in range(2, self.MAX_NEGOTIATION_READ):
+                    op = await self._read(iac_cmd, buf, iac_loc + pos, network_reader)
+                    negotiation.append(op)
+                    if op == SE:
+                        # ends negotiation commands
+                        break
+
+                # SE command is followed by IAC, remove the last two operations from stack
+                await self._negotiate(negotiation[0:-2], connection)
+
+            # This must be a 3-byte TELNET command
+            else:
+                try:
+                    iac_cmd.append(buf[iac_loc + 2])
+                except IndexError:
+                    d = await network_reader.read(1)
+                    buf.extend(d)
+                    iac_cmd.append(buf[iac_loc + 2])
+                # We do ECHO, SGA, and BINARY. Period.
+                if iac_cmd[1] == DO:
+                    if iac_cmd[2] not in [ECHO, SGA, BINARY]:
+                        network_writer.write(bytes([IAC, WONT, iac_cmd[2]]))
+                        log.debug(f"Telnet WON'T {iac_cmd[2]:#x}")
+                    else:
+                        if iac_cmd[2] == SGA:
+                            if self._binary:
+                                network_writer.write(bytes([IAC, WILL, iac_cmd[2]]))
+                            else:
+                                network_writer.write(bytes([IAC, WONT, iac_cmd[2]]))
+                                log.debug(f"Telnet WON'T {iac_cmd[2]:#x}")
+
+                elif iac_cmd[1] == DONT:
+                    log.debug("Unhandled DONT telnet command: " "{:#x} {:#x} {:#x}".format(*iac_cmd))
+                elif iac_cmd[1] == WILL:
+                    if iac_cmd[2] not in [BINARY, NAWS]:
+                        log.debug("Unhandled WILL telnet command: " "{:#x} {:#x} {:#x}".format(*iac_cmd))
+                elif iac_cmd[1] == WONT:
+                    log.debug("Unhandled WONT telnet command: " "{:#x} {:#x} {:#x}".format(*iac_cmd))
+                else:
+                    log.debug("Unhandled telnet command: " "{:#x} {:#x} {:#x}".format(*iac_cmd))
+
+            # Remove the entire TELNET command from the buffer
+            buf = buf.replace(iac_cmd, b"", 1)
+
+            await network_writer.drain()
+
+        # Return the new copy of the buffer, minus telnet commands
+        return buf
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+    loop = asyncio.get_event_loop()
+
+    process = loop.run_until_complete(
+        asyncio.ensure_future(
+            asyncio.subprocess.create_subprocess_exec(
+                "/bin/sh",
+                "-i",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                stdin=asyncio.subprocess.PIPE,
+            )
+        )
+    )
+    server = AsyncioTelnetServer(reader=process.stdout, writer=process.stdin, binary=False, echo=False)
+
+    coro = asyncio.start_server(server.run, "127.0.0.1", 4444)
+    s = loop.run_until_complete(coro)
+
+    try:
+        loop.run_forever()
+    except KeyboardInterrupt:
+        pass
+    # Close the server
+    s.close()
+    loop.run_until_complete(s.wait_closed())
+    loop.close()

gns3server/utils/cpu_percent.py

@@ -0,0 +1,46 @@
+#
+# Copyright (C) 2020 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/>.
+
+import psutil
+import time
+
+
+class CpuPercent:
+    """
+    Ensures a minimum interval between two cpu_percent() calls
+    """
+
+    _last_measurement = None  # time of last measurement
+    _last_cpu_percent = 0.0  # last cpu_percent
+
+    @classmethod
+    def get(cls, interval=None):
+        """
+        Get CPU utilization as a percentage
+
+        :returns: float
+        """
+
+        if interval:
+            cls._last_cpu_percent = psutil.cpu_percent(interval=interval)
+            cls._last_measurement = time.monotonic()
+        else:
+            cur_time = time.monotonic()
+            if cls._last_measurement is None or (cur_time - cls._last_measurement) >= 1.9:
+                cls._last_cpu_percent = psutil.cpu_percent(interval=None)
+                cls._last_measurement = cur_time
+
+        return cls._last_cpu_percent

gns3server/utils/file_watcher.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2016 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/>.
+
+import zlib
+import asyncio
+import os
+
+
+class FileWatcher:
+    """
+    Watch for file change and call the callback when something happens
+
+    :param paths: A path or a list of file to watch
+    :param delay: Delay between file check (seconds)
+    :param strategy: File change strategy (mtime: modification time, hash: hash compute)
+    """
+
+    def __init__(self, paths, callback, delay=1, strategy="mtime"):
+        self._paths = []
+        if not isinstance(paths, list):
+            paths = [paths]
+        for path in paths:
+            if not isinstance(path, str):
+                path = str(path)
+            self._paths.append(path)
+
+        self._callback = callback
+        self._delay = delay
+        self._closed = False
+        self._strategy = strategy
+
+        if self._strategy == "mtime":
+            # Store modification time
+            self._mtime = {}
+            for path in self._paths:
+                try:
+                    self._mtime[path] = os.stat(path).st_mtime_ns
+                except OSError:
+                    self._mtime[path] = None
+        else:
+            # Store hash
+            self._hashed = {}
+            for path in self._paths:
+                try:
+                    # Alder32 is a fast but insecure hash algorithm
+                    self._hashed[path] = zlib.adler32(open(path, "rb").read())
+                except OSError:
+                    self._hashed[path] = None
+        asyncio.get_event_loop().call_later(self._delay, self._check_config_file_change)
+
+    def __del__(self):
+        self._closed = True
+
+    def close(self):
+        self._closed = True
+
+    def _check_config_file_change(self):
+        if self._closed:
+            return
+        changed = False
+
+        for path in self._paths:
+            if self._strategy == "mtime":
+                try:
+                    mtime = os.stat(path).st_mtime_ns
+                    if mtime != self._mtime[path]:
+                        changed = True
+                        self._mtime[path] = mtime
+                except OSError:
+                    self._mtime[path] = None
+            else:
+                try:
+                    hashc = zlib.adler32(open(path, "rb").read())
+                    if hashc != self._hashed[path]:
+                        changed = True
+                        self._hashed[path] = hashc
+                except OSError:
+                    self._hashed[path] = None
+            if changed:
+                self._callback(path)
+        asyncio.get_event_loop().call_later(self._delay, self._check_config_file_change)
+
+    @property
+    def callback(self):
+        return self._callback
+
+    @callback.setter
+    def callback(self, val):
+        self._callback = val

gns3server/utils/get_resource.py

@@ -0,0 +1,48 @@
+#
+# 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/>.
+
+import atexit
+import logging
+import os
+import sys
+
+try:
+    import importlib_resources
+except ImportError:
+    from importlib import resources as importlib_resources
+
+
+from contextlib import ExitStack
+resource_manager = ExitStack()
+atexit.register(resource_manager.close)
+
+log = logging.getLogger(__name__)
+
+
+def get_resource(resource_name):
+    """
+    Return a resource in current directory or in frozen package
+    """
+
+    resource_path = None
+    if hasattr(sys, "frozen"):
+        resource_path = os.path.normpath(os.path.join(os.path.dirname(sys.executable), resource_name))
+    else:
+        ref = importlib_resources.files("gns3server") / resource_name
+        path = resource_manager.enter_context(importlib_resources.as_file(ref))
+        if os.path.exists(path):
+            resource_path = os.path.normpath(path)
+    return resource_path