Merged PR 243: #2139 - Implemented routing

## Summary
- Integrated the RouteTable into the Routers frame processing.
- Frames are now dropped when their TTL reaches 0

## Test process
Added five tests that check routing passes and fails with correct/incorrect route tables.

## Checklist
- [ ] PR is linked to a **work item**
- [ ] **acceptance criteria** of linked ticket are met
- [ ] performed **self-review** of the code
- [ ] written **tests** for any new functionality added with this PR
- [ ] updated the **documentation** if this PR changes or adds functionality
- [ ] written/updated **design docs** if this PR implements new functionality
- [ ] updated the **change log**
- [ ] ran **pre-commit** checks for code style
- [ ] attended to any **TO-DOs** left in the code

#2139 - Implemented routing

Related work items: #2139

CHANGELOG.md

@@ -38,6 +38,18 @@ SessionManager.
 - HTTP Services: `WebBrowser` to simulate a web client and `WebServer`
 - Fixed an issue where the services were still able to run even though the node the service is installed on is turned off
 - NTP Services: `NTPClient` and `NTPServer`
+- **RouterNIC Class**: Introduced a new class `RouterNIC`, extending the standard `NIC` functionality. This class is specifically designed for router operations, optimizing the processing and routing of network traffic.
+  - **Custom Layer-3 Processing**: The `RouterNIC` class includes custom handling for network frames, bypassing standard Node NIC's Layer 3 broadcast/unicast checks. This allows for more efficient routing behavior in network scenarios where router-specific frame processing is required.
+  - **Enhanced Frame Reception**: The `receive_frame` method in `RouterNIC` is tailored to handle frames based on Layer 2 (Ethernet) checks, focusing on MAC address-based routing and broadcast frame acceptance.
+- **Subnet-Wide Broadcasting for Services and Applications**: Implemented the ability for services and applications to conduct broadcasts across an entire IPv4 subnet within the network simulation framework.
+
+### Changed
+- Integrated the RouteTable into the Routers frame processing.
+- Frames are now dropped when their TTL reaches 0
+- **NIC Functionality Update**: Updated the Network Interface Card (`NIC`) functionality to support Layer 3 (L3) broadcasts.
+  - **Layer 3 Broadcast Handling**: Enhanced the existing `NIC` classes to correctly process and handle Layer 3 broadcasts. This update allows devices using standard NICs to effectively participate in network activities that involve L3 broadcasting.
+  - **Improved Frame Reception Logic**: The `receive_frame` method of the `NIC` class has been updated to include additional checks and handling for L3 broadcasts, ensuring proper frame processing in a wider range of network scenarios.
+
 
 ### Removed
 - Removed legacy simulation modules: `acl`, `common`, `environment`, `links`, `nodes`, `pol`

src/primaite/simulator/network/creation.py

@@ -0,0 +1,148 @@
+from ipaddress import IPv4Address
+from typing import Optional
+
+from primaite.simulator.network.container import Network
+from primaite.simulator.network.hardware.nodes.computer import Computer
+from primaite.simulator.network.hardware.nodes.router import ACLAction, Router
+from primaite.simulator.network.hardware.nodes.switch import Switch
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+
+
+def num_of_switches_required(num_nodes: int, max_switch_ports: int = 24) -> int:
+    """
+    Calculate the minimum number of network switches required to connect a given number of nodes.
+
+    Each switch is assumed to have one port reserved for connecting to a router, reducing the effective
+    number of ports available for PCs. The function calculates the total number of switches needed
+    to accommodate all nodes under this constraint.
+
+    :param num_nodes: The total number of nodes that need to be connected in the network.
+    :param max_switch_ports: The maximum number of ports available on each switch. Defaults to 24.
+
+    :return: The minimum number of switches required to connect all PCs.
+
+    Example:
+    >>> num_of_switches_required(5)
+    1
+    >>> num_of_switches_required(24,24)
+    2
+    >>> num_of_switches_required(48,24)
+    3
+    >>> num_of_switches_required(25,10)
+    3
+    """
+    # Reduce the effective number of switch ports by 1 to leave space for the router
+    effective_switch_ports = max_switch_ports - 1
+
+    # Calculate the number of fully utilised switches and any additional switch for remaining PCs
+    full_switches = num_nodes // effective_switch_ports
+    extra_pcs = num_nodes % effective_switch_ports
+
+    # Return the total number of switches required
+    return full_switches + (1 if extra_pcs > 0 else 0)
+
+
+def create_office_lan(
+    lan_name: str,
+    subnet_base: int,
+    pcs_ip_block_start: int,
+    num_pcs: int,
+    network: Optional[Network] = None,
+    include_router: bool = True,
+) -> Network:
+    """
+    Creates a 2-Tier or 3-Tier office local area network (LAN).
+
+    The LAN is configured with a specified number of personal computers (PCs), optionally including a router,
+    and multiple edge switches to connect them. A core switch is added only if more than one edge switch is required.
+    The network topology involves edge switches connected either directly to the router in a 2-Tier setup or
+    to a core switch in a 3-Tier setup. If a router is included, it is connected to the core switch (if present)
+    and configured with basic access control list (ACL) rules. PCs are distributed across the edge switches.
+
+
+    :param str lan_name: The name to be assigned to the LAN.
+    :param int subnet_base: The subnet base number to be used in the IP addresses.
+    :param int pcs_ip_block_start: The starting block for assigning IP addresses to PCs.
+    :param int num_pcs: The number of PCs to be added to the LAN.
+    :param Optional[Network] network: The network to which the LAN components will be added. If None, a new network is
+        created.
+    :param bool include_router: Flag to determine if a router should be included in the LAN. Defaults to True.
+    :return: The network object with the LAN components added.
+    :raises ValueError: If pcs_ip_block_start is less than or equal to the number of required switches.
+    """
+    # Initialise the network if not provided
+    if not network:
+        network = Network()
+
+    # Calculate the required number of switches
+    num_of_switches = num_of_switches_required(num_nodes=num_pcs)
+    effective_switch_ports = 23  # One port less for router connection
+    if pcs_ip_block_start <= num_of_switches:
+        raise ValueError(f"pcs_ip_block_start must be greater than the number of required switches {num_of_switches}")
+
+    # Create a core switch if more than one edge switch is needed
+    if num_of_switches > 1:
+        core_switch = Switch(hostname=f"switch_core_{lan_name}", start_up_duration=0)
+        core_switch.power_on()
+        network.add_node(core_switch)
+        core_switch_port = 1
+
+    # Initialise the default gateway to None
+    default_gateway = None
+
+    # Optionally include a router in the LAN
+    if include_router:
+        default_gateway = IPv4Address(f"192.168.{subnet_base}.1")
+        router = Router(hostname=f"router_{lan_name}", start_up_duration=0)
+        router.power_on()
+        router.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.ARP, dst_port=Port.ARP, position=22)
+        router.acl.add_rule(action=ACLAction.PERMIT, protocol=IPProtocol.ICMP, position=23)
+        network.add_node(router)
+        router.configure_port(port=1, ip_address=default_gateway, subnet_mask="255.255.255.0")
+        router.enable_port(1)
+
+    # Initialise the first edge switch and connect to the router or core switch
+    switch_port = 0
+    switch_n = 1
+    switch = Switch(hostname=f"switch_edge_{switch_n}_{lan_name}", start_up_duration=0)
+    switch.power_on()
+    network.add_node(switch)
+    if num_of_switches > 1:
+        network.connect(core_switch.switch_ports[core_switch_port], switch.switch_ports[24])
+    else:
+        network.connect(router.ethernet_ports[1], switch.switch_ports[24])
+
+    # Add PCs to the LAN and connect them to switches
+    for i in range(1, num_pcs + 1):
+        # Add a new edge switch if the current one is full
+        if switch_port == effective_switch_ports:
+            switch_n += 1
+            switch_port = 0
+            switch = Switch(hostname=f"switch_edge_{switch_n}_{lan_name}", start_up_duration=0)
+            switch.power_on()
+            network.add_node(switch)
+            # Connect the new switch to the router or core switch
+            if num_of_switches > 1:
+                core_switch_port += 1
+                network.connect(core_switch.switch_ports[core_switch_port], switch.switch_ports[24])
+            else:
+                network.connect(router.ethernet_ports[1], switch.switch_ports[24])
+
+        # Create and add a PC to the network
+        pc = Computer(
+            hostname=f"pc_{i}_{lan_name}",
+            ip_address=f"192.168.{subnet_base}.{i+pcs_ip_block_start-1}",
+            subnet_mask="255.255.255.0",
+            default_gateway=default_gateway,
+            start_up_duration=0,
+        )
+        pc.power_on()
+        network.add_node(pc)
+
+        # Connect the PC to the switch
+        switch_port += 1
+        network.connect(switch.switch_ports[switch_port], pc.ethernet_port[1])
+        switch.switch_ports[switch_port].enable()
+
+    return network

src/primaite/simulator/network/hardware/base.py

@@ -4,7 +4,7 @@ import re
 import secrets
 from ipaddress import IPv4Address, IPv4Network
 from pathlib import Path
-from typing import Any, Dict, Literal, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 from prettytable import MARKDOWN, PrettyTable
 
@@ -274,18 +274,40 @@ class NIC(SimComponent):
 
     def receive_frame(self, frame: Frame) -> bool:
         """
-        Receive a network frame from the connected link if the NIC is enabled.
+        Receive a network frame from the connected link, processing it if the NIC is enabled.
 
-        The Frame is passed to the Node.
+        This method decrements the Time To Live (TTL) of the frame, captures it using PCAP (Packet Capture), and checks
+        if the frame is either a broadcast or destined for this NIC. If the frame is acceptable, it is passed to the
+        connected node. The method also handles the discarding of frames with TTL expired and logs this event.
 
-        :param frame: The network frame being received.
+        The frame's reception is based on various conditions:
+        - If the NIC is disabled, the frame is not processed.
+        - If the TTL of the frame reaches zero after decrement, it is discarded and logged.
+        - If the frame is a broadcast or its destination MAC/IP address matches this NIC's, it is accepted.
+        - All other frames are dropped and logged or printed to the console.
+
+        :param frame: The network frame being received. This should be an instance of the Frame class.
+        :return: Returns True if the frame is processed and passed to the node, False otherwise.
         """
         if self.enabled:
             frame.decrement_ttl()
+            if frame.ip and frame.ip.ttl < 1:
+                self._connected_node.sys_log.info("Frame discarded as TTL limit reached")
+                return False
             frame.set_received_timestamp()
             self.pcap.capture(frame)
             # If this destination or is broadcast
-            if frame.ethernet.dst_mac_addr == self.mac_address or frame.ethernet.dst_mac_addr == "ff:ff:ff:ff:ff:ff":
+            accept_frame = False
+
+            # Check if it's a broadcast:
+            if frame.ethernet.dst_mac_addr == "ff:ff:ff:ff:ff:ff":
+                if frame.ip.dst_ip_address in {self.ip_address, self.ip_network.broadcast_address}:
+                    accept_frame = True
+            else:
+                if frame.ethernet.dst_mac_addr == self.mac_address:
+                    accept_frame = True
+
+            if accept_frame:
                 self._connected_node.receive_frame(frame=frame, from_nic=self)
                 return True
         return False
@@ -436,6 +458,9 @@ class SwitchPort(SimComponent):
         """
         if self.enabled:
             frame.decrement_ttl()
+            if frame.ip and frame.ip.ttl < 1:
+                self._connected_node.sys_log.info("Frame discarded as TTL limit reached")
+                return False
             self.pcap.capture(frame)
             connected_node: Node = self._connected_node
             connected_node.forward_frame(frame=frame, incoming_port=self)
@@ -671,17 +696,30 @@ class ARPCache:
         """Clear the entire ARP cache, removing all stored entries."""
         self.arp.clear()
 
-    def send_arp_request(self, target_ip_address: Union[IPv4Address, str]):
+    def send_arp_request(
+        self, target_ip_address: Union[IPv4Address, str], ignore_networks: Optional[List[IPv4Address]] = None
+    ):
         """
         Perform a standard ARP request for a given target IP address.
 
         Broadcasts the request through all enabled NICs to determine the MAC address corresponding to the target IP
-        address.
+        address. This method can be configured to ignore specific networks when sending out ARP requests,
+        which is useful in environments where certain addresses should not be queried.
 
         :param target_ip_address: The target IP address to send an ARP request for.
+        :param ignore_networks: An optional list of IPv4 addresses representing networks to be excluded from the ARP
+            request broadcast. Each address in this list indicates a network which will not be queried during the ARP
+            request process. This is particularly useful in complex network environments where traffic should be
+            minimized or controlled to specific subnets. It is mainly used by the router to prevent ARP requests being
+            sent back to their source.
         """
         for nic in self.nics.values():
-            if nic.enabled:
+            use_nic = True
+            if ignore_networks:
+                for ipv4 in ignore_networks:
+                    if ipv4 in nic.ip_network:
+                        use_nic = False
+            if nic.enabled and use_nic:
                 self.sys_log.info(f"Sending ARP request from NIC {nic} for ip {target_ip_address}")
                 tcp_header = TCPHeader(src_port=Port.ARP, dst_port=Port.ARP)
 
@@ -806,7 +844,6 @@ class ICMP:
                 self.arp.send_arp_request(frame.ip.src_ip_address)
                 self.process_icmp(frame=frame, from_nic=from_nic, is_reattempt=True)
                 return
-            tcp_header = TCPHeader(src_port=Port.ARP, dst_port=Port.ARP)
 
             # Network Layer
             ip_packet = IPPacket(
@@ -821,9 +858,7 @@ class ICMP:
                 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
-            )
+            frame = Frame(ethernet=ethernet_header, ip=ip_packet, 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)
@@ -1447,7 +1482,6 @@ class Node(SimComponent):
         service.parent = self
         service.install()  # Perform any additional setup, such as creating files for this service on the node.
         self.sys_log.info(f"Installed service {service.name}")
-        _LOGGER.info(f"Added service {service.uuid} to node {self.uuid}")
         self._service_request_manager.add_request(service.uuid, RequestType(func=service._request_manager))
 
     def uninstall_service(self, service: Service) -> None:
@@ -1480,7 +1514,6 @@ class Node(SimComponent):
         self.applications[application.uuid] = application
         application.parent = self
         self.sys_log.info(f"Installed application {application.name}")
-        _LOGGER.info(f"Added application {application.uuid} to node {self.uuid}")
         self._application_request_manager.add_request(application.uuid, RequestType(func=application._request_manager))
 
     def uninstall_application(self, application: Application) -> None:

src/primaite/simulator/network/hardware/nodes/router.py

@@ -324,11 +324,10 @@ class RouteEntry(SimComponent):
     """
     Represents a single entry in a routing table.
 
-    Attributes:
-        address (IPv4Address): The destination IP address or network address.
-        subnet_mask (IPv4Address): The subnet mask for the network.
-        next_hop_ip_address (IPv4Address): The next hop IP address to which packets should be forwarded.
-        metric (int): The cost metric for this route. Default is 0.0.
+    :ivar address: The destination IP address or network address.
+    :ivar subnet_mask: The subnet mask for the network.
+    :ivar next_hop_ip_address: The next hop IP address to which packets should be forwarded.
+    :ivar metric: The cost metric for this route. Default is 0.0.
 
     Example:
         >>> entry = RouteEntry(
@@ -348,12 +347,6 @@ class RouteEntry(SimComponent):
     metric: float = 0.0
     "The cost metric for this route. Default is 0.0."
 
-    def __init__(self, **kwargs):
-        for key in {"address", "subnet_mask", "next_hop_ip_address"}:
-            if not isinstance(kwargs[key], IPv4Address):
-                kwargs[key] = IPv4Address(kwargs[key])
-        super().__init__(**kwargs)
-
     def set_original_state(self):
         """Sets the original state."""
         vals_to_include = {"address", "subnet_mask", "next_hop_ip_address", "metric"}
@@ -388,6 +381,7 @@ class RouteTable(SimComponent):
     """
 
     routes: List[RouteEntry] = []
+    default_route: Optional[RouteEntry] = None
     sys_log: SysLog
 
     def set_original_state(self):
@@ -433,12 +427,35 @@ class RouteTable(SimComponent):
         )
         self.routes.append(route)
 
+    def set_default_route_next_hop_ip_address(self, ip_address: IPv4Address):
+        """
+        Sets the next-hop IP address for the default route in a routing table.
+
+        This method checks if a default route (0.0.0.0/0) exists in the routing table. If it does not exist,
+         the method creates a new default route with the specified next-hop IP address. If a default route already
+         exists, it updates the next-hop IP address of the existing default route. After setting the next-hop
+         IP address, the method logs this action.
+
+        :param ip_address: The next-hop IP address to be set for the default route.
+        """
+        if not self.default_route:
+            self.default_route = RouteEntry(
+                ip_address=IPv4Address("0.0.0.0"),
+                subnet_mask=IPv4Address("0.0.0.0"),
+                next_hop_ip_address=ip_address,
+            )
+        else:
+            self.default_route.next_hop_ip_address = ip_address
+        self.sys_log.info(f"Default configured to use {ip_address} as the next-hop")
+
     def find_best_route(self, destination_ip: Union[str, IPv4Address]) -> Optional[RouteEntry]:
         """
         Find the best route for a given destination IP.
 
         This method uses the Longest Prefix Match algorithm and considers metrics to find the best route.
 
+        If no dedicated route exists but a default route does, then the default route is returned as a last resort.
+
         :param destination_ip: The destination IP to find the route for.
         :return: The best matching RouteEntry, or None if no route matches.
         """
@@ -458,6 +475,9 @@ class RouteTable(SimComponent):
                     longest_prefix = prefix_len
                     lowest_metric = route.metric
 
+        if not best_route and self.default_route:
+            best_route = self.default_route
+
         return best_route
 
     def show(self, markdown: bool = False):
@@ -489,12 +509,26 @@ class RouterARPCache(ARPCache):
         super().__init__(sys_log)
         self.router: Router = router
 
-    def process_arp_packet(self, from_nic: NIC, frame: Frame):
+    def process_arp_packet(
+        self, from_nic: NIC, frame: Frame, route_table: RouteTable, is_reattempt: bool = False
+    ) -> None:
         """
-        Overridden method to process a received ARP packet in a router-specific way.
+        Processes a received ARP (Address Resolution Protocol) packet in a router-specific way.
+
+        This method is responsible for handling both ARP requests and responses. It processes ARP packets received on a
+        Network Interface Card (NIC) and performs actions based on whether the packet is a request or a reply. This
+        includes updating the ARP cache, forwarding ARP replies, sending ARP requests for unknown destinations, and
+        handling packet TTL (Time To Live).
+
+        The method first checks if the ARP packet is a request or a reply. For ARP replies, it updates the ARP cache
+        and forwards the reply if necessary. For ARP requests, it checks if the target IP matches one of the router's
+        NICs and sends an ARP reply if so. If the destination is not directly connected, it consults the routing table
+        to find the best route and reattempts ARP request processing if needed.
 
         :param from_nic: The NIC that received the ARP packet.
-        :param frame: The original ARP frame.
+        :param frame: The frame containing the ARP packet.
+        :param route_table: The routing table of the router.
+        :param is_reattempt: Flag to indicate if this is a reattempt of processing the ARP packet, defaults to False.
         """
         arp_packet = frame.arp
 
@@ -522,7 +556,11 @@ class RouterARPCache(ARPCache):
                 )
                 arp_packet.sender_mac_addr = nic.mac_address
                 frame.decrement_ttl()
+                if frame.ip and frame.ip.ttl < 1:
+                    self.sys_log.info("Frame discarded as TTL limit reached")
+                    return
                 nic.send_frame(frame)
+            return
 
         # ARP Request
         self.sys_log.info(
@@ -533,16 +571,32 @@ class RouterARPCache(ARPCache):
         self.add_arp_cache_entry(
             ip_address=arp_packet.sender_ip_address, mac_address=arp_packet.sender_mac_addr, nic=from_nic
         )
-        arp_packet = arp_packet.generate_reply(from_nic.mac_address)
-        self.send_arp_reply(arp_packet, from_nic)
 
         # If the target IP matches one of the router's NICs
         for nic in self.nics.values():
-            if nic.enabled and nic.ip_address == arp_packet.target_ip_address:
+            if arp_packet.target_ip_address in nic.ip_network:
+                # if nic.enabled and nic.ip_address == arp_packet.target_ip_address:
                 arp_reply = arp_packet.generate_reply(from_nic.mac_address)
                 self.send_arp_reply(arp_reply, from_nic)
                 return
 
+        # Check Route Table
+        route = route_table.find_best_route(arp_packet.target_ip_address)
+        if route:
+            nic = self.get_arp_cache_nic(route.next_hop_ip_address)
+
+            if not nic:
+                if not is_reattempt:
+                    self.send_arp_request(route.next_hop_ip_address, ignore_networks=[frame.ip.src_ip_address])
+                    return self.process_arp_packet(from_nic, frame, route_table, is_reattempt=True)
+                else:
+                    self.sys_log.info("Ignoring ARP request as destination unavailable/No ARP entry found")
+                    return
+            else:
+                arp_reply = arp_packet.generate_reply(from_nic.mac_address)
+                self.send_arp_reply(arp_reply, from_nic)
+            return
+
 
 class RouterICMP(ICMP):
     """
@@ -613,7 +667,7 @@ class RouterICMP(ICMP):
                     return
 
             # Route the frame
-            self.router.route_frame(frame, from_nic)
+            self.router.process_frame(frame, from_nic)
 
         elif frame.icmp.icmp_type == ICMPType.ECHO_REPLY:
             for nic in self.router.nics.values():
@@ -633,7 +687,48 @@ class RouterICMP(ICMP):
 
                     return
             # Route the frame
-            self.router.route_frame(frame, from_nic)
+            self.router.process_frame(frame, from_nic)
+
+
+class RouterNIC(NIC):
+    """
+    A Router-specific Network Interface Card (NIC) that extends the standard NIC functionality.
+
+    This class overrides the standard Node NIC's Layer 3 (L3) broadcast/unicast checks. It is designed
+    to handle network frames in a manner specific to routers, allowing them to efficiently process
+    and route network traffic.
+    """
+
+    def receive_frame(self, frame: Frame) -> bool:
+        """
+        Receive and process a network frame from the connected link, provided the NIC is enabled.
+
+        This method is tailored for router behavior. It decrements the frame's Time To Live (TTL), checks for TTL
+        expiration, and captures the frame using PCAP (Packet Capture). The frame is accepted if it is destined for
+        this NIC's MAC address or is a broadcast frame.
+
+        Key Differences from Standard NIC:
+        - Does not perform Layer 3 (IP-based) broadcast checks.
+        - Only checks for Layer 2 (Ethernet) destination MAC address and broadcast frames.
+
+        :param frame: The network frame being received. This should be an instance of the Frame class.
+        :return: Returns True if the frame is processed and passed to the connected node, False otherwise.
+        """
+        if self.enabled:
+            frame.decrement_ttl()
+            if frame.ip and frame.ip.ttl < 1:
+                self._connected_node.sys_log.info("Frame discarded as TTL limit reached")
+                return False
+            frame.set_received_timestamp()
+            self.pcap.capture(frame)
+            # If this destination or is broadcast
+            if frame.ethernet.dst_mac_addr == self.mac_address or frame.ethernet.dst_mac_addr == "ff:ff:ff:ff:ff:ff":
+                self._connected_node.receive_frame(frame=frame, from_nic=self)
+                return True
+        return False
+
+    def __str__(self) -> str:
+        return f"{self.mac_address}/{self.ip_address}"
 
 
 class Router(Node):
@@ -646,7 +741,7 @@ class Router(Node):
     """
 
     num_ports: int
-    ethernet_ports: Dict[int, NIC] = {}
+    ethernet_ports: Dict[int, RouterNIC] = {}
     acl: AccessControlList
     route_table: RouteTable
     arp: RouterARPCache
@@ -665,7 +760,7 @@ class Router(Node):
             kwargs["icmp"] = RouterICMP(sys_log=kwargs.get("sys_log"), arp_cache=kwargs.get("arp"), router=self)
         super().__init__(hostname=hostname, num_ports=num_ports, **kwargs)
         for i in range(1, self.num_ports + 1):
-            nic = NIC(ip_address="127.0.0.1", subnet_mask="255.0.0.0", gateway="0.0.0.0")
+            nic = RouterNIC(ip_address="127.0.0.1", subnet_mask="255.0.0.0", gateway="0.0.0.0")
             self.connect_nic(nic)
             self.ethernet_ports[i] = nic
 
@@ -720,9 +815,9 @@ class Router(Node):
         state["acl"] = (self.acl.describe_state(),)
         return state
 
-    def route_frame(self, frame: Frame, from_nic: NIC, re_attempt: bool = False) -> None:
+    def process_frame(self, frame: Frame, from_nic: NIC, re_attempt: bool = False) -> None:
         """
-        Route a given frame from a source NIC to its destination.
+        Process a Frame.
 
         :param frame: The frame to be routed.
         :param from_nic: The source network interface.
@@ -737,25 +832,57 @@ class Router(Node):
             return
 
         if not nic:
-            self.arp.send_arp_request(frame.ip.dst_ip_address)
-            return self.route_frame(frame=frame, from_nic=from_nic, re_attempt=True)
+            self.arp.send_arp_request(
+                frame.ip.dst_ip_address, ignore_networks=[frame.ip.src_ip_address, from_nic.ip_address]
+            )
+            return self.process_frame(frame=frame, from_nic=from_nic, re_attempt=True)
 
         if not nic.enabled:
-            # TODO: Add sys_log here
+            self.sys_log.info(f"Frame dropped as NIC {nic} is not enabled")
             return
 
         if frame.ip.dst_ip_address in nic.ip_network:
             from_port = self._get_port_of_nic(from_nic)
             to_port = self._get_port_of_nic(nic)
-            self.sys_log.info(f"Routing frame to internally from port {from_port} to port {to_port}")
+            self.sys_log.info(f"Forwarding frame to internally from port {from_port} to port {to_port}")
             frame.decrement_ttl()
+            if frame.ip and frame.ip.ttl < 1:
+                self.sys_log.info("Frame discarded as TTL limit reached")
+                return
             frame.ethernet.src_mac_addr = nic.mac_address
             frame.ethernet.dst_mac_addr = target_mac
             nic.send_frame(frame)
             return
         else:
-            pass
-            # TODO: Deal with routing from route tables
+            self._route_frame(frame, from_nic)
+
+    def _route_frame(self, frame: Frame, from_nic: NIC, re_attempt: bool = False) -> None:
+        route = self.route_table.find_best_route(frame.ip.dst_ip_address)
+        if route:
+            nic = self.arp.get_arp_cache_nic(route.next_hop_ip_address)
+            target_mac = self.arp.get_arp_cache_mac_address(route.next_hop_ip_address)
+            if re_attempt and not nic:
+                self.sys_log.info(f"Destination {frame.ip.dst_ip_address} is unreachable")
+                return
+
+            if not nic:
+                self.arp.send_arp_request(frame.ip.dst_ip_address, ignore_networks=[frame.ip.src_ip_address])
+                return self.process_frame(frame=frame, from_nic=from_nic, re_attempt=True)
+
+            if not nic.enabled:
+                self.sys_log.info(f"Frame dropped as NIC {nic} is not enabled")
+                return
+
+            from_port = self._get_port_of_nic(from_nic)
+            to_port = self._get_port_of_nic(nic)
+            self.sys_log.info(f"Routing frame to internally from port {from_port} to port {to_port}")
+            frame.decrement_ttl()
+            if frame.ip and frame.ip.ttl < 1:
+                self.sys_log.info("Frame discarded as TTL limit reached")
+                return
+            frame.ethernet.src_mac_addr = nic.mac_address
+            frame.ethernet.dst_mac_addr = target_mac
+            nic.send_frame(frame)
 
     def receive_frame(self, frame: Frame, from_nic: NIC):
         """
@@ -764,7 +891,7 @@ class Router(Node):
         :param frame: The incoming frame.
         :param from_nic: The network interface where the frame is coming from.
         """
-        route_frame = False
+        process_frame = False
         protocol = frame.ip.protocol
         src_ip_address = frame.ip.src_ip_address
         dst_ip_address = frame.ip.dst_ip_address
@@ -796,12 +923,12 @@ class Router(Node):
             self.icmp.process_icmp(frame=frame, from_nic=from_nic)
         else:
             if src_port == Port.ARP:
-                self.arp.process_arp_packet(from_nic=from_nic, frame=frame)
+                self.arp.process_arp_packet(from_nic=from_nic, frame=frame, route_table=self.route_table)
             else:
                 # All other traffic
-                route_frame = True
-        if route_frame:
-            self.route_frame(frame, from_nic)
+                process_frame = True
+        if process_frame:
+            self.process_frame(frame, from_nic)
 
     def configure_port(self, port: int, ip_address: Union[IPv4Address, str], subnet_mask: Union[IPv4Address, str]):
         """

src/primaite/simulator/network/hardware/nodes/switch.py

@@ -90,12 +90,12 @@ class Switch(Node):
         self._add_mac_table_entry(src_mac, incoming_port)
 
         outgoing_port = self.mac_address_table.get(dst_mac)
-        if outgoing_port or dst_mac != "ff:ff:ff:ff:ff:ff":
+        if outgoing_port and dst_mac.lower() != "ff:ff:ff:ff:ff:ff":
             outgoing_port.send_frame(frame)
         else:
             # If the destination MAC is not in the table, flood to all ports except incoming
             for port in self.switch_ports.values():
-                if port != incoming_port:
+                if port.enabled and port != incoming_port:
                     port.send_frame(frame)
 
     def disconnect_link_from_port(self, link: Link, port_number: int):

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ipaddress import IPv4Address
+from ipaddress import IPv4Address, IPv4Network
 from typing import Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
 
 from prettytable import MARKDOWN, PrettyTable
@@ -141,41 +141,76 @@ class SessionManager:
     def receive_payload_from_software_manager(
         self,
         payload: Any,
-        dst_ip_address: Optional[IPv4Address] = None,
+        dst_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
         dst_port: Optional[Port] = None,
         session_id: Optional[str] = None,
         is_reattempt: bool = False,
     ) -> Union[Any, None]:
         """
-        Receive a payload from the SoftwareManager.
+        Receive a payload from the SoftwareManager and send it to the appropriate NIC for transmission.
 
-        If no session_id, a Session is established. Once established, the payload is sent to ``send_payload_to_nic``.
+        This method supports both unicast and Layer 3 broadcast transmissions. If `dst_ip_address` is an
+        IPv4Network, a broadcast is initiated. For unicast, the destination MAC address is resolved via ARP.
+        A new session is established if `session_id` is not provided, and an existing session is used otherwise.
 
         :param payload: The payload to be sent.
-        :param session_id: The Session ID the payload is to originate from. Optional. If None, one will be created.
+        :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 = self.sessions_by_uuid[session_id].with_ip_address
-            dst_port = self.sessions_by_uuid[session_id].dst_port
+            dst_ip_address = session.with_ip_address
+            dst_port = session.dst_port
 
-        dst_mac_address = self.arp_cache.get_arp_cache_mac_address(dst_ip_address)
+        # Determine if the payload is for broadcast or unicast
 
-        if dst_mac_address:
-            outbound_nic = self.arp_cache.get_arp_cache_nic(dst_ip_address)
+        # 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:
-            if not is_reattempt:
-                self.arp_cache.send_arp_request(dst_ip_address)
-                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
+            # 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
+            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
+
+        # Check if outbound NIC and destination MAC address are resolved
+        if not outbound_nic 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(
@@ -189,15 +224,17 @@ class SessionManager:
             payload=payload,
         )
 
-        if not session_id:
+        # Manage session for unicast transmission
+        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)
             if not session:
-                # Create new session
+                # Create a new session if it doesn't exist
                 session = Session.from_session_key(session_key)
                 self.sessions_by_key[session_key] = session
                 self.sessions_by_uuid[session.uuid] = session
 
+        # Send the frame through the NIC
         return outbound_nic.send_frame(frame)
 
     def receive_frame(self, frame: Frame):

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

@@ -1,4 +1,4 @@
-from ipaddress import IPv4Address
+from ipaddress import IPv4Address, IPv4Network
 from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 
 from prettytable import MARKDOWN, PrettyTable
@@ -130,20 +130,28 @@ class SoftwareManager:
     def send_payload_to_session_manager(
         self,
         payload: Any,
-        dest_ip_address: Optional[IPv4Address] = None,
+        dest_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
         dest_port: Optional[Port] = None,
         session_id: Optional[str] = None,
     ) -> bool:
         """
-        Send a payload to the SessionManager.
+        Sends a payload to the SessionManager for network transmission.
+
+        This method is responsible for initiating the process of sending network payloads. It supports both
+        unicast and Layer 3 broadcast transmissions. For broadcasts, the destination IP should be specified
+        as an IPv4Network.
 
         :param payload: The payload to be sent.
-        :param dest_ip_address: The ip address of the payload destination.
-        :param dest_port: The port of the payload destination.
-        :param session_id: The Session ID the payload is to originate from. Optional.
+        :param dest_ip_address: The IP address or network (for broadcasts) of the payload destination.
+        :param dest_port: The destination port for the payload. Optional.
+        :param session_id: The Session ID from which the payload originates. Optional.
+        :return: True if the payload was successfully sent, False otherwise.
         """
         return self.session_manager.receive_payload_from_software_manager(
-            payload=payload, dst_ip_address=dest_ip_address, dst_port=dest_port, session_id=session_id
+            payload=payload,
+            dst_ip_address=dest_ip_address,
+            dst_port=dest_port,
+            session_id=session_id,
         )
 
     def receive_payload_from_session_manager(self, payload: Any, port: Port, protocol: IPProtocol, session_id: str):

src/primaite/simulator/system/software.py

@@ -2,8 +2,8 @@ import copy
 from abc import abstractmethod
 from datetime import datetime
 from enum import Enum
-from ipaddress import IPv4Address
-from typing import Any, Dict, Optional
+from ipaddress import IPv4Address, IPv4Network
+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
@@ -350,19 +350,22 @@ class IOSoftware(Software):
         self,
         payload: Any,
         session_id: Optional[str] = None,
-        dest_ip_address: Optional[IPv4Address] = None,
+        dest_ip_address: Optional[Union[IPv4Address, IPv4Network]] = None,
         dest_port: Optional[Port] = None,
         **kwargs,
     ) -> bool:
         """
-        Sends a payload to the SessionManager.
+        Sends a payload to the SessionManager for network transmission.
+
+        This method is responsible for initiating the process of sending network payloads. It supports both
+        unicast and Layer 3 broadcast transmissions. For broadcasts, the destination IP should be specified
+        as an IPv4Network. It delegates the actual sending process to the SoftwareManager.
 
         :param payload: The payload to be sent.
-        :param dest_ip_address: The ip address of the payload destination.
-        :param dest_port: The port of the payload destination.
-        :param session_id: The Session ID the payload is to originate from. Optional.
-
-        :return: True if successful, False otherwise.
+        :param dest_ip_address: The IP address or network (for broadcasts) of the payload destination.
+        :param dest_port: The destination port for the payload. Optional.
+        :param session_id: The Session ID from which the payload originates. Optional.
+        :return: True if the payload was successfully sent, False otherwise.
         """
         if not self._can_perform_action():
             return False

tests/integration_tests/network/test_broadcast.py

@@ -0,0 +1,180 @@
+from ipaddress import IPv4Address, IPv4Network
+from typing import Any, Dict, List, Tuple
+
+import pytest
+
+from primaite.simulator.network.container import Network
+from primaite.simulator.network.hardware.nodes.computer import Computer
+from primaite.simulator.network.hardware.nodes.server import Server
+from primaite.simulator.network.hardware.nodes.switch import Switch
+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
+from primaite.simulator.system.services.service import Service
+
+
+class BroadcastService(Service):
+    """A service for sending broadcast and unicast messages over a network."""
+
+    def __init__(self, **kwargs):
+        # Set default service properties for broadcasting
+        kwargs["name"] = "BroadcastService"
+        kwargs["port"] = Port.HTTP
+        kwargs["protocol"] = IPProtocol.TCP
+        super().__init__(**kwargs)
+
+    def describe_state(self) -> Dict:
+        # Implement state description for the service
+        pass
+
+    def unicast(self, ip_address: IPv4Address):
+        # Send a unicast payload to a specific IP address
+        super().send(
+            payload="unicast",
+            dest_ip_address=ip_address,
+            dest_port=Port.HTTP,
+        )
+
+    def broadcast(self, ip_network: IPv4Network):
+        # Send a broadcast payload to an entire IP network
+        super().send(
+            payload="broadcast",
+            dest_ip_address=ip_network,
+            dest_port=Port.HTTP,
+        )
+
+
+class BroadcastClient(Application):
+    """A client application to receive broadcast and unicast messages."""
+
+    payloads_received: List = []
+
+    def __init__(self, **kwargs):
+        # Set default client properties
+        kwargs["name"] = "BroadcastClient"
+        kwargs["port"] = Port.HTTP
+        kwargs["protocol"] = IPProtocol.TCP
+        super().__init__(**kwargs)
+
+    def describe_state(self) -> Dict:
+        # Implement state description for the application
+        pass
+
+    def receive(self, payload: Any, session_id: str, **kwargs) -> bool:
+        # Append received payloads to the list and print a message
+        self.payloads_received.append(payload)
+        print(f"Payload: {payload} received on node {self.sys_log.hostname}")
+
+
+@pytest.fixture(scope="function")
+def broadcast_network() -> Network:
+    network = Network()
+
+    client_1 = Computer(
+        hostname="client_1",
+        ip_address="192.168.1.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        start_up_duration=0,
+    )
+    client_1.power_on()
+    client_1.software_manager.install(BroadcastClient)
+    application_1 = client_1.software_manager.software["BroadcastClient"]
+    application_1.run()
+
+    client_2 = Computer(
+        hostname="client_2",
+        ip_address="192.168.1.3",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        start_up_duration=0,
+    )
+    client_2.power_on()
+    client_2.software_manager.install(BroadcastClient)
+    application_2 = client_2.software_manager.software["BroadcastClient"]
+    application_2.run()
+
+    server_1 = Server(
+        hostname="server_1",
+        ip_address="192.168.1.1",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.1.1",
+        start_up_duration=0,
+    )
+    server_1.power_on()
+
+    server_1.software_manager.install(BroadcastService)
+    service: BroadcastService = server_1.software_manager.software["BroadcastService"]
+    service.start()
+
+    switch_1 = Switch(hostname="switch_1", num_ports=6, start_up_duration=0)
+    switch_1.power_on()
+
+    network.connect(endpoint_a=client_1.ethernet_port[1], endpoint_b=switch_1.switch_ports[1])
+    network.connect(endpoint_a=client_2.ethernet_port[1], endpoint_b=switch_1.switch_ports[2])
+    network.connect(endpoint_a=server_1.ethernet_port[1], endpoint_b=switch_1.switch_ports[3])
+
+    return network
+
+
+@pytest.fixture(scope="function")
+def broadcast_service_and_clients(broadcast_network) -> Tuple[BroadcastService, BroadcastClient, BroadcastClient]:
+    client_1: BroadcastClient = broadcast_network.get_node_by_hostname("client_1").software_manager.software[
+        "BroadcastClient"
+    ]
+    client_2: BroadcastClient = broadcast_network.get_node_by_hostname("client_2").software_manager.software[
+        "BroadcastClient"
+    ]
+    service: BroadcastService = broadcast_network.get_node_by_hostname("server_1").software_manager.software[
+        "BroadcastService"
+    ]
+
+    return service, client_1, client_2
+
+
+def test_broadcast_correct_subnet(broadcast_service_and_clients):
+    service, client_1, client_2 = broadcast_service_and_clients
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received
+
+    service.broadcast(IPv4Network("192.168.1.0/24"))
+
+    assert client_1.payloads_received == ["broadcast"]
+    assert client_2.payloads_received == ["broadcast"]
+
+
+def test_broadcast_incorrect_subnet(broadcast_service_and_clients):
+    service, client_1, client_2 = broadcast_service_and_clients
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received
+
+    service.broadcast(IPv4Network("192.168.2.0/24"))
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received
+
+
+def test_unicast_correct_address(broadcast_service_and_clients):
+    service, client_1, client_2 = broadcast_service_and_clients
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received
+
+    service.unicast(IPv4Address("192.168.1.2"))
+
+    assert client_1.payloads_received == ["unicast"]
+    assert not client_2.payloads_received
+
+
+def test_unicast_incorrect_address(broadcast_service_and_clients):
+    service, client_1, client_2 = broadcast_service_and_clients
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received
+
+    service.unicast(IPv4Address("192.168.2.2"))
+
+    assert not client_1.payloads_received
+    assert not client_2.payloads_received

tests/integration_tests/network/test_routing.py

@@ -1,11 +1,16 @@
+from ipaddress import IPv4Address
 from typing import Tuple
 
 import pytest
 
+from primaite.simulator.network.container import Network
 from primaite.simulator.network.hardware.base import Link, NIC, Node, NodeOperatingState
+from primaite.simulator.network.hardware.nodes.computer import Computer
 from primaite.simulator.network.hardware.nodes.router import ACLAction, Router
 from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.services.ntp.ntp_client import NTPClient
+from primaite.simulator.system.services.ntp.ntp_server import NTPServer
 
 
 @pytest.fixture(scope="function")
@@ -34,6 +39,69 @@ def pc_a_pc_b_router_1() -> Tuple[Node, Node, Router]:
     return pc_a, pc_b, router_1
 
 
+@pytest.fixture(scope="function")
+def multi_hop_network() -> Network:
+    network = Network()
+
+    # Configure PC A
+    pc_a = Computer(
+        hostname="pc_a",
+        ip_address="192.168.0.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.0.1",
+        start_up_duration=0,
+    )
+    pc_a.power_on()
+    network.add_node(pc_a)
+
+    # Configure Router 1
+    router_1 = Router(hostname="router_1", start_up_duration=0)
+    router_1.power_on()
+    network.add_node(router_1)
+
+    # Configure the connection between PC A and Router 1 port 2
+    router_1.configure_port(2, "192.168.0.1", "255.255.255.0")
+    network.connect(pc_a.ethernet_port[1], router_1.ethernet_ports[2])
+    router_1.enable_port(2)
+
+    # Configure Router 1 ACLs
+    router_1.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.ARP, dst_port=Port.ARP, position=22)
+    router_1.acl.add_rule(action=ACLAction.PERMIT, protocol=IPProtocol.ICMP, position=23)
+
+    # Configure PC B
+    pc_b = Computer(
+        hostname="pc_b",
+        ip_address="192.168.2.2",
+        subnet_mask="255.255.255.0",
+        default_gateway="192.168.2.1",
+        start_up_duration=0,
+    )
+    pc_b.power_on()
+    network.add_node(pc_b)
+
+    # Configure Router 2
+    router_2 = Router(hostname="router_2", start_up_duration=0)
+    router_2.power_on()
+    network.add_node(router_2)
+
+    # Configure the connection between PC B and Router 2 port 2
+    router_2.configure_port(2, "192.168.2.1", "255.255.255.0")
+    network.connect(pc_b.ethernet_port[1], router_2.ethernet_ports[2])
+    router_2.enable_port(2)
+
+    # Configure Router 2 ACLs
+    router_2.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.ARP, dst_port=Port.ARP, position=22)
+    router_2.acl.add_rule(action=ACLAction.PERMIT, protocol=IPProtocol.ICMP, position=23)
+
+    # Configure the connection between Router 1 port 1 and Router 2 port 1
+    router_2.configure_port(1, "192.168.1.2", "255.255.255.252")
+    router_1.configure_port(1, "192.168.1.1", "255.255.255.252")
+    network.connect(router_1.ethernet_ports[1], router_2.ethernet_ports[1])
+    router_1.enable_port(1)
+    router_2.enable_port(1)
+    return network
+
+
 def test_ping_default_gateway(pc_a_pc_b_router_1):
     pc_a, pc_b, router_1 = pc_a_pc_b_router_1
 
@@ -50,3 +118,68 @@ def test_host_on_other_subnet(pc_a_pc_b_router_1):
     pc_a, pc_b, router_1 = pc_a_pc_b_router_1
 
     assert pc_a.ping("192.168.1.10")
+
+
+def test_no_route_no_ping(multi_hop_network):
+    pc_a = multi_hop_network.get_node_by_hostname("pc_a")
+    pc_b = multi_hop_network.get_node_by_hostname("pc_b")
+
+    assert not pc_a.ping(pc_b.ethernet_port[1].ip_address)
+
+
+def test_with_routes_can_ping(multi_hop_network):
+    pc_a = multi_hop_network.get_node_by_hostname("pc_a")
+    pc_b = multi_hop_network.get_node_by_hostname("pc_b")
+
+    router_1: Router = multi_hop_network.get_node_by_hostname("router_1")  # noqa
+    router_2: Router = multi_hop_network.get_node_by_hostname("router_2")  # noqa
+
+    # Configure Route from Router 1 to PC B subnet
+    router_1.route_table.add_route(
+        address="192.168.2.0", subnet_mask="255.255.255.0", next_hop_ip_address="192.168.1.2"
+    )
+
+    # Configure Route from Router 2 to PC A subnet
+    router_2.route_table.add_route(
+        address="192.168.0.2", subnet_mask="255.255.255.0", next_hop_ip_address="192.168.1.1"
+    )
+
+    assert pc_a.ping(pc_b.ethernet_port[1].ip_address)
+
+
+def test_routing_services(multi_hop_network):
+    pc_a = multi_hop_network.get_node_by_hostname("pc_a")
+
+    pc_b = multi_hop_network.get_node_by_hostname("pc_b")
+
+    pc_a.software_manager.install(NTPClient)
+    ntp_client = pc_a.software_manager.software["NTPClient"]
+    ntp_client.start()
+
+    pc_b.software_manager.install(NTPServer)
+    pc_b.software_manager.software["NTPServer"].start()
+
+    ntp_client.configure(ntp_server_ip_address=pc_b.ethernet_port[1].ip_address)
+
+    router_1: Router = multi_hop_network.get_node_by_hostname("router_1")  # noqa
+    router_2: Router = multi_hop_network.get_node_by_hostname("router_2")  # noqa
+
+    router_1.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.NTP, dst_port=Port.NTP, position=21)
+    router_2.acl.add_rule(action=ACLAction.PERMIT, src_port=Port.NTP, dst_port=Port.NTP, position=21)
+
+    assert ntp_client.time is None
+    ntp_client.request_time()
+    assert ntp_client.time is None
+
+    # Configure Route from Router 1 to PC B subnet
+    router_1.route_table.add_route(
+        address="192.168.2.0", subnet_mask="255.255.255.0", next_hop_ip_address="192.168.1.2"
+    )
+
+    # Configure Route from Router 2 to PC A subnet
+    router_2.route_table.add_route(
+        address="192.168.0.2", subnet_mask="255.255.255.0", next_hop_ip_address="192.168.1.1"
+    )
+
+    ntp_client.request_time()
+    assert ntp_client.time is not None