gns3-server 3.0.0__py3-none-any.whl

gns3server/compute/iou/utils/iou_export.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+
+# To use python v2.7 change the first line to:
+#!/usr/bin/env python
+
+# Copyright (C) 2015 Bernhard Ehlers
+#
+# 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 2 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/>.
+
+# This utility is a stripped down version of dynamips' nvram_export,
+# ported from C to Python, see https://github.com/GNS3/dynamips
+# nvram_export is (c) 2013 Flávio J. Saraiva
+
+"""
+iou_export exports startup/private configuration from IOU NVRAM file.
+
+usage: iou_export [-h] NVRAM startup-config [private-config]
+
+positional arguments:
+  NVRAM           NVRAM file
+  startup-config  startup configuration
+  private-config  private configuration
+
+optional arguments:
+  -h, --help      show this help message and exit
+"""
+
+import struct
+
+
+# Uncompress data in LZC format, .Z file format
+# LZC uses the LZW compression algorithm with a variable dictionary size
+# For LZW see https://en.wikipedia.org/wiki/Lempel–Ziv–Welch
+# Performance: about 1 MByte/sec, 15-50 times slower than C implementation
+def uncompress_LZC(data):
+    LZC_NUM_BITS_MIN = 9
+    LZC_NUM_BITS_MAX = 16
+
+    in_data = bytearray(data)
+    in_len = len(in_data)
+    out_data = bytearray()
+
+    if in_len == 0:
+        return out_data
+    if in_len < 3:
+        raise ValueError("invalid length")
+    if in_data[0] != 0x1F or in_data[1] != 0x9D:
+        raise ValueError("invalid header")
+
+    max_bits = in_data[2] & 0x1F
+    if max_bits < LZC_NUM_BITS_MIN or max_bits > LZC_NUM_BITS_MAX:
+        raise ValueError("not supported")
+    num_items = 1 << max_bits
+    blockmode = (in_data[2] & 0x80) != 0
+
+    in_pos = 3
+    start_pos = in_pos
+    num_bits = LZC_NUM_BITS_MIN
+    dict_size = 1 << num_bits
+    head = 256
+    if blockmode:
+        head += 1
+    first_sym = True
+
+    # initialize dictionary
+    comp_dict = [None] * num_items
+    for i in range(0, 256):
+        comp_dict[i] = bytes(bytearray([i]))
+
+    buf = buf_bits = 0
+    while in_pos < in_len:
+        # get next symbol
+        try:
+            while buf_bits < num_bits:
+                buf |= in_data[in_pos] << buf_bits
+                buf_bits += 8
+                in_pos += 1
+            buf, symbol = divmod(buf, dict_size)
+            buf_bits -= num_bits
+        except IndexError:
+            raise ValueError("invalid data")
+
+        # re-initialize dictionary
+        if blockmode and symbol == 256:
+            # skip to next buffer boundary
+            buf = buf_bits = 0
+            in_pos += (start_pos - in_pos) % num_bits
+            # reset to LZC_NUM_BITS_MIN
+            head = 257
+            num_bits = LZC_NUM_BITS_MIN
+            dict_size = 1 << num_bits
+            start_pos = in_pos
+            first_sym = True
+            continue
+
+        # first symbol
+        if first_sym:
+            first_sym = False
+            if symbol >= 256:
+                raise ValueError("invalid data")
+            prev = symbol
+            out_data.extend(comp_dict[symbol])
+            continue
+
+        # dictionary full
+        if head >= num_items:
+            out_data.extend(comp_dict[symbol])
+            continue
+
+        # update compression dictionary
+        if symbol < head:
+            comp_dict[head] = comp_dict[prev] + comp_dict[symbol][0:1]
+        elif symbol == head:
+            comp_dict[head] = comp_dict[prev] + comp_dict[prev][0:1]
+        else:
+            raise ValueError("invalid data")
+        prev = symbol
+
+        # output symbol
+        out_data.extend(comp_dict[symbol])
+
+        # update head, check for num_bits change
+        head += 1
+        if head >= dict_size and num_bits < max_bits:
+            num_bits += 1
+            dict_size = 1 << num_bits
+            start_pos = in_pos
+
+    return out_data
+
+
+# export IOU NVRAM
+# NVRAM format: https://github.com/ehlers/IOUtools/blob/master/NVRAM.md
+def nvram_export(nvram):
+    nvram = bytearray(nvram)
+
+    offset = 0
+    # extract startup config
+    try:
+        (magic, data_format, _, _, _, _, length, _, _, _, _, _) = struct.unpack_from(
+            ">HHHHIIIIIHHI", nvram, offset=offset
+        )
+        offset += 36
+        if magic != 0xABCD:
+            raise ValueError("no startup config")
+        if len(nvram) < offset + length:
+            raise ValueError("invalid length")
+        startup = nvram[offset : offset + length]
+    except struct.error:
+        raise ValueError("invalid length")
+
+    # uncompress startup config
+    if data_format == 2:
+        try:
+            startup = uncompress_LZC(startup)
+        except ValueError as err:
+            raise ValueError("uncompress startup: " + str(err))
+
+    private = None
+    try:
+        # calculate offset of private header
+        length += (4 - length % 4) % 4  # alignment to multiple of 4
+        offset += length
+        # check for additonal offset of 4
+        (magic, data_format) = struct.unpack_from(">HH", nvram, offset=offset + 4)
+        if magic == 0xFEDC and data_format == 1:
+            offset += 4
+
+        # extract private config
+        (magic, data_format, _, _, length) = struct.unpack_from(">HHIII", nvram, offset=offset)
+        offset += 16
+        if magic == 0xFEDC and data_format == 1:
+            if len(nvram) < offset + length:
+                raise ValueError("invalid length")
+            private = nvram[offset : offset + length]
+
+    # missing private header is not an error
+    except struct.error:
+        pass
+
+    return (startup, private)
+
+
+if __name__ == "__main__":
+    # Main program
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="%(prog)s exports startup/private configuration from IOU NVRAM file.")
+    parser.add_argument("nvram", metavar="NVRAM", help="NVRAM file")
+    parser.add_argument("startup", metavar="startup-config", help="startup configuration")
+    parser.add_argument("private", metavar="private-config", nargs="?", help="private configuration")
+    args = parser.parse_args()
+
+    try:
+        fd = open(args.nvram, "rb")
+        nvram = fd.read()
+        fd.close()
+    except OSError as err:
+        sys.stderr.write(f"Error reading file: {err}\n")
+        sys.exit(1)
+
+    try:
+        startup, private = nvram_export(nvram)
+    except ValueError as err:
+        sys.stderr.write(f"nvram_export: {err}\n")
+        sys.exit(3)
+
+    try:
+        fd = open(args.startup, "wb")
+        fd.write(startup)
+        fd.close()
+        if args.private is not None:
+            if private is None:
+                sys.stderr.write("Warning: No private config\n")
+            else:
+                fd = open(args.private, "wb")
+                fd.write(private)
+                fd.close()
+    except OSError as err:
+        sys.stderr.write(f"Error writing file: {err}\n")
+        sys.exit(1)

gns3server/compute/iou/utils/iou_import.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+
+# To use python v2.7 change the first line to:
+#!/usr/bin/env python
+
+# Copyright (C) 2015 Bernhard Ehlers
+#
+# 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 2 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_import imports startup/private configuration into IOU NVRAM file.
+
+usage: iou_import [-h] [-c size] NVRAM startup-config [private-config]
+
+positional arguments:
+  NVRAM                 NVRAM file
+  startup-config        startup configuration
+  private-config        private configuration
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -c size, --create size
+                        create NVRAM file, size in kByte
+"""
+
+import struct
+
+
+# calculate padding
+def padding(length, start_address):
+    pad = -length % 4  # padding to alignment of 4
+    # extra padding if pad != 0 and big start_address
+    if pad != 0 and (start_address & 0x80000000) != 0:
+        pad += 4
+    return pad
+
+
+# update checksum
+def checksum(data, start, end):
+    chk = 0
+    # calculate checksum of first two words
+    for word in struct.unpack_from(">2H", data, start):
+        chk += word
+
+    # add remaining words, ignoring old checksum at offset 4
+    struct_format = f">{(end - start - 6) // 2:d}H"
+    for word in struct.unpack_from(struct_format, data, start + 6):
+        chk += word
+
+    # handle 16 bit overflow
+    while chk >> 16:
+        chk = (chk & 0xFFFF) + (chk >> 16)
+    chk = chk ^ 0xFFFF
+
+    # save checksum
+    struct.pack_into(">H", data, start + 4, chk)
+
+
+# import IOU NVRAM
+# NVRAM format: https://github.com/ehlers/IOUtools/blob/master/NVRAM.md
+def nvram_import(nvram, startup, private, size):
+    DEFAULT_IOS = 0x0F04  # IOS 15.4
+    base_address = 0x10000000
+
+    # check size parameter
+    if size is not None and (size < 8 or size > 1024):
+        raise ValueError("invalid size")
+
+    # create new nvram if nvram is empty or has wrong size
+    if nvram is None or (size is not None and len(nvram) != size * 1024):
+        nvram = bytearray([0] * (size * 1024))
+    else:
+        nvram = bytearray(nvram)
+
+    # check nvram size
+    nvram_len = len(nvram)
+    if nvram_len < 8 * 1024 or nvram_len > 1024 * 1024 or nvram_len % 1024 != 0:
+        raise ValueError("invalid NVRAM length")
+    nvram_len = nvram_len // 2
+
+    # get size of current config
+    config_len = 0
+    try:
+        (magic, _, _, ios, start_addr, _, length, _, _, _, _, _) = struct.unpack_from(">HHHHIIIIIHHI", nvram, offset=0)
+        if magic == 0xABCD:
+            base_address = start_addr - 36
+            config_len = 36 + length + padding(length, base_address)
+            (magic, _, _, _, length) = struct.unpack_from(">HHIII", nvram, offset=config_len)
+            if magic == 0xFEDC:
+                config_len += 16 + length
+        else:
+            ios = None
+    except struct.error:
+        raise ValueError("unknown nvram format")
+    if config_len > nvram_len:
+        raise ValueError("unknown nvram format")
+
+    # calculate max. config size
+    max_config = nvram_len - 2 * 1024  # reserve 2k for files
+    idx = max_config
+    empty_sector = bytearray([0] * 1024)
+    while True:
+        idx -= 1024
+        if idx < config_len:
+            break
+        # if valid file header:
+        (magic, _, flags, length, _) = struct.unpack_from(">HHHH24s", nvram, offset=idx)
+        if magic == 0xDCBA and flags < 8 and length <= 992:
+            max_config = idx
+        elif nvram[idx : idx + 1024] != empty_sector:
+            break
+
+    # import startup config
+    new_nvram = bytearray()
+    if ios is None:
+        # Target IOS version is unknown. As some IOU don't work nicely with
+        # the padding of a different version, the startup config is padded
+        # with '\n' to the alignment of 4.
+        ios = DEFAULT_IOS
+        startup += b"\n" * (-len(startup) % 4)
+    new_nvram.extend(
+        struct.pack(
+            ">HHHHIIIIIHHI",
+            0xABCD,  # magic
+            1,  # raw data
+            0,  # checksum, not yet calculated
+            ios,  # IOS version
+            base_address + 36,  # start address
+            base_address + 36 + len(startup),  # end address
+            len(startup),  # length
+            0,
+            0,
+            0,
+            0,
+            0,
+        )
+    )
+    new_nvram.extend(startup)
+    new_nvram.extend([0] * padding(len(new_nvram), base_address))
+
+    # import private config
+    if private is None:
+        private = b""
+    offset = len(new_nvram)
+    new_nvram.extend(
+        struct.pack(
+            ">HHIII",
+            0xFEDC,  # magic
+            1,  # raw data
+            base_address + offset + 16,  # start address
+            base_address + offset + 16 + len(private),  # end address
+            len(private),
+        )
+    )  # length
+    new_nvram.extend(private)
+
+    # add rest
+    if len(new_nvram) > max_config:
+        raise ValueError("NVRAM size too small")
+    new_nvram.extend([0] * (max_config - len(new_nvram)))
+    new_nvram.extend(nvram[max_config:])
+
+    checksum(new_nvram, 0, nvram_len)
+
+    return new_nvram
+
+
+if __name__ == "__main__":
+    # Main program
+    import argparse
+    import sys
+
+    def check_size(string):
+        try:
+            value = int(string)
+        except ValueError:
+            raise argparse.ArgumentTypeError("invalid int value: " + string)
+        if value < 8 or value > 1024:
+            raise argparse.ArgumentTypeError("size must be 8..1024")
+        return value
+
+    parser = argparse.ArgumentParser(description="%(prog)s imports startup/private configuration into IOU NVRAM file.")
+    parser.add_argument("-c", "--create", metavar="size", type=check_size, help="create NVRAM file, size in kByte")
+    parser.add_argument("nvram", metavar="NVRAM", help="NVRAM file")
+    parser.add_argument("startup", metavar="startup-config", help="startup configuration")
+    parser.add_argument("private", metavar="private-config", nargs="?", help="private configuration")
+    args = parser.parse_args()
+
+    try:
+        if args.create is None:
+            fd = open(args.nvram, "rb")
+            nvram = fd.read()
+            fd.close()
+        else:
+            nvram = None
+        fd = open(args.startup, "rb")
+        startup = fd.read()
+        fd.close()
+        if args.private is None:
+            private = None
+        else:
+            fd = open(args.private, "rb")
+            private = fd.read()
+            fd.close()
+    except OSError as err:
+        sys.stderr.write(f"Error reading file: {err}\n")
+        sys.exit(1)
+
+    try:
+        nvram = nvram_import(nvram, startup, private, args.create)
+    except ValueError as err:
+        sys.stderr.write(f"nvram_import: {err}\n")
+        sys.exit(3)
+
+    try:
+        fd = open(args.nvram, "wb")
+        fd.write(nvram)
+        fd.close()
+    except OSError as err:
+        sys.stderr.write(f"Error writing file: {err}\n")
+        sys.exit(1)

gns3server/compute/nios/nio.py

@@ -0,0 +1,120 @@
+#
+# Copyright (C) 2013 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/>.
+
+"""
+Base interface for NIOs.
+"""
+
+
+class NIO:
+
+    """
+    IOU NIO.
+    """
+
+    def __init__(self):
+
+        self._capturing = False
+        self._suspended = False
+        self._filters = {}
+        self._pcap_output_file = ""
+        self._pcap_data_link_type = ""
+
+    def start_packet_capture(self, pcap_output_file, pcap_data_link_type="DLT_EN10MB"):
+        """
+        :param pcap_output_file: PCAP destination file for the capture
+        :param pcap_data_link_type: PCAP data link type (DLT_*), default is DLT_EN10MB
+        """
+
+        self._capturing = True
+        self._pcap_output_file = pcap_output_file
+        self._pcap_data_link_type = pcap_data_link_type
+
+    def stop_packet_capture(self):
+
+        self._capturing = False
+        self._pcap_output_file = ""
+        self._pcap_data_link_type = ""
+
+    @property
+    def capturing(self):
+        """
+        Returns either a capture is configured on this NIO.
+        :returns: boolean
+        """
+
+        return self._capturing
+
+    @property
+    def pcap_output_file(self):
+        """
+        Returns the path to the PCAP output file.
+
+        :returns: path to the PCAP output file
+        """
+
+        return self._pcap_output_file
+
+    @property
+    def pcap_data_link_type(self):
+        """
+        Returns the PCAP data link type
+
+        :returns: PCAP data link type (DLT_* value)
+        """
+
+        return self._pcap_data_link_type
+
+    @property
+    def suspend(self):
+        """
+        Returns if this link is suspended or not.
+
+        :returns: boolean
+        """
+
+        return self._suspended
+
+    @suspend.setter
+    def suspend(self, suspended):
+        """
+        Suspend this link.
+
+        :param suspended: boolean
+        """
+
+        self._suspended = suspended
+
+    @property
+    def filters(self):
+        """
+        Returns the list of packet filters for this NIO.
+
+        :returns: packet filters (dictionary)
+        """
+
+        return self._filters
+
+    @filters.setter
+    def filters(self, new_filters):
+        """
+        Set a list of packet filters for this NIO.
+
+        :param new_filters: packet filters (dictionary)
+        """
+
+        assert isinstance(new_filters, dict)
+        self._filters = new_filters

gns3server/compute/nios/nio_ethernet.py

@@ -0,0 +1,56 @@
+#
+# Copyright (C) 2013 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/>.
+
+"""
+Interface for Ethernet NIOs.
+"""
+
+from .nio import NIO
+
+
+class NIOEthernet(NIO):
+
+    """
+    Generic Ethernet NIO.
+
+    :param ethernet_device: Ethernet device name (e.g. eth0)
+    """
+
+    def __init__(self, ethernet_device):
+
+        super().__init__()
+        self._ethernet_device = ethernet_device
+
+    @property
+    def ethernet_device(self):
+        """
+        Returns the Ethernet device used by this NIO.
+
+        :returns: the Ethernet device name
+        """
+
+        return self._ethernet_device
+
+    def __str__(self):
+
+        return "NIO Ethernet"
+
+    def asdict(self):
+
+        return {
+            "type": "nio_ethernet",
+            "ethernet_device": self._ethernet_device
+        }

gns3server/compute/nios/nio_tap.py

@@ -0,0 +1,56 @@
+#
+# Copyright (C) 2013 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/>.
+
+"""
+Interface for TAP NIOs (UNIX based OSes only).
+"""
+
+from .nio import NIO
+
+
+class NIOTAP(NIO):
+
+    """
+    TAP NIO.
+
+    :param tap_device: TAP device name (e.g. tap0)
+    """
+
+    def __init__(self, tap_device):
+
+        super().__init__()
+        self._tap_device = tap_device
+
+    @property
+    def tap_device(self):
+        """
+        Returns the TAP device used by this NIO.
+
+        :returns: the TAP device name
+        """
+
+        return self._tap_device
+
+    def __str__(self):
+
+        return "NIO TAP"
+
+    def asdict(self):
+
+        return {
+            "type": "nio_tap",
+            "tap_device": self._tap_device
+        }