CS 144 Lab Six -- building an IP router

class AsyncNetworkInterface : public NetworkInterface {
    std::queue<InternetDatagram> _datagrams_out{};

  public:
    using NetworkInterface::NetworkInterface;

    //! Construct from a NetworkInterface
    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);
        // 只会将IPV4数据报放入数据报接收队列中
        if (optional_dgram.has_value()) {
            _datagrams_out.push(std::move(optional_dgram.value()));
        }
    };

    //! Access queue of Internet datagrams that have been received
    std::queue<InternetDatagram> &datagrams_out() { return _datagrams_out; }
};

//! \brief 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{};

    //! Send a single datagram from the appropriate outbound interface to the next hop,
    //! as specified by the route with the longest prefix_length that matches the
    //! datagram's destination address.
    // 路由一个IP数据报
    void route_one_datagram(InternetDatagram &dgram);

    // 路由表条目
    struct RouterTableEntry {
        // 路由前缀
        const uint32_t route_prefix;
        // 前缀长度
        const uint8_t prefix_length;
        // 下一跳的IP地址
        const std::optional<Address> next_hop;
        // 对应哪一个网络接口
        const size_t interface_idx;
    };
    // 路由表
    std::vector<RouterTableEntry> _router_table{};

  public:
    //! Add an interface to the router
    //! \param[in] 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(const size_t N) { return _interfaces.at(N); }

    //! Add a route (a forwarding rule)
    // 增加路由条目
    void add_route(const uint32_t route_prefix,
                   const uint8_t prefix_length,
                   const std::optional<Address> next_hop,
                   const size_t interface_num);

    //! Route packets between the interfaces
    void route();
};

// 向路由表中添加路由条目
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() << "/" << int(prefix_length)
         << " => " << (next_hop.has_value() ? next_hop->ip() : "(direct)") << " on interface " << interface_num << "\n";

    _router_table.push_back({route_prefix, prefix_length, next_hop, interface_num});
}

//! \param[in] dgram The datagram to be routed
// 根据路由表进行路由
void Router::route_one_datagram(InternetDatagram &dgram) {
    // 获取目的ip地址
    const uint32_t dst_ip_addr = dgram.header().dst;
    auto max_matched_entry = _router_table.end();
    // 开始查询
    for (auto router_entry_iter = _router_table.begin(); router_entry_iter != _router_table.end();
         router_entry_iter++) {
        // 如果前缀匹配匹配长度为 0，或者前缀匹配相同
        if (router_entry_iter->prefix_length == 0 ||
            (router_entry_iter->route_prefix ^ dst_ip_addr) >> (32 - router_entry_iter->prefix_length) == 0) {
            // 如果条件符合，则更新最匹配的条目
            if (max_matched_entry == _router_table.end() ||
                max_matched_entry->prefix_length < router_entry_iter->prefix_length)
                max_matched_entry = router_entry_iter;
        }
    }
    // 将数据包 TTL 减去1
    // 如果存在最匹配的，并且数据包仍然存活，则将其转发
    if (max_matched_entry != _router_table.end() && dgram.header().ttl-- > 1) {
        // 获取下一条IP地址
        const optional<Address> next_hop = max_matched_entry->next_hop;
        // 获取对应的网络接口
        AsyncNetworkInterface &interface = _interfaces[max_matched_entry->interface_idx];
        // 目标主机是否位于与路由器相同的网络中。
        // 在这种情况下，下一跳字段可能为空，因为目标主机可以直接通过局域网访问，无需经过路由器。
        if (next_hop.has_value())
            // 交给NetworkInterface,将这个数据报发送出去
            interface.send_datagram(dgram, next_hop.value());
        else
            // 目的主机与路由器位于相同的网络中
            interface.send_datagram(dgram, Address::from_ipv4_numeric(dst_ip_addr));
    }
    // 其他情况下则丢弃该数据包
}

void Router::route() {
    // Go through all the interfaces, and route every incoming datagram to its proper outgoing interface.
    // 依次遍历当前路由器内部每个网络接口,依次取出每个AsyncNetworkInterface的待传输队列datagrams_out
    for (auto &interface : _interfaces) {
        auto &queue = interface.datagrams_out();
        // 如果待路由队列不为空,则依次取出进行路由
        while (not queue.empty()) {
            route_one_datagram(queue.front());
            queue.pop();
        }
    }
}