一、实验目的

完成一个网络接口实现。

二、实验内容

完成一个网络接口实现，其大部分工作是：为每个下一跳IP地址查找(和缓存)以太网地址。而这种协议被称为地址解析协议ARP。

三、实验过程

在minnow目录下输入git merge origin/check4-startercode获取Lab4

用文本编辑器打开./src/network_interface.hh

修改代码

用文本编辑器打开./src/network_interface.cc

修改代码

在build目录下输入make进行编译

输入make check4进行测试

测试成功，实验结束。

四、实验体会

1.在实现整个网络接口时，必须确保几点：

①ARP条目 TTL 为30s，时间到期后需要将其从 ARP Table 中删除。

若发送 IP 报文时，发现 ARP Table 中无目标 MAC 地址，则立即发送 ARP 请求报文，同时将当前 IP 报文暂时缓存，直至获取到目标 MAC 地址后再重新发送。

②不同目标 IP 的 ARP 请求报文之间的发送间隔，不能超过 5s。

③如果 ARP 请求报文在 5 秒内仍然无响应，则重新发送。

④当网络接口接收到一个以太网帧时，

必须丢弃目的 MAC 地址不为当前网络接口 MAC 地址

除了 ARP 协议需要比较自己的 IP 地址以外，不要在其他任何地方进行 IP 比较，因为网络接口位于链路层。

如果是发给自己的 ARP 请求，那么要忽略掉发送来的 ARPMessage::target_ethernet_address，因为发送者自己也不知道这个要填写什么，该字段无意义。

无论接收到的是 ARP 请求包或者 ARP 响应包，只要是明确发给自己的，那么这里面的 src_ip_addr 和 src_eth_addr 都可用于更新当前的 ARP 表。

2.如何理解NetworkInterface：

①一个将IP（互联网层或网络层）与以太网（网络访问层或链路层）连接的"网络接口"，该模块是TCP/IP协议栈的最底层（连接IP与更底层的网络协议，如以太网），但同样的模块也作为路由器的一部分反复使用；

②路由器通常有许多网络接口，其工作是在不同的接口之间路由互联网数据报，网络接口将来自"客户端"（例如TCP/IP协议栈或路由器）的数据报转换为以太网帧。为了填写以太网的目标地址，它查找每个数据报的下一个IP跳的以太网地址，并使用地址解析协议ARP进行请求。在相反的方向，网络接口接受以太网帧，检查它们是否是针对它的，如果是，则根据其类型处理有效载荷。

如果是IPv4数据报，网络接口将其向上传递到协议栈。

如果是ARP请求或回复，网络接口将处理该帧，并根据需要进行学习或回复。

五、代码附录

network_interface.hh

#pragma once#include "address.hh"
#include "ethernet_frame.hh"
#include "ipv4_datagram.hh"#include <iostream>
#include <list>
#include <optional>
#include <queue>
#include <unordered_map>
#include <utility>// A "network interface" that connects IP (the internet layer, or network layer)
// with Ethernet (the network access layer, or link layer).// This module is the lowest layer of a TCP/IP stack
// (connecting IP with the lower-layer network protocol,
// e.g. Ethernet). But the same module is also used repeatedly
// as part of a router: a router generally has many network
// interfaces, and the router's job is to route Internet datagrams
// between the different interfaces.// The network interface translates datagrams (coming from the
// "customer," e.g. a TCP/IP stack or router) into Ethernet
// frames. To fill in the Ethernet destination address, it looks up
// the Ethernet address of the next IP hop of each datagram, making
// requests with the [Address Resolution Protocol](\ref rfc::rfc826).
// In the opposite direction, the network interface accepts Ethernet
// frames, checks if they are intended for it, and if so, processes
// the the payload depending on its type. If it's an IPv4 datagram,
// the network interface passes it up the stack. If it's an ARP
// request or reply, the network interface processes the frame
// and learns or replies as necessary.
class NetworkInterface
{
private:// Ethernet (known as hardware, network-access, or link-layer) address of the interfaceEthernetAddress ethernet_address_;// IP (known as Internet-layer or network-layer) address of the interfaceAddress ip_address_;std::queue<EthernetFrame> send_frame_{};std::unordered_map<uint32_t, std::queue<InternetDatagram>> store_dgram_{};//std::queue<std::pair<InternetDatagram, Address>> store_dgram_{};//这里key值不能选Address，它没有拷贝构造函数，=重载std::unordered_map<uint32_t, std::pair<EthernetAddress, size_t>> map_ip2mac_{};std::unordered_map<uint32_t,size_t> map_arp_time_{};public:// Construct a network interface with given Ethernet (network-access-layer) and IP (internet-layer)// addressesNetworkInterface( const EthernetAddress& ethernet_address, const Address& ip_address );// Access queue of Ethernet frames awaiting transmissionstd::optional<EthernetFrame> maybe_send();// Sends an IPv4 datagram, encapsulated in an Ethernet frame (if it knows the Ethernet destination// address). Will need to use [ARP](\ref rfc::rfc826) to look up the Ethernet destination address// for the next hop.// ("Sending" is accomplished by making sure maybe_send() will release the frame when next called,// but please consider the frame sent as soon as it is generated.)void send_datagram( const InternetDatagram& dgram, const Address& next_hop );// Receives an Ethernet frame and responds appropriately.// If type is IPv4, returns the datagram.// 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 "sender" fields.std::optional<InternetDatagram> recv_frame( const EthernetFrame& frame );// Called periodically when time elapsesvoid tick( size_t ms_since_last_tick );
};

network_interface.cc

#include "network_interface.hh"#include "arp_message.hh"
#include "ethernet_frame.hh"using namespace std;// ethernet_address: Ethernet (what ARP calls "hardware") address of the interface
// ip_address: IP (what ARP calls "protocol") address of the interface
NetworkInterface::NetworkInterface( const EthernetAddress& ethernet_address, const Address& ip_address ): ethernet_address_( ethernet_address ), ip_address_( ip_address )
{cerr << "DEBUG: Network interface has Ethernet address " << to_string( ethernet_address_ ) << " and IP address "<< ip_address.ip() << "\n";
}// dgram: the IPv4 datagram to be sent
// next_hop: the IP address of the interface to send it to (typically a router or default gateway, but
// may also be another host if directly connected to the same network as the destination)// Note: the Address type can be converted to a uint32_t (raw 32-bit IP address) by using the
// Address::ipv4_numeric() method.
void NetworkInterface::send_datagram( const InternetDatagram& dgram, const Address& next_hop )
{//以太网帧可以携带Internetdatagram，也可以携带arpmessage//(void)dgram;//(void)next_hop;uint32_t target_ip = next_hop.ipv4_numeric();//uint32_t source_address = dgram.header.src;//uint32_t destination_address = dgram.header.dst;//发送到next_hop, 而不是dgram的dstauto it = map_ip2mac_.find(target_ip);//nexthop的以太网地址已知，封装dgram发送if(it!=map_ip2mac_.end()){EthernetFrame send_frame{{it->second.first, ethernet_address_, EthernetHeader::TYPE_IPv4},serialize(dgram)};//send_frame.header.dst = it->second.first;send_frame_.push(send_frame);return;}//nexthop的以太网地址未知，如果没发过arp就发request arp，把dgram缓存起来if(map_arp_time_.find(target_ip)==map_arp_time_.end()){ARPMessage arp_send;arp_send.opcode = ARPMessage::OPCODE_REQUEST;arp_send.sender_ethernet_address = ethernet_address_;arp_send.sender_ip_address = ip_address_.ipv4_numeric();arp_send.target_ip_address = target_ip;EthernetFrame send_frame{{ETHERNET_BROADCAST, ethernet_address_, EthernetHeader::TYPE_ARP}, serialize(arp_send)};send_frame_.push(send_frame);map_arp_time_.insert(make_pair(target_ip, 0));//发完arp之后加入到map里面记录下来}//缓存dgramauto it_store_dgram = store_dgram_.find(target_ip);if(it_store_dgram == store_dgram_.end()){std::queue<InternetDatagram> q_dgram;store_dgram_.insert(make_pair(target_ip, q_dgram));//store_dgram_[target_ip].push(dgram);}store_dgram_[target_ip].push(dgram);return;
}// frame: the incoming Ethernet frame
optional<InternetDatagram> NetworkInterface::recv_frame( const EthernetFrame& frame )
{if(frame.header.dst!=ethernet_address_ && frame.header.dst!=ETHERNET_BROADCAST)return{};//有点疑惑为什么会出现这种发错的情况，但是测试样例里面有一个这样的例子//(void)frame;//收到arp，两种情况，收到的是request或者replyif(frame.header.type==EthernetHeader::TYPE_ARP){ARPMessage rec_arp;parse(rec_arp, frame.payload);map_ip2mac_.insert(make_pair(rec_arp.sender_ip_address, make_pair(rec_arp.sender_ethernet_address, 0)));//收到的是request，如果request的是自己的以太网地址，就发送一个reply的arpmessage，发送给request方if(rec_arp.opcode==ARPMessage::OPCODE_REQUEST){if(rec_arp.target_ip_address == ip_address_.ipv4_numeric()){ARPMessage arp_reply;arp_reply.opcode = ARPMessage::OPCODE_REPLY;arp_reply.sender_ethernet_address = ethernet_address_;arp_reply.sender_ip_address = ip_address_.ipv4_numeric();arp_reply.target_ethernet_address = rec_arp.sender_ethernet_address;arp_reply.target_ip_address = rec_arp.sender_ip_address;EthernetFrame reply_frame{{rec_arp.sender_ethernet_address, ethernet_address_, EthernetHeader::TYPE_ARP},serialize(arp_reply)};send_frame_.push(reply_frame);return{};}else return{};}//收到arp之后，无论arp是reply还是request都检查一下有没有可以发送的dgramauto it = store_dgram_.find(rec_arp.sender_ip_address);if(it!=store_dgram_.end()){while(it->second.empty()==false){InternetDatagram dgram = it->second.front();it->second.pop();EthernetFrame send_frame{{rec_arp.sender_ethernet_address, ethernet_address_,EthernetHeader::TYPE_IPv4},serialize(dgram)};send_frame_.push(send_frame);}if(it->second.empty()) store_dgram_.erase(it);}}//frame携带的是internetdatagramelse if(frame.header.type==EthernetHeader::TYPE_IPv4){InternetDatagram dgram;parse(dgram, frame.payload);return dgram;}return {};
}// ms_since_last_tick: the number of milliseconds since the last call to this method
void NetworkInterface::tick( const size_t ms_since_last_tick )
{for(auto it = map_ip2mac_.begin();it!=map_ip2mac_.end();){it->second.second += ms_since_last_tick;if(it->second.second >= 30000)it=map_ip2mac_.erase(it);else it++;}for(auto it = map_arp_time_.begin(); it!=map_arp_time_.end();){it->second += ms_since_last_tick;if(it->second>=5000) it=map_arp_time_.erase(it);else it++;}//for(auto it = map)//(void)ms_since_last_tick;
}optional<EthernetFrame> NetworkInterface::maybe_send()
{if(!send_frame_.empty()){auto frame = send_frame_.front();send_frame_.pop();return {frame};}else return{};
}