Merge remote-tracking branch 'origin/dev' into feature/2317-refactor-reset

src/primaite/simulator/system/applications/database_client.py

@@ -23,6 +23,7 @@ class DatabaseClient(Application):
 
     server_ip_address: Optional[IPv4Address] = None
     server_password: Optional[str] = None
+    connected: bool = False
     _query_success_tracker: Dict[str, bool] = {}
 
     def __init__(self, **kwargs):
@@ -59,9 +60,10 @@ class DatabaseClient(Application):
         if not connection_id:
             connection_id = str(uuid4())
 
-        return self._connect(
+        self.connected = self._connect(
             server_ip_address=self.server_ip_address, password=self.server_password, connection_id=connection_id
         )
+        return self.connected
 
     def _connect(
         self,
@@ -133,6 +135,7 @@ class DatabaseClient(Application):
         self.sys_log.info(
             f"{self.name}: DatabaseClient disconnected connection {connection_id} from {self.server_ip_address}"
         )
+        self.connected = False
 
     def _query(self, sql: str, query_id: str, connection_id: str, is_reattempt: bool = False) -> bool:
         """

src/primaite/simulator/system/core/packet_capture.py

@@ -21,7 +21,7 @@ class PacketCapture:
     The PCAPs are logged to: <simulation output directory>/<hostname>/<hostname>_<ip address>_pcap.log
     """
 
-    def __init__(self, hostname: str, ip_address: Optional[str] = None, switch_port_number: Optional[int] = None):
+    def __init__(self, hostname: str, ip_address: Optional[str] = None, interface_num: Optional[int] = None):
         """
         Initialize the PacketCapture process.
 
@@ -32,19 +32,20 @@ class PacketCapture:
         "The hostname for which PCAP logs are being recorded."
         self.ip_address: str = ip_address
         "The IP address associated with the PCAP logs."
-        self.switch_port_number = switch_port_number
-        "The SwitchPort number."
+        self.interface_num = interface_num
+        "The interface num on the Node."
+
+        self.inbound_logger = None
+        self.outbound_logger = None
 
         self.current_episode: int = 1
 
-        self.setup_logger()
+        self.setup_logger(outbound=False)
+        self.setup_logger(outbound=True)
 
-    def setup_logger(self):
+    def setup_logger(self, outbound: bool = False):
         """Set up the logger configuration."""
-        if not SIM_OUTPUT.save_pcap_logs:
-            return
-
-        log_path = self._get_log_path()
+        log_path = self._get_log_path(outbound)
 
         file_handler = logging.FileHandler(filename=log_path)
         file_handler.setLevel(60)  # Custom log level > CRITICAL to prevent any unwanted standard DEBUG-CRITICAL logs
@@ -52,11 +53,17 @@ class PacketCapture:
         log_format = "%(message)s"
         file_handler.setFormatter(logging.Formatter(log_format))
 
-        self.logger = logging.getLogger(self._logger_name)
-        self.logger.setLevel(60)  # Custom log level > CRITICAL to prevent any unwanted standard DEBUG-CRITICAL logs
-        self.logger.addHandler(file_handler)
+        if outbound:
+            self.outbound_logger = logging.getLogger(self._get_logger_name(outbound))
+            logger = self.outbound_logger
+        else:
+            self.inbound_logger = logging.getLogger(self._get_logger_name(outbound))
+            logger = self.inbound_logger
 
-        self.logger.addFilter(_JSONFilter())
+        logger.setLevel(60)  # Custom log level > CRITICAL to prevent any unwanted standard DEBUG-CRITICAL logs
+        logger.addHandler(file_handler)
+
+        logger.addFilter(_JSONFilter())
 
     def read(self) -> List[Dict[str, Any]]:
         """
@@ -70,27 +77,34 @@ class PacketCapture:
                 frames.append(json.loads(line.rstrip()))
         return frames
 
-    @property
-    def _logger_name(self) -> str:
+    def _get_logger_name(self, outbound: bool = False) -> str:
         """Get PCAP the logger name."""
         if self.ip_address:
-            return f"{self.hostname}_{self.ip_address}_pcap"
-        if self.switch_port_number:
-            return f"{self.hostname}_port-{self.switch_port_number}_pcap"
-        return f"{self.hostname}_pcap"
+            return f"{self.hostname}_{self.ip_address}_{'outbound' if outbound else 'inbound'}_pcap"
+        if self.interface_num:
+            return f"{self.hostname}_port-{self.interface_num}_{'outbound' if outbound else 'inbound'}_pcap"
+        return f"{self.hostname}_{'outbound' if outbound else 'inbound'}_pcap"
 
-    def _get_log_path(self) -> Path:
+    def _get_log_path(self, outbound: bool = False) -> Path:
         """Get the path for the log file."""
         root = SIM_OUTPUT.path / f"episode_{self.current_episode}" / self.hostname
         root.mkdir(exist_ok=True, parents=True)
-        return root / f"{self._logger_name}.log"
+        return root / f"{self._get_logger_name(outbound)}.log"
 
-    def capture(self, frame):  # noqa - I'll have a circular import and cant use if TYPE_CHECKING ;(
+    def capture_inbound(self, frame):  # noqa - I'll have a circular import and cant use if TYPE_CHECKING ;(
         """
-        Capture a Frame and log it.
+        Capture an inbound Frame and log it.
 
         :param frame: The PCAP frame to capture.
         """
-        if SIM_OUTPUT.save_pcap_logs:
-            msg = frame.model_dump_json()
-            self.logger.log(level=60, msg=msg)  # Log at custom log level > CRITICAL
+        msg = frame.model_dump_json()
+        self.inbound_logger.log(level=60, msg=msg)  # Log at custom log level > CRITICAL
+
+    def capture_outbound(self, frame):  # noqa - I'll have a circular import and cant use if TYPE_CHECKING ;(
+        """
+        Capture an outbound Frame and log it.
+
+        :param frame: The PCAP frame to capture.
+        """
+        msg = frame.model_dump_json()
+        self.outbound_logger.log(level=60, msg=msg)  # Log at custom log level > CRITICAL

src/primaite/simulator/system/core/session_manager.py

@@ -6,12 +6,14 @@ from typing import Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
 from prettytable import MARKDOWN, PrettyTable
 
 from primaite.simulator.core import SimComponent
+from primaite.simulator.network.protocols.arp import ARPPacket
+from primaite.simulator.network.protocols.icmp import ICMPPacket
 from primaite.simulator.network.transmission.data_link_layer import EthernetHeader, Frame
 from primaite.simulator.network.transmission.network_layer import IPPacket, IPProtocol
-from primaite.simulator.network.transmission.transport_layer import Port, TCPHeader
+from primaite.simulator.network.transmission.transport_layer import Port, TCPHeader, UDPHeader
 
 if TYPE_CHECKING:
-    from primaite.simulator.network.hardware.base import ARPCache
+    from primaite.simulator.network.hardware.base import NetworkInterface
     from primaite.simulator.system.core.software_manager import SoftwareManager
     from primaite.simulator.system.core.sys_log import SysLog
 
@@ -73,14 +75,14 @@ class SessionManager:
     :param arp_cache: A reference to the ARP cache component.
     """
 
-    def __init__(self, sys_log: SysLog, arp_cache: "ARPCache"):
+    def __init__(self, sys_log: SysLog):
         self.sessions_by_key: Dict[
             Tuple[IPProtocol, IPv4Address, IPv4Address, Optional[Port], Optional[Port]], Session
         ] = {}
         self.sessions_by_uuid: Dict[str, Session] = {}
         self.sys_log: SysLog = sys_log
         self.software_manager: SoftwareManager = None  # Noqa
-        self.arp_cache: "ARPCache" = arp_cache
+        self.node: Node = None  # noqa
 
     def describe_state(self) -> Dict:
         """
@@ -138,13 +140,130 @@ class SessionManager:
             dst_port = None
         return protocol, with_ip_address, src_port, dst_port
 
+    def resolve_outbound_network_interface(self, dst_ip_address: IPv4Address) -> Optional["NetworkInterface"]:
+        """
+        Resolves the appropriate outbound network interface for a given destination IP address.
+
+        This method determines the most suitable network interface for sending a packet to the specified
+        destination IP address. It considers only enabled network interfaces and checks if the destination
+        IP address falls within the subnet of each interface. If no suitable local network interface is found,
+        the method defaults to using the network interface associated with the default gateway.
+
+        The search process prioritises local network interfaces based on the IP network to which they belong.
+        If the destination IP address does not match any local subnet, the method assumes that the destination
+        is outside the local network and hence, routes the packet through the default gateway's network interface.
+
+        :param dst_ip_address: The destination IP address for which the outbound interface is to be resolved.
+        :type dst_ip_address: IPv4Address
+        :return: The network interface through which the packet should be sent to reach the destination IP address,
+            or the default gateway's network interface if the destination is not within any local subnet.
+        :rtype: Optional["NetworkInterface"]
+        """
+        for network_interface in self.node.network_interfaces.values():
+            if dst_ip_address in network_interface.ip_network and network_interface.enabled:
+                return network_interface
+        return self.software_manager.arp.get_default_gateway_network_interface()
+
+    def resolve_outbound_transmission_details(
+        self,
+        dst_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
+        src_port: Optional[Port] = None,
+        dst_port: Optional[Port] = None,
+        protocol: Optional[IPProtocol] = None,
+        session_id: Optional[str] = None,
+    ) -> Tuple[
+        Optional["NetworkInterface"],
+        Optional[str],
+        IPv4Address,
+        Optional[Port],
+        Optional[Port],
+        Optional[IPProtocol],
+        bool,
+    ]:
+        """
+        Resolves the necessary details for outbound transmission based on the provided parameters.
+
+        This method determines whether the payload should be broadcast or unicast based on the destination IP address
+        and resolves the outbound network interface and destination MAC address accordingly.
+
+        The method first checks if `session_id` is provided and uses the session details if available. For broadcast
+        transmissions, it finds a suitable network interface and uses a broadcast MAC address. For unicast
+        transmissions, it attempts to resolve the destination MAC address using ARP and finds the appropriate
+        outbound network interface. If the destination IP address is outside the local network and no specific MAC
+        address is resolved, it uses the default gateway for the transmission.
+
+        :param dst_ip_address: The destination IP address or network. If an IPv4Network is provided, the method
+            treats the transmission as a broadcast to that network. Optional.
+        :type dst_ip_address: Optional[Union[IPv4Address, IPv4Network]]
+        :param src_port: The source port number for the transmission. Optional.
+        :type src_port: Optional[Port]
+        :param dst_port: The destination port number for the transmission. Optional.
+        :type dst_port: Optional[Port]
+        :param protocol: The IP protocol to be used for the transmission. Optional.
+        :type protocol: Optional[IPProtocol]
+        :param session_id: The session ID associated with the transmission. If provided, the session details override
+            other parameters. Optional.
+        :type session_id: Optional[str]
+        :return: A tuple containing the resolved outbound network interface, destination MAC address, destination IP
+            address, source port, destination port, protocol, and a boolean indicating whether the transmission is a
+            broadcast.
+        :rtype: Tuple[Optional["NetworkInterface"], Optional[str], IPv4Address, Optional[Port], Optional[Port],
+            Optional[IPProtocol], bool]
+        """
+        if dst_ip_address and not isinstance(dst_ip_address, (IPv4Address, IPv4Network)):
+            dst_ip_address = IPv4Address(dst_ip_address)
+        is_broadcast = False
+        outbound_network_interface = None
+        dst_mac_address = None
+
+        # Use session details if session_id is provided
+        if session_id:
+            session = self.sessions_by_uuid[session_id]
+
+            dst_ip_address = session.with_ip_address
+            protocol = session.protocol
+            src_port = session.src_port
+            dst_port = session.dst_port
+
+        # Determine if the payload is for broadcast or unicast
+
+        # Handle broadcast transmission
+        if isinstance(dst_ip_address, IPv4Network):
+            is_broadcast = True
+            dst_ip_address = dst_ip_address.broadcast_address
+            if dst_ip_address:
+                # Find a suitable NIC for the broadcast
+                for network_interface in self.node.network_interfaces.values():
+                    if dst_ip_address in network_interface.ip_network and network_interface.enabled:
+                        dst_mac_address = "ff:ff:ff:ff:ff:ff"
+                        outbound_network_interface = network_interface
+                        break
+        else:
+            # Resolve MAC address for unicast transmission
+            use_default_gateway = True
+            for network_interface in self.node.network_interfaces.values():
+                if dst_ip_address in network_interface.ip_network and network_interface.enabled:
+                    dst_mac_address = self.software_manager.arp.get_arp_cache_mac_address(dst_ip_address)
+                    break
+
+            if dst_mac_address:
+                use_default_gateway = False
+                outbound_network_interface = self.software_manager.arp.get_arp_cache_network_interface(dst_ip_address)
+
+            if use_default_gateway:
+                dst_mac_address = self.software_manager.arp.get_default_gateway_mac_address()
+                outbound_network_interface = self.software_manager.arp.get_default_gateway_network_interface()
+        return outbound_network_interface, dst_mac_address, dst_ip_address, src_port, dst_port, protocol, is_broadcast
+
     def receive_payload_from_software_manager(
         self,
         payload: Any,
         dst_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
+        src_port: Optional[Port] = None,
         dst_port: Optional[Port] = None,
         session_id: Optional[str] = None,
-        is_reattempt: bool = False,
+        ip_protocol: IPProtocol = IPProtocol.TCP,
+        icmp_packet: Optional[ICMPPacket] = None,
     ) -> Union[Any, None]:
         """
         Receive a payload from the SoftwareManager and send it to the appropriate NIC for transmission.
@@ -157,74 +276,82 @@ class SessionManager:
         :param dst_ip_address: The destination IP address or network for broadcast. Optional.
         :param dst_port: The destination port for the TCP packet. Optional.
         :param session_id: The Session ID from which the payload originates. Optional.
-        :param is_reattempt: Flag to indicate if this is a reattempt after an ARP request. Default is False.
         :return: The outcome of sending the frame, or None if sending was unsuccessful.
         """
-        is_broadcast = False
-        outbound_nic = None
-        dst_mac_address = None
-
-        # Use session details if session_id is provided
-        if session_id:
-            session = self.sessions_by_uuid[session_id]
-            dst_ip_address = session.with_ip_address
-            dst_port = session.dst_port
-
-        # Determine if the payload is for broadcast or unicast
-
-        # Handle broadcast transmission
-        if isinstance(dst_ip_address, IPv4Network):
-            is_broadcast = True
-            dst_ip_address = dst_ip_address.broadcast_address
-            if dst_ip_address:
-                # Find a suitable NIC for the broadcast
-                for nic in self.arp_cache.nics.values():
-                    if dst_ip_address in nic.ip_network and nic.enabled:
-                        dst_mac_address = "ff:ff:ff:ff:ff:ff"
-                        outbound_nic = nic
-        else:
-            # Resolve MAC address for unicast transmission
-            dst_mac_address = self.arp_cache.get_arp_cache_mac_address(dst_ip_address)
-
-            # Resolve outbound NIC for unicast transmission
-            if dst_mac_address:
-                outbound_nic = self.arp_cache.get_arp_cache_nic(dst_ip_address)
-
-            # If MAC address not found, initiate ARP request
+        if isinstance(payload, ARPPacket):
+            # ARP requests need to be handles differently
+            if payload.request:
+                dst_mac_address = "ff:ff:ff:ff:ff:ff"
             else:
-                if not is_reattempt:
-                    self.arp_cache.send_arp_request(dst_ip_address)
-                    # Reattempt payload transmission after ARP request
-                    return self.receive_payload_from_software_manager(
-                        payload=payload,
-                        dst_ip_address=dst_ip_address,
-                        dst_port=dst_port,
-                        session_id=session_id,
-                        is_reattempt=True,
-                    )
-                else:
-                    # Return None if reattempt fails
-                    return
+                dst_mac_address = payload.target_mac_addr
+            outbound_network_interface = self.resolve_outbound_network_interface(payload.target_ip_address)
+            is_broadcast = payload.request
+            ip_protocol = IPProtocol.UDP
+        else:
+            vals = self.resolve_outbound_transmission_details(
+                dst_ip_address=dst_ip_address,
+                src_port=src_port,
+                dst_port=dst_port,
+                protocol=ip_protocol,
+                session_id=session_id,
+            )
+            (
+                outbound_network_interface,
+                dst_mac_address,
+                dst_ip_address,
+                src_port,
+                dst_port,
+                protocol,
+                is_broadcast,
+            ) = vals
+            if protocol:
+                ip_protocol = protocol
 
         # Check if outbound NIC and destination MAC address are resolved
-        if not outbound_nic or not dst_mac_address:
+        if not outbound_network_interface or not dst_mac_address:
             return False
 
-        # Construct the frame for transmission
-        frame = Frame(
-            ethernet=EthernetHeader(src_mac_addr=outbound_nic.mac_address, dst_mac_addr=dst_mac_address),
-            ip=IPPacket(
-                src_ip_address=outbound_nic.ip_address,
-                dst_ip_address=dst_ip_address,
-            ),
-            tcp=TCPHeader(
+        if not (src_port or dst_port):
+            raise ValueError(
+                "Failed to resolve src or dst port. Have you sent the port from the service or application?"
+            )
+
+        tcp_header = None
+        udp_header = None
+        if ip_protocol == IPProtocol.TCP:
+            tcp_header = TCPHeader(
                 src_port=dst_port,
                 dst_port=dst_port,
+            )
+        elif ip_protocol == IPProtocol.UDP:
+            udp_header = UDPHeader(
+                src_port=dst_port,
+                dst_port=dst_port,
+            )
+        # TODO: Only create IP packet if not ARP
+        # ip_packet = None
+        # if dst_port != Port.ARP:
+        #     IPPacket(
+        #         src_ip_address=outbound_network_interface.ip_address,
+        #         dst_ip_address=dst_ip_address,
+        #         protocol=ip_protocol
+        #     )
+        # Construct the frame for transmission
+        frame = Frame(
+            ethernet=EthernetHeader(src_mac_addr=outbound_network_interface.mac_address, dst_mac_addr=dst_mac_address),
+            ip=IPPacket(
+                src_ip_address=outbound_network_interface.ip_address,
+                dst_ip_address=dst_ip_address,
+                protocol=ip_protocol,
             ),
+            tcp=tcp_header,
+            udp=udp_header,
+            icmp=icmp_packet,
             payload=payload,
         )
 
         # Manage session for unicast transmission
+        # TODO: Only create sessions for TCP
         if not (is_broadcast and session_id):
             session_key = self._get_session_key(frame, inbound_frame=False)
             session = self.sessions_by_key.get(session_key)
@@ -235,9 +362,9 @@ class SessionManager:
                 self.sessions_by_uuid[session.uuid] = session
 
         # Send the frame through the NIC
-        return outbound_nic.send_frame(frame)
+        return outbound_network_interface.send_frame(frame)
 
-    def receive_frame(self, frame: Frame):
+    def receive_frame(self, frame: Frame, from_network_interface: "NetworkInterface"):
         """
         Receive a Frame.
 
@@ -246,6 +373,7 @@ class SessionManager:
 
         :param frame: The frame being received.
         """
+        # TODO: Only create sessions for TCP
         session_key = self._get_session_key(frame, inbound_frame=True)
         session: Session = self.sessions_by_key.get(session_key)
         if not session:
@@ -253,8 +381,20 @@ class SessionManager:
             session = Session.from_session_key(session_key)
             self.sessions_by_key[session_key] = session
             self.sessions_by_uuid[session.uuid] = session
+        dst_port = None
+        if frame.tcp:
+            dst_port = frame.tcp.dst_port
+        elif frame.udp:
+            dst_port = frame.udp.dst_port
+        elif frame.icmp:
+            dst_port = Port.NONE
         self.software_manager.receive_payload_from_session_manager(
-            payload=frame.payload, port=frame.tcp.dst_port, protocol=frame.ip.protocol, session_id=session.uuid
+            payload=frame.payload,
+            port=dst_port,
+            protocol=frame.ip.protocol,
+            session_id=session.uuid,
+            from_network_interface=from_network_interface,
+            frame=frame,
         )
 
     def show(self, markdown: bool = False):

src/primaite/simulator/system/core/software_manager.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 from prettytable import MARKDOWN, PrettyTable
 
 from primaite.simulator.file_system.file_system import FileSystem
+from primaite.simulator.network.transmission.data_link_layer import Frame
 from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.applications.application import Application, ApplicationOperatingState
@@ -14,7 +15,9 @@ from primaite.simulator.system.software import IOSoftware
 if TYPE_CHECKING:
     from primaite.simulator.system.core.session_manager import SessionManager
     from primaite.simulator.system.core.sys_log import SysLog
-    from primaite.simulator.network.hardware.base import Node
+    from primaite.simulator.network.hardware.base import Node, NIC
+    from primaite.simulator.system.services.arp.arp import ARP
+    from primaite.simulator.system.services.icmp.icmp import ICMP
 
 from typing import Type, TypeVar
 
@@ -22,7 +25,14 @@ IOSoftwareClass = TypeVar("IOSoftwareClass", bound=IOSoftware)
 
 
 class SoftwareManager:
-    """A class that manages all running Services and Applications on a Node and facilitates their communication."""
+    """
+    Manages all running services and applications on a network node and facilitates their communication.
+
+    This class is responsible for installing, uninstalling, and managing the operational state of various network
+    services and applications. It acts as a bridge between the node's session manager and its software components,
+    ensuring that incoming and outgoing network payloads are correctly routed to and from the appropriate services
+    or applications.
+    """
 
     def __init__(
         self,
@@ -46,17 +56,26 @@ class SoftwareManager:
         self.file_system: FileSystem = file_system
         self.dns_server: Optional[IPv4Address] = dns_server
 
+    @property
+    def arp(self) -> "ARP":
+        """Provides access to the ARP service instance, if installed."""
+        return self.software.get("ARP")  # noqa
+
+    @property
+    def icmp(self) -> "ICMP":
+        """Provides access to the ICMP service instance, if installed."""
+        return self.software.get("ICMP")  # noqa
+
     def get_open_ports(self) -> List[Port]:
         """
         Get a list of open ports.
 
         :return: A list of all open ports on the Node.
         """
-        open_ports = [Port.ARP]
+        open_ports = []
         for software in self.port_protocol_mapping.values():
             if software.operating_state in {ApplicationOperatingState.RUNNING, ServiceOperatingState.RUNNING}:
                 open_ports.append(software.port)
-        open_ports.sort(key=lambda port: port.value)
         return open_ports
 
     def install(self, software_class: Type[IOSoftwareClass]):
@@ -132,6 +151,7 @@ class SoftwareManager:
         payload: Any,
         dest_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
         dest_port: Optional[Port] = None,
+        ip_protocol: IPProtocol = IPProtocol.TCP,
         session_id: Optional[str] = None,
     ) -> bool:
         """
@@ -151,10 +171,19 @@ class SoftwareManager:
             payload=payload,
             dst_ip_address=dest_ip_address,
             dst_port=dest_port,
+            ip_protocol=ip_protocol,
             session_id=session_id,
         )
 
-    def receive_payload_from_session_manager(self, payload: Any, port: Port, protocol: IPProtocol, session_id: str):
+    def receive_payload_from_session_manager(
+        self,
+        payload: Any,
+        port: Port,
+        protocol: IPProtocol,
+        session_id: str,
+        from_network_interface: "NIC",
+        frame: Frame,
+    ):
         """
         Receive a payload from the SessionManager and forward it to the corresponding service or application.
 
@@ -163,7 +192,9 @@ class SoftwareManager:
         """
         receiver: Optional[Union[Service, Application]] = self.port_protocol_mapping.get((port, protocol), None)
         if receiver:
-            receiver.receive(payload=payload, session_id=session_id)
+            receiver.receive(
+                payload=payload, session_id=session_id, from_network_interface=from_network_interface, frame=frame
+            )
         else:
             self.sys_log.error(f"No service or application found for port {port} and protocol {protocol}")
         pass
@@ -174,7 +205,7 @@ class SoftwareManager:
 
         :param markdown: If True, outputs the table in markdown format. Default is False.
         """
-        table = PrettyTable(["Name", "Type", "Operating State", "Health State", "Port"])
+        table = PrettyTable(["Name", "Type", "Operating State", "Health State", "Port", "Protocol"])
         if markdown:
             table.set_style(MARKDOWN)
         table.align = "l"
@@ -187,7 +218,8 @@ class SoftwareManager:
                     software_type,
                     software.operating_state.name,
                     software.health_state_actual.name,
-                    software.port.value,
+                    software.port.value if software.port != Port.NONE else None,
+                    software.protocol.value,
                 ]
             )
         print(table)

src/primaite/simulator/system/core/sys_log.py

@@ -88,47 +88,62 @@ class SysLog:
         root.mkdir(exist_ok=True, parents=True)
         return root / f"{self.hostname}_sys.log"
 
-    def debug(self, msg: str):
+    def debug(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the DEBUG level.
 
         :param msg: The message to be logged.
+        :param to_terminal: If True, prints to the terminal too.
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.debug(msg)
+        if to_terminal:
+            print(msg)
 
-    def info(self, msg: str):
+    def info(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the INFO level.
 
         :param msg: The message to be logged.
+        :param to_terminal: If True, prints to the terminal too.
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.info(msg)
+        if to_terminal:
+            print(msg)
 
-    def warning(self, msg: str):
+    def warning(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the WARNING level.
 
         :param msg: The message to be logged.
+        :param to_terminal: If True, prints to the terminal too.
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.warning(msg)
+        if to_terminal:
+            print(msg)
 
-    def error(self, msg: str):
+    def error(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the ERROR level.
 
         :param msg: The message to be logged.
+        :param to_terminal: If True, prints to the terminal too.
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.error(msg)
+        if to_terminal:
+            print(msg)
 
-    def critical(self, msg: str):
+    def critical(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the CRITICAL level.
 
         :param msg: The message to be logged.
+        :param to_terminal: If True, prints to the terminal too.
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.critical(msg)
+        if to_terminal:
+            print(msg)

src/primaite/simulator/system/services/arp/arp.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Any, Dict, Optional, Union
+
+from prettytable import MARKDOWN, PrettyTable
+
+from primaite.simulator.network.hardware.base import NetworkInterface
+from primaite.simulator.network.protocols.arp import ARPEntry, ARPPacket
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.services.service import Service
+from primaite.utils.validators import IPV4Address
+
+
+class ARP(Service):
+    """
+    The ARP (Address Resolution Protocol) Service.
+
+    Manages ARP for resolving network layer addresses into link layer addresses. It maintains an ARP cache,
+    sends ARP requests and replies, and processes incoming ARP packets.
+    """
+
+    arp: Dict[IPV4Address, ARPEntry] = {}
+
+    def __init__(self, **kwargs):
+        kwargs["name"] = "ARP"
+        kwargs["port"] = Port.ARP
+        kwargs["protocol"] = IPProtocol.UDP
+        super().__init__(**kwargs)
+
+    def describe_state(self) -> Dict:
+        """
+        Produce a dictionary describing the current state of this object.
+
+        :return: Current state of this object and child objects.
+        """
+        state = super().describe_state()
+        state.update({str(ip): arp_entry.mac_address for ip, arp_entry in self.arp.items()})
+
+        return super().describe_state()
+
+    def show(self, markdown: bool = False):
+        """
+        Prints the current state of the ARP cache in a table format.
+
+        :param markdown: If True, format the output as Markdown. Otherwise, use plain text.
+        """
+        table = PrettyTable(["IP Address", "MAC Address", "Via"])
+        if markdown:
+            table.set_style(MARKDOWN)
+        table.align = "l"
+        table.title = f"{self.sys_log.hostname} ARP Cache"
+        for ip, arp in self.arp.items():
+            table.add_row(
+                [
+                    str(ip),
+                    arp.mac_address,
+                    self.software_manager.node.network_interfaces[arp.network_interface_uuid].mac_address,
+                ]
+            )
+        print(table)
+
+    def clear(self):
+        """Clears the arp cache."""
+        self.arp.clear()
+
+    def add_arp_cache_entry(
+        self, ip_address: IPV4Address, mac_address: str, network_interface: NetworkInterface, override: bool = False
+    ):
+        """
+        Add an ARP entry to the cache.
+
+        If an entry for the given IP address already exists, the entry is only updated if the `override` parameter is
+        set to True.
+
+        :param ip_address: The IP address to be added to the cache.
+        :param mac_address: The MAC address associated with the IP address.
+        :param network_interface: The NIC through which the NIC with the IP address is reachable.
+        :param override: If True, an existing entry for the IP address will be overridden. Default is False.
+        """
+        for _network_interface in self.software_manager.node.network_interfaces.values():
+            if _network_interface.ip_address == ip_address:
+                return
+        if override or not self.arp.get(ip_address):
+            self.sys_log.info(f"Adding ARP cache entry for {mac_address}/{ip_address} via NIC {network_interface}")
+            arp_entry = ARPEntry(mac_address=mac_address, network_interface_uuid=network_interface.uuid)
+
+            self.arp[ip_address] = arp_entry
+
+    @abstractmethod
+    def get_arp_cache_mac_address(self, ip_address: IPV4Address) -> Optional[str]:
+        """
+        Retrieves the MAC address associated with a given IP address from the ARP cache.
+
+        :param ip_address: The IP address to look up.
+        :return: The associated MAC address, if found. Otherwise, returns None.
+        """
+        pass
+
+    @abstractmethod
+    def get_arp_cache_network_interface(self, ip_address: IPV4Address) -> Optional[NetworkInterface]:
+        """
+        Retrieves the NIC associated with a given IP address from the ARP cache.
+
+        :param ip_address: The IP address to look up.
+        :return: The associated NIC, if found. Otherwise, returns None.
+        """
+        pass
+
+    def send_arp_request(self, target_ip_address: Union[IPV4Address, str]):
+        """
+        Sends an ARP request to resolve the MAC address of a target IP address.
+
+        :param target_ip_address: The target IP address for which the MAC address is being requested.
+        """
+        if target_ip_address in self.arp:
+            return
+
+        use_default_gateway = True
+        for network_interface in self.software_manager.node.network_interfaces.values():
+            if target_ip_address in network_interface.ip_network:
+                use_default_gateway = False
+                break
+
+        if use_default_gateway:
+            if self.software_manager.node.default_gateway:
+                target_ip_address = self.software_manager.node.default_gateway
+            else:
+                return
+
+        outbound_network_interface = self.software_manager.session_manager.resolve_outbound_network_interface(
+            target_ip_address
+        )
+        if outbound_network_interface:
+            self.sys_log.info(f"Sending ARP request from NIC {outbound_network_interface} for ip {target_ip_address}")
+            arp_packet = ARPPacket(
+                sender_ip_address=outbound_network_interface.ip_address,
+                sender_mac_addr=outbound_network_interface.mac_address,
+                target_ip_address=target_ip_address,
+            )
+            self.software_manager.session_manager.receive_payload_from_software_manager(
+                payload=arp_packet, dst_ip_address=target_ip_address, dst_port=self.port, ip_protocol=self.protocol
+            )
+        else:
+            self.sys_log.error(
+                "Cannot send ARP request as there is no outbound Network Interface to use. Try configuring the default "
+                "gateway."
+            )
+
+    def send_arp_reply(self, arp_reply: ARPPacket):
+        """
+        Sends an ARP reply in response to an ARP request.
+
+        :param arp_reply: The ARP packet containing the reply.
+        """
+        outbound_network_interface = self.software_manager.session_manager.resolve_outbound_network_interface(
+            arp_reply.target_ip_address
+        )
+        if outbound_network_interface:
+            self.sys_log.info(
+                f"Sending ARP reply from {arp_reply.sender_mac_addr}/{arp_reply.sender_ip_address} "
+                f"to {arp_reply.target_ip_address}/{arp_reply.target_mac_addr} "
+            )
+            self.software_manager.session_manager.receive_payload_from_software_manager(
+                payload=arp_reply,
+                dst_ip_address=arp_reply.target_ip_address,
+                dst_port=self.port,
+                ip_protocol=self.protocol,
+            )
+        else:
+            self.sys_log.error(
+                "Cannot send ARP reply as there is no outbound Network Interface to use. Try configuring the default "
+                "gateway."
+            )
+
+    @abstractmethod
+    def _process_arp_request(self, arp_packet: ARPPacket, from_network_interface: NetworkInterface):
+        """
+        Processes an incoming ARP request.
+
+        :param arp_packet: The ARP packet containing the request.
+        :param from_network_interface: The NIC that received the ARP request.
+        """
+        self.sys_log.info(
+            f"Received ARP request for {arp_packet.target_ip_address} from "
+            f"{arp_packet.sender_mac_addr}/{arp_packet.sender_ip_address} "
+        )
+
+    def _process_arp_reply(self, arp_packet: ARPPacket, from_network_interface: NetworkInterface):
+        """
+        Processes an incoming ARP reply.
+
+        :param arp_packet: The ARP packet containing the reply.
+        :param from_network_interface: The NIC that received the ARP reply.
+        """
+        self.sys_log.info(
+            f"Received ARP response for {arp_packet.sender_ip_address} "
+            f"from {arp_packet.sender_mac_addr} via Network Interface {from_network_interface}"
+        )
+        self.add_arp_cache_entry(
+            ip_address=arp_packet.sender_ip_address,
+            mac_address=arp_packet.sender_mac_addr,
+            network_interface=from_network_interface,
+        )
+
+    def receive(self, payload: Any, session_id: str, **kwargs) -> bool:
+        """
+        Processes received data, handling ARP packets.
+
+        :param payload: The payload received.
+        :param session_id: The session ID associated with the received data.
+        :param kwargs: Additional keyword arguments.
+        :return: True if the payload was processed successfully, otherwise False.
+        """
+        if not super().receive(payload, session_id, **kwargs):
+            return False
+
+        from_network_interface = kwargs["from_network_interface"]
+        if payload.request:
+            self._process_arp_request(arp_packet=payload, from_network_interface=from_network_interface)
+        else:
+            self._process_arp_reply(arp_packet=payload, from_network_interface=from_network_interface)
+        return True
+
+    def __contains__(self, item: Any) -> bool:
+        """
+        Checks if an item is in the ARP cache.
+
+        :param item: The item to check.
+        :return: True if the item is in the cache, otherwise False.
+        """
+        return item in self.arp

src/primaite/simulator/system/services/database/database_service.py

@@ -170,7 +170,7 @@ class DatabaseService(Service):
         }
 
     def _process_sql(
-        self, query: Literal["SELECT", "DELETE"], query_id: str, connection_id: Optional[str] = None
+        self, query: Literal["SELECT", "DELETE", "INSERT"], query_id: str, connection_id: Optional[str] = None
     ) -> Dict[str, Union[int, List[Any]]]:
         """
         Executes the given SQL query and returns the result.
@@ -178,6 +178,7 @@ class DatabaseService(Service):
         Possible queries:
         - SELECT : returns the data
         - DELETE : deletes the data
+        - INSERT : inserts the data
 
         :param query: The SQL query to be executed.
         :return: Dictionary containing status code and data fetched.
@@ -201,9 +202,27 @@ class DatabaseService(Service):
                 return {"status_code": 404, "data": False}
         elif query == "DELETE":
             self.db_file.health_status = FileSystemItemHealthStatus.COMPROMISED
-            return {"status_code": 200, "type": "sql", "data": False, "uuid": query_id, "connection_id": connection_id}
+            return {
+                "status_code": 200,
+                "type": "sql",
+                "data": False,
+                "uuid": query_id,
+                "connection_id": connection_id,
+            }
+        elif query == "INSERT":
+            if self.health_state_actual == SoftwareHealthState.GOOD:
+                return {
+                    "status_code": 200,
+                    "type": "sql",
+                    "data": False,
+                    "uuid": query_id,
+                    "connection_id": connection_id,
+                }
+            else:
+                return {"status_code": 404, "data": False}
         else:
             # Invalid query
+            self.sys_log.info(f"{self.name}: Invalid {query}")
             return {"status_code": 500, "data": False}
 
     def describe_state(self) -> Dict:

src/primaite/simulator/system/services/icmp/icmp.py

@@ -0,0 +1,194 @@
+import secrets
+from ipaddress import IPv4Address
+from typing import Any, Dict, Optional, Tuple, Union
+
+from primaite import getLogger
+from primaite.simulator.network.hardware.base import NetworkInterface
+from primaite.simulator.network.protocols.icmp import ICMPPacket, ICMPType
+from primaite.simulator.network.transmission.data_link_layer import Frame
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.services.service import Service
+
+_LOGGER = getLogger(__name__)
+
+
+class ICMP(Service):
+    """
+    The Internet Control Message Protocol (ICMP) service.
+
+    Enables the sending and receiving of ICMP messages such as echo requests and replies. This is typically used for
+    network diagnostics, notably the ping command.
+    """
+
+    request_replies: Dict = {}
+
+    def __init__(self, **kwargs):
+        kwargs["name"] = "ICMP"
+        kwargs["port"] = Port.NONE
+        kwargs["protocol"] = IPProtocol.ICMP
+        super().__init__(**kwargs)
+
+    def describe_state(self) -> Dict:
+        """
+        Produce a dictionary describing the current state of this object.
+
+        :return: Current state of this object and child objects.
+        """
+        return super().describe_state()
+
+    def clear(self):
+        """
+        Clears the ICMP request and reply tracker.
+
+        This is typically used to reset the state of the service, removing all tracked ICMP echo requests and their
+        corresponding replies.
+        """
+        self.request_replies.clear()
+
+    def ping(self, target_ip_address: Union[IPv4Address, str], pings: int = 4) -> bool:
+        """
+        Pings a target IP address by sending an ICMP echo request and waiting for a reply.
+
+        :param target_ip_address: The IP address to be pinged.
+        :param pings: The number of echo requests to send. Defaults to 4.
+        :return: True if the ping was successful (i.e., if a reply was received for every request sent), otherwise
+            False.
+        """
+        if not self._can_perform_action():
+            return False
+        if target_ip_address.is_loopback:
+            self.sys_log.info("Pinging loopback address")
+            return any(network_interface.enabled for network_interface in self.network_interfaces.values())
+        self.sys_log.info(f"Pinging {target_ip_address}:", to_terminal=True)
+        sequence, identifier = 0, None
+        while sequence < pings:
+            sequence, identifier = self._send_icmp_echo_request(target_ip_address, sequence, identifier, pings)
+        request_replies = self.software_manager.icmp.request_replies.get(identifier)
+        passed = request_replies == pings
+        if request_replies:
+            self.software_manager.icmp.request_replies.pop(identifier)
+        else:
+            request_replies = 0
+        output = (
+            f"Ping statistics for {target_ip_address}: "
+            f"Packets: Sent = {pings}, "
+            f"Received = {request_replies}, "
+            f"Lost = {pings - request_replies} ({(pings - request_replies) / pings * 100}% loss)"
+        )
+        self.sys_log.info(output, to_terminal=True)
+
+        return passed
+
+    def _send_icmp_echo_request(
+        self, target_ip_address: IPv4Address, sequence: int = 0, identifier: Optional[int] = None, pings: int = 4
+    ) -> Tuple[int, Union[int, None]]:
+        """
+        Sends an ICMP echo request to a specified target IP address.
+
+        :param target_ip_address: The target IP address for the echo request.
+        :param sequence: The sequence number of the echo request.
+        :param identifier: The identifier for the ICMP packet. If None, a default identifier is used.
+        :param pings: The number of pings to send. Defaults to 4.
+        :return: A tuple containing the next sequence number and the identifier.
+        """
+        network_interface = self.software_manager.session_manager.resolve_outbound_network_interface(target_ip_address)
+
+        if not network_interface:
+            self.sys_log.error(
+                "Cannot send ICMP echo request as there is no outbound Network Interface to use. Try configuring the "
+                "default gateway."
+            )
+            return pings, None
+
+        sequence += 1
+
+        icmp_packet = ICMPPacket(identifier=identifier, sequence=sequence)
+        payload = secrets.token_urlsafe(int(32 / 1.3))  # Standard ICMP 32 bytes size
+
+        self.software_manager.session_manager.receive_payload_from_software_manager(
+            payload=payload,
+            dst_ip_address=target_ip_address,
+            dst_port=self.port,
+            ip_protocol=self.protocol,
+            icmp_packet=icmp_packet,
+        )
+        return sequence, icmp_packet.identifier
+
+    def _process_icmp_echo_request(self, frame: Frame, from_network_interface: NetworkInterface):
+        """
+        Processes an ICMP echo request received by the service.
+
+        :param frame: The network frame containing the ICMP echo request.
+        """
+        if frame.ip.dst_ip_address != from_network_interface.ip_address:
+            return
+        self.sys_log.info(f"Received echo request from {frame.ip.src_ip_address}")
+
+        network_interface = self.software_manager.session_manager.resolve_outbound_network_interface(
+            frame.ip.src_ip_address
+        )
+
+        if not network_interface:
+            self.sys_log.error(
+                "Cannot send ICMP echo reply as there is no outbound Network Interface to use. Try configuring the "
+                "default gateway."
+            )
+            return
+
+        icmp_packet = ICMPPacket(
+            icmp_type=ICMPType.ECHO_REPLY,
+            icmp_code=0,
+            identifier=frame.icmp.identifier,
+            sequence=frame.icmp.sequence + 1,
+        )
+        payload = secrets.token_urlsafe(int(32 / 1.3))  # Standard ICMP 32 bytes size
+        self.sys_log.info(f"Sending echo reply to {frame.ip.dst_ip_address}")
+
+        self.software_manager.session_manager.receive_payload_from_software_manager(
+            payload=payload,
+            dst_ip_address=frame.ip.src_ip_address,
+            dst_port=self.port,
+            ip_protocol=self.protocol,
+            icmp_packet=icmp_packet,
+        )
+
+    def _process_icmp_echo_reply(self, frame: Frame):
+        """
+        Processes an ICMP echo reply received by the service, logging the reply details.
+
+        :param frame: The network frame containing the ICMP echo reply.
+        """
+        time = frame.transmission_duration()
+        time_str = f"{time}ms" if time > 0 else "<1ms"
+        self.sys_log.info(
+            f"Reply from {frame.ip.src_ip_address}: "
+            f"bytes={len(frame.payload)}, "
+            f"time={time_str}, "
+            f"TTL={frame.ip.ttl}",
+            to_terminal=True,
+        )
+        if not self.request_replies.get(frame.icmp.identifier):
+            self.request_replies[frame.icmp.identifier] = 0
+        self.request_replies[frame.icmp.identifier] += 1
+
+    def receive(self, payload: Any, session_id: str, **kwargs) -> bool:
+        """
+        Processes received data, handling ICMP echo requests and replies.
+
+        :param payload: The payload received.
+        :param session_id: The session ID associated with the received data.
+        :param kwargs: Additional keyword arguments.
+        :return: True if the payload was processed successfully, otherwise False.
+        """
+        frame: Frame = kwargs["frame"]
+        from_network_interface = kwargs["from_network_interface"]
+
+        if not frame.icmp:
+            return False
+
+        if frame.icmp.icmp_type == ICMPType.ECHO_REQUEST:
+            self._process_icmp_echo_request(frame, from_network_interface)
+        elif frame.icmp.icmp_type == ICMPType.ECHO_REPLY:
+            self._process_icmp_echo_reply(frame)
+        return True

src/primaite/simulator/system/services/icmp/router_icmp.py

@@ -0,0 +1,90 @@
+# class RouterICMP(ICMP):
+#     """
+#     A class to represent a router's Internet Control Message Protocol (ICMP) handler.
+#
+#     :param sys_log: System log for logging network events and errors.
+#     :type sys_log: SysLog
+#     :param arp_cache: The ARP cache for resolving MAC addresses.
+#     :type arp_cache: ARPCache
+#     :param router: The router to which this ICMP handler belongs.
+#     :type router: Router
+#     """
+#
+#     router: Router
+#
+#     def __init__(self, sys_log: SysLog, arp_cache: ARPCache, router: Router):
+#         super().__init__(sys_log, arp_cache)
+#         self.router = router
+#
+#     def process_icmp(self, frame: Frame, from_network_interface: NIC, is_reattempt: bool = False):
+#         """
+#         Process incoming ICMP frames based on ICMP type.
+#
+#         :param frame: The incoming frame to process.
+#         :param from_network_interface: The network interface where the frame is coming from.
+#         :param is_reattempt: Flag to indicate if the process is a reattempt.
+#         """
+#         if frame.icmp.icmp_type == ICMPType.ECHO_REQUEST:
+#             # determine if request is for router interface or whether it needs to be routed
+#
+#             for network_interface in self.router.network_interfaces.values():
+#                 if network_interface.ip_address == frame.ip.dst_ip_address:
+#                     if network_interface.enabled:
+#                         # reply to the request
+#                         if not is_reattempt:
+#                             self.sys_log.info(f"Received echo request from {frame.ip.src_ip_address}")
+#                         target_mac_address = self.arp.get_arp_cache_mac_address(frame.ip.src_ip_address)
+#                         src_nic = self.arp.get_arp_cache_network_interface(frame.ip.src_ip_address)
+#                         tcp_header = TCPHeader(src_port=Port.ARP, dst_port=Port.ARP)
+#
+#                         # Network Layer
+#                         ip_packet = IPPacket(
+#                             src_ip_address=network_interface.ip_address,
+#                             dst_ip_address=frame.ip.src_ip_address,
+#                             protocol=IPProtocol.ICMP,
+#                         )
+#                         # Data Link Layer
+#                         ethernet_header = EthernetHeader(
+#                             src_mac_addr=src_nic.mac_address, dst_mac_addr=target_mac_address
+#                         )
+#                         icmp_reply_packet = ICMPPacket(
+#                             icmp_type=ICMPType.ECHO_REPLY,
+#                             icmp_code=0,
+#                             identifier=frame.icmp.identifier,
+#                             sequence=frame.icmp.sequence + 1,
+#                         )
+#                         payload = secrets.token_urlsafe(int(32 / 1.3))  # Standard ICMP 32 bytes size
+#                         frame = Frame(
+#                             ethernet=ethernet_header,
+#                             ip=ip_packet,
+#                             tcp=tcp_header,
+#                             icmp=icmp_reply_packet,
+#                             payload=payload,
+#                         )
+#                         self.sys_log.info(f"Sending echo reply to {frame.ip.dst_ip_address}")
+#
+#                         src_nic.send_frame(frame)
+#                     return
+#
+#             # Route the frame
+#             self.router.process_frame(frame, from_network_interface)
+#
+#         elif frame.icmp.icmp_type == ICMPType.ECHO_REPLY:
+#             for network_interface in self.router.network_interfaces.values():
+#                 if network_interface.ip_address == frame.ip.dst_ip_address:
+#                     if network_interface.enabled:
+#                         time = frame.transmission_duration()
+#                         time_str = f"{time}ms" if time > 0 else "<1ms"
+#                         self.sys_log.info(
+#                             f"Reply from {frame.ip.src_ip_address}: "
+#                             f"bytes={len(frame.payload)}, "
+#                             f"time={time_str}, "
+#                             f"TTL={frame.ip.ttl}"
+#                         )
+#                         if not self.request_replies.get(frame.icmp.identifier):
+#                             self.request_replies[frame.icmp.identifier] = 0
+#                         self.request_replies[frame.icmp.identifier] += 1
+#
+#                     return
+#             # Route the frame
+#             self.router.process_frame(frame, from_network_interface)

src/primaite/simulator/system/services/ntp/ntp_client.py

@@ -21,7 +21,7 @@ class NTPClient(Service):
     def __init__(self, **kwargs):
         kwargs["name"] = "NTPClient"
         kwargs["port"] = Port.NTP
-        kwargs["protocol"] = IPProtocol.TCP
+        kwargs["protocol"] = IPProtocol.UDP
         super().__init__(**kwargs)
         self.start()
 
@@ -99,9 +99,14 @@ class NTPClient(Service):
 
     def request_time(self) -> None:
         """Send request to ntp_server."""
-        ntp_server_packet = NTPPacket()
-
-        self.send(payload=ntp_server_packet, dest_ip_address=self.ntp_server)
+        if self.ntp_server:
+            self.software_manager.session_manager.receive_payload_from_software_manager(
+                payload=NTPPacket(),
+                dst_ip_address=self.ntp_server,
+                src_port=self.port,
+                dst_port=self.port,
+                ip_protocol=self.protocol,
+            )
 
     def apply_timestep(self, timestep: int) -> None:
         """

src/primaite/simulator/system/services/ntp/ntp_server.py

@@ -16,7 +16,7 @@ class NTPServer(Service):
     def __init__(self, **kwargs):
         kwargs["name"] = "NTPServer"
         kwargs["port"] = Port.NTP
-        kwargs["protocol"] = IPProtocol.TCP
+        kwargs["protocol"] = IPProtocol.UDP
         super().__init__(**kwargs)
         self.start()
 
@@ -59,5 +59,7 @@ class NTPServer(Service):
         time = datetime.now()
         payload = payload.generate_reply(time)
         # send reply
-        self.send(payload, session_id)
+        self.software_manager.session_manager.receive_payload_from_software_manager(
+            payload=payload, src_port=self.port, dst_port=self.port, ip_protocol=self.protocol, session_id=session_id
+        )
         return True

src/primaite/simulator/system/software.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Optional, Union
 from primaite.simulator.core import _LOGGER, RequestManager, RequestType, SimComponent
 from primaite.simulator.file_system.file_system import FileSystem, Folder
 from primaite.simulator.network.hardware.node_operating_state import NodeOperatingState
+from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 from primaite.simulator.system.core.session_manager import Session
 from primaite.simulator.system.core.sys_log import SysLog
@@ -229,6 +230,8 @@ class IOSoftware(Software):
     "Indicates if the software uses UDP protocol for communication. Default is True."
     port: Port
     "The port to which the software is connected."
+    protocol: IPProtocol
+    "The IP Protocol the Software operates on."
     _connections: Dict[str, Dict] = {}
     "Active connections."
 
@@ -334,6 +337,7 @@ class IOSoftware(Software):
         session_id: Optional[str] = None,
         dest_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
         dest_port: Optional[Port] = None,
+        ip_protocol: IPProtocol = IPProtocol.TCP,
         **kwargs,
     ) -> bool:
         """
@@ -353,7 +357,11 @@ class IOSoftware(Software):
             return False
 
         return self.software_manager.send_payload_to_session_manager(
-            payload=payload, dest_ip_address=dest_ip_address, dest_port=dest_port, session_id=session_id
+            payload=payload,
+            dest_ip_address=dest_ip_address,
+            dest_port=dest_port,
+            ip_protocol=ip_protocol,
+            session_id=session_id,
         )
 
     @abstractmethod