CS 144 Checkpoint 5: the IP router

Author: keithw

etc/tests.cmake

@@ -56,6 +56,8 @@ ttest(send_extra)
 
 ttest(net_interface)
 
+ttest(router)
+
 add_custom_target (check0 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --stop-on-failure --timeout 12 -R 'webget|^byte_stream_')
 
 add_custom_target (check_webget COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --timeout 12 -R 'webget')
@@ -68,6 +70,8 @@ add_custom_target (check3 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --s
 
 add_custom_target (check4 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --stop-on-failure --timeout 12 -R '^net_interface')
 
+add_custom_target (check5 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --stop-on-failure --timeout 12 -R '^net_interface|^router')
+
 ###
 
 add_custom_target (speed COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --timeout 12 -R '_speed_test')

scripts/lines-of-code

@@ -11,7 +11,8 @@ modules = [['byte_stream', 'ByteStream'],
            ['tcp_receiver', 'TCPReceiver'],
            ['wrapping_integers', 'Wrap32'],
            ['tcp_sender', 'TCPSender'],
-           ['network_interface', 'NetworkInterface']]
+           ['network_interface', 'NetworkInterface'],
+           ['router', 'Router']]
 longest_module_length = max([len(x[1]) for x in modules])
 
 

src/router.cc

@@ -0,0 +1,29 @@
+#include "router.hh"
+
+#include <iostream>
+#include <limits>
+
+using namespace std;
+
+// route_prefix: The "up-to-32-bit" IPv4 address prefix to match the datagram's destination address against
+// prefix_length: For this route to be applicable, how many high-order (most-significant) bits of
+//    the route_prefix will need to match the corresponding bits of the datagram's destination address?
+// next_hop: The IP address of the next hop. Will be empty if the network is directly attached to the router (in
+//    which case, the next hop address should be the datagram's final destination).
+// interface_num: The index of the interface to send the datagram out on.
+void Router::add_route( const uint32_t route_prefix,
+                        const uint8_t prefix_length,
+                        const optional<Address> next_hop,
+                        const size_t interface_num )
+{
+  cerr << "DEBUG: adding route " << Address::from_ipv4_numeric( route_prefix ).ip() << "/"
+       << static_cast<int>( prefix_length ) << " => " << ( next_hop.has_value() ? next_hop->ip() : "(direct)" )
+       << " on interface " << interface_num << "\n";
+
+  (void)route_prefix;
+  (void)prefix_length;
+  (void)next_hop;
+  (void)interface_num;
+}
+
+void Router::route() {}

src/router.hh

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "network_interface.hh"
+
+#include <optional>
+#include <queue>
+
+// A wrapper for NetworkInterface that makes the host-side
+// interface asynchronous: instead of returning received datagrams
+// immediately (from the `recv_frame` method), it stores them for
+// later retrieval. Otherwise, behaves identically to the underlying
+// implementation of NetworkInterface.
+class AsyncNetworkInterface : public NetworkInterface
+{
+  std::queue<InternetDatagram> datagrams_in_ {};
+
+public:
+  using NetworkInterface::NetworkInterface;
+
+  // Construct from a NetworkInterface
+  explicit AsyncNetworkInterface( NetworkInterface&& interface ) : NetworkInterface( interface ) {}
+
+  // \brief Receives and Ethernet frame and responds appropriately.
+
+  // - If type is IPv4, pushes to the `datagrams_out` queue for later retrieval by the owner.
+  // - If type is ARP request, learn a mapping from the "sender" fields, and send an ARP reply.
+  // - If type is ARP reply, learn a mapping from the "target" fields.
+  //
+  // \param[in] frame the incoming Ethernet frame
+  void recv_frame( const EthernetFrame& frame )
+  {
+    auto optional_dgram = NetworkInterface::recv_frame( frame );
+    if ( optional_dgram.has_value() ) {
+      datagrams_in_.push( std::move( optional_dgram.value() ) );
+    }
+  };
+
+  // Access queue of Internet datagrams that have been received
+  std::optional<InternetDatagram> maybe_receive()
+  {
+    if ( datagrams_in_.empty() ) {
+      return {};
+    }
+
+    InternetDatagram datagram = std::move( datagrams_in_.front() );
+    datagrams_in_.pop();
+    return datagram;
+  }
+};
+
+// A router that has multiple network interfaces and
+// performs longest-prefix-match routing between them.
+class Router
+{
+  // The router's collection of network interfaces
+  std::vector<AsyncNetworkInterface> interfaces_ {};
+
+public:
+  // Add an interface to the router
+  // interface: an already-constructed network interface
+  // returns the index of the interface after it has been added to the router
+  size_t add_interface( AsyncNetworkInterface&& interface )
+  {
+    interfaces_.push_back( std::move( interface ) );
+    return interfaces_.size() - 1;
+  }
+
+  // Access an interface by index
+  AsyncNetworkInterface& interface( size_t N ) { return interfaces_.at( N ); }
+
+  // Add a route (a forwarding rule)
+  void add_route( uint32_t route_prefix,
+                  uint8_t prefix_length,
+                  std::optional<Address> next_hop,
+                  size_t interface_num );
+
+  // Route packets between the interfaces. For each interface, use the
+  // maybe_receive() method to consume every incoming datagram and
+  // send it on one of interfaces to the correct next hop. The router
+  // chooses the outbound interface and next-hop as specified by the
+  // route with the longest prefix_length that matches the datagram's
+  // destination address.
+  void route();
+};

tests/CMakeLists.txt

@@ -69,5 +69,7 @@ add_test_exec(send_extra)
 
 add_test_exec(net_interface)
 
+add_test_exec(router)
+
 add_speed_test(byte_stream_speed_test)
 add_speed_test(reassembler_speed_test)

tests/net_interface.cc

@@ -27,7 +27,7 @@ InternetDatagram make_datagram( const string& src_ip, const string& dst_ip ) //
   dgram.header.src = Address( src_ip, 0 ).ipv4_numeric();
   dgram.header.dst = Address( dst_ip, 0 ).ipv4_numeric();
   dgram.payload.emplace_back( "hello" );
-  dgram.header.len = static_cast<uint64_t>( dgram.header.hlen ) * 4 + dgram.payload.size();
+  dgram.header.len = static_cast<uint64_t>( dgram.header.hlen ) * 4 + dgram.payload.front().size();
   dgram.header.compute_checksum();
   return dgram;
 }

tests/network_interface_test_harness.hh

@@ -135,14 +135,23 @@ struct Tick : public Action<NetworkInterface>
   explicit Tick( const size_t ms ) : _ms( ms ) {}
 };
 
+inline std::string concat( std::vector<Buffer>& buffers )
+{
+  return std::accumulate(
+    buffers.begin(), buffers.end(), std::string {}, []( const std::string& x, const Buffer& y ) {
+      return x + static_cast<std::string>( y );
+    } );
+}
+
 inline std::string summary( const EthernetFrame& frame )
 {
   std::string out = frame.header.to_string() + ", payload: ";
   switch ( frame.header.type ) {
     case EthernetHeader::TYPE_IPv4: {
       InternetDatagram dgram;
       if ( parse( dgram, frame.payload ) ) {
-        out.append( "IPv4: " + dgram.header.to_string() );
+        out.append( "IPv4: " + dgram.header.to_string() + " payload=\""
+                    + Printer::prettify( concat( dgram.payload ) ) + "\"" );
       } else {
         out.append( "bad IPv4 datagram" );
       }