How does a router forward a data packet to the correct server?

1. Determining the target IP address: The router extracts the destination IP address from the data packet header.
2. Searching in the routing table: The router searches for this IP address or the corresponding network in its routing table. The table contains entries about networks and next hops (where to send the packet next).
3. Determining the next hop: If a match is found, the router determines the next IP address or interface through which to send the packet.
4. Encapsulation and sending: The router changes the destination MAC address in the packet header to the MAC address of the next hop (via ARP) and sends the packet to this hop.
5. Repeating the process: This process is repeated at each router along the path until the packet reaches the target network.
6. Delivery within the network: In the target network, the final router sends the packet directly to the server with the corresponding IP address (again using ARP to determine the server's MAC address).

# Example (not exactly router code, but a concept)
def route_packet(packet, routing_table, arp_cache)
  destination_ip = packet[:destination_ip]

  routing_table.each do |entry|
    if matches_network?(destination_ip, entry[:network])
      next_hop_ip = entry[:next_hop] || destination_ip # If it's a direct network
      next_hop_mac = arp_cache[next_hop_ip] # Look up MAC in ARP cache

      if next_hop_mac
        packet[:destination_mac] = next_hop_mac
        send_packet_to_interface(packet, entry[:interface])
        return true
      else
        # ARP request to determine MAC address of the next hop
        send_arp_request(next_hop_ip, entry[:interface])
        # The packet will be queued until the ARP reply is received
        return false # Packet not sent immediately
      end
    end
  end
  # If no match is found, send to default route
  send_packet_to_default_route(packet)
  return true
end

def matches_network?(ip, network_cidr)
  # Logic to determine if the IP address belongs to the CIDR network
  # e.g., "192.168.1.10" in "192.168.1.0/24"
end

def send_packet_to_interface(packet, interface)
  # Logic to send the packet through a physical or virtual interface
end

def send_arp_request(ip, interface)
  # Logic to send an ARP request
end

def send_packet_to_default_route(packet)
  # Logic to send the packet via the default route (if any)
end

# Example routing table structure
# routing_table = [
#   { network: "192.168.1.0/24", interface: "eth0" },
#   { network: "10.0.0.0/8", next_hop: "192.168.1.1", interface: "eth1" },
#   { network: "0.0.0.0/0", next_hop: "192.168.1.254", interface: "eth0" } # Default route
# ]

# Example ARP cache structure
# arp_cache = {
#   "192.168.1.1" => "aa:bb:cc:dd:ee:ff",
#   "192.168.1.100" => "11:22:33:44:55:66"
# }