NFD无线传输修改

修改NFD支持无线传输

想要将NFD改成无线模式有两种方式，一种是为无线网卡配置adhoc模式，通过网卡实现的802.11链路层的协议，以及相关的帧交换，用户端在使用时只需要构造出想要发送的数据并发送到网卡即可。另外一种是将网卡配置为monitor模式，这样就需要自己为发送的数据包添加字段，构造为符合802.11协议的数据包。

方法一：配置adhoc模式

将无线网卡配置adhoc模式，这种方式改动量很小，只需要将网卡配置为adhoc模式，网卡全权负责数据包帧格式的转换。配置adhoc模式的方法为：

nic_name=$1
ch_number=$2
sudo ip link set $nic_name down
sudo iwconfig $nic_name mode ad-hoc
sudo iwconfig $nic_name essid 'sdr-ad-hoc'
sudo ip link set $nic_name up
sudo iwconfig $nic_name channel $ch_number

执行脚本时需要输入网卡名和信道号，测试时采取的是13信道(2.472GHz)，干扰相对较小。如果两个网卡在配置完adhoc模式后分到了一个cell里，则配置成功。

由于网卡负责后序对包的帧结构进行处理，配置成功后不需要修改NFD和ndn-cxx的源码，直接可以发送成功。发送的包在wireshark中的显示和实际发送的数据内容相同。

但是如果是在监听模式下，收到的包会增加其他的字段。

此外，其他网卡启动monitor模式监测信道中的包时，会发现每节点每秒中会有大约10个广播包(wireshark抓包结果，不排除同一个包显示了多次的可能性)，猜测广播包的作用是进行链路层的探测。探测包的结构如下：

测试了一下将目标MAC地址和NLSR配置变成全F，wireshark能抓到包，但是无法正常解析。正确的做法应该是NLSR配置实际的网卡MAC地址，配置face时设置为全F。但是此时NLSR里配置的邻居的MAC地址和全F不符，需要修改NLSR代码。

修改目标地址为广播需要将NFD的ethernet-factory.cpp的187-190行对多播的判断注释掉。

if (remoteEndpoint.isMulticast()) {
  NFD_LOG_TRACE("createFace does not support multicast faces");
  onFailure(406, "Cannot create multicast Ethernet faces");
  return;
}

方法二：配置monitor模式

将无线网卡都配置成monitor模式，在这种模式下，需要自己对数据包的帧结构进行调整，网卡只负责收发数据，不修改帧结构。因此此模式下需要修改NFD收发包过程。

配置monitor模式：

sudo ifconfig wlp0s20f3 down
sudo iw dev wlp0s20f3 set type monitor
sudo ifconfig wlp0s20f3 up
iwconfig

修改NFD代码：

1. 修改对接口状态的判断

首先，网卡为monitor模式时，会将网卡的状态设置为NO_CARRIER，在ndn-cxx的network-monitor-impl-netlink.cpp中，强制将其跳过，另外忽略OPER_STATE_DORMANT。还需要将解析链路状态的unknown忽略

static void
updateInterfaceState(NetworkInterface& interface, uint8_t operState)
{
  if (operState == linux_if::OPER_STATE_UP) {
    interface.setState(InterfaceState::RUNNING);
  }
  else if (operState == linux_if::OPER_STATE_DORMANT) {
    interface.setState(InterfaceState::RUNNING);
    // interface.setState(InterfaceState::DORMANT);
  }
  else {
    // fallback to flags
    auto flags = interface.getFlags();
    if(flags == 4099 || flags == 4098)
      flags = 65609;
    NDN_LOG_INFO(flags);
    if ((flags & linux_if::FLAG_LOWER_UP) && !(flags & linux_if::FLAG_DORMANT))
      interface.setState(InterfaceState::RUNNING);
    else if (flags & IFF_UP)
      interface.setState(InterfaceState::NO_CARRIER);
    else
      interface.setState(InterfaceState::DOWN);
  }
}

void
NetworkMonitorImplNetlink::parseLinkMessage(const NetlinkMessage& nlmsg)
{
   // if (ifiTypeToInterfaceType(ifi->ifi_type) == InterfaceType::UNKNOWN) {
  //   NDN_LOG_DEBUG("  unhandled interface type " << ifi->ifi_type);
  //   return;
  // }   
}

2. 修改创建信道时的判断

注释掉EthernetFactory::applyUnicastConfigToNetif和EthernetFactory::applyMcastConfigToNetif

函数对以太网face的判断

shared_ptr<EthernetChannel>
EthernetFactory::applyUnicastConfigToNetif(const shared_ptr<const ndn::net::NetworkInterface>& netif)
{
      // if (netif->getType() != ndn::net::InterfaceType::ETHERNET) {
  //   NFD_LOG_DEBUG("Not creating channel on " << netif->getName() << ": incompatible netif type");
  //   return nullptr;
  // }
}
shared_ptr<Face>
EthernetFactory::applyMcastConfigToNetif(const ndn::net::NetworkInterface& netif)
{
      // if (netif.getType() != ndn::net::InterfaceType::ETHERNET) {
  //   NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": incompatible netif type");
  //   return nullptr;
  // }
}

3.修改对网卡数据链路层的判断

原来的NFD限制了链路层必须为DLT_EN10MB类型，现在改为了获取网卡的链路层类型，再执行原来的处理。PcapHelper::newactivate()在activate函数的基础上加了获取网卡的链路层类型的功能。

  try {
    // m_pcap.activate(DLT_EN10MB);
    m_pcap.newactivate();
    m_socket.assign(m_pcap.getFd());
  }

void
PcapHelper::newactivate()
{
  PrivilegeHelper::runElevated([this] {
    int ret = pcap_activate(m_pcap);
    if (ret < 0)
      NDN_THROW(Error("pcap_activate: " + std::string(pcap_statustostr(ret))));
  });

  // 获取数据链路层类型
  int datalink = pcap_datalink(m_pcap);
  std::cout << "datalink= " << pcap_datalink_val_to_name(datalink) << std::endl;
  if (pcap_set_datalink(m_pcap, datalink) < 0)
    NDN_THROW(Error("pcap_set_datalink: " + getLastError()));

  if (pcap_setdirection(m_pcap, PCAP_D_IN) < 0)
    NDN_THROW(Error("pcap_setdirection: " + getLastError()));
}

4. 修改发包流程

本质上就是构造出完整的IEEE802.11帧结构，参考了ndnSIM仿真中的包结构，修改ethernet-transport.cpp，加入了radiotap，durationtime，LLC子层，FCS等字段。

原来的帧结构：（目的地址，源地址，协议类型(0x8624)，NDN包）

现在的帧结构：（radiotap，durationtime，目的地址，源地址，LLC子层，协议类型，NDN包，FCS）

void
EthernetTransport::sendPacket(const ndn::Block& block)
{
  ndn::EncodingBuffer buffer(block);
  // 构造 Radiotap 头
  radiotap_header radiotapHeader;
  radiotapHeader.header_revision = {0};
  radiotapHeader.header_pad = {0};
  radiotapHeader.header_length = {0x16, 0};  // 小端
  radiotapHeader.present_flags = {0x0f, 0, 0, 0, 0x6a, 0x27, 0, 0, 0, 0, 0, 0, 0x10, 0x6c, 0xa8, 0x09, 0xc0, 0x00, 0x88, 0};
  // ... 设置其他 Radiotap 字段
  // 计算 Radiotap 头的长度
  std::array<uint8_t, 2> durationtime;
  durationtime = {0, 1};    // 小端
  std::array<uint8_t, 16> LLClayer;
  LLClayer = {0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0xaa, 0xaa, 0x03, 0, 0, 0};    // 小端
  // 计算新的以太网帧的长度
  // pad with zeroes if the payload is too short
  if (block.size() < ethernet::MIN_DATA_LEN) {
    static const uint8_t padding[ethernet::MIN_DATA_LEN] = {};
    buffer.appendByteArray(padding, ethernet::MIN_DATA_LEN - block.size());
  }
  //添加FCS
  std::array<uint8_t, 4> FCS;
  FCS = {0,0,0,0};
  buffer.appendByteArray(FCS.data(), FCS.size());
  // construct and prepend the ethernet header
  uint16_t ethertype = boost::endian::native_to_big(ethernet::ETHERTYPE_NDN);
  buffer.prependByteArray(reinterpret_cast<const uint8_t*>(&ethertype), ethernet::TYPE_LEN);
  //添加LLClayer
  buffer.prependByteArray(LLClayer.data(), LLClayer.size());
  buffer.prependByteArray(m_srcAddress.data(), m_srcAddress.size());
  buffer.prependByteArray(m_destAddress.data(), m_destAddress.size());
  //添加durationtime
  buffer.prependByteArray(durationtime.data(), durationtime.size());  //01 00
  //添加radiotapHeader
  buffer.prependByteArray(radiotapHeader.present_flags.data(), radiotapHeader.present_flags.size());  //00 00 00 00 00 00
  buffer.prependByteArray(radiotapHeader.header_length.data(), radiotapHeader.header_length.size());  //00 08
  buffer.prependByteArray(radiotapHeader.header_pad.data(), radiotapHeader.header_pad.size());  //00
  buffer.prependByteArray(radiotapHeader.header_revision.data(), radiotapHeader.header_revision.size());  //00
  // send the frame
  int sent = pcap_inject(m_pcap, buffer.buf(), buffer.size());
  if (sent < 0)
    handleError("Send operation failed: " + m_pcap.getLastError());
  else if (static_cast<size_t>(sent) < buffer.size())
    handleError("Failed to send the full frame: size=" + to_string(buffer.size()) +
                " sent=" + to_string(sent));
  else
    // print block size because we don't want to count the padding in buffer
    NFD_LOG_FACE_TRACE("Successfully sent: " << block.size() << " bytes");
}

构造后的包在wireshark中抓包如下：

5. 修改收包流程

首先需要修改接收到包对收发地址和协议类型的判断，在ethernet-protocal.cpp中

std::pair<const ether_header*, std::string>
checkFrameHeader(const uint8_t* packet, size_t length,
                 const Address& localAddr, const Address& destAddr)
{
    ether_header* eh = new ether_header();
    size_t lengthRadiotap = packet[2] + 4;
    size_t lengthethaddr = 12;
    size_t LLClen = 16;
    std::cout << "lengthRadiotap=" << lengthRadiotap;
    for(size_t i = 0; i < 6; i++) {
      eh->ether_dhost[i] = packet[lengthRadiotap + i];
      printf("%02x ", eh->ether_dhost[i]);
    }
    std::cout << std::endl;
    for(size_t i = 0; i < 6; i++) {
      eh->ether_shost[i] = packet[lengthRadiotap + 6 + i];
      printf("%02x ", eh->ether_shost[i]);
    }
    std::cout << std::endl;
    for(size_t i = 0; i < 2; i++) {
      printf("%02x ", packet[lengthRadiotap + lengthethaddr + LLClen + i]);
    }
    std::cout << std::endl;
    eh->ether_type = static_cast<uint16_t>(packet[lengthRadiotap + lengthethaddr + LLClen] << 8) | packet[lengthRadiotap + lengthethaddr + LLClen + 1];
    // in some cases VLAN-tagged frames may survive the BPF filter,
    // make sure we do not process those frames (see #3348)
    //uint16_t ethertype = boost::endian::big_to_native(eh->ether_type);
    uint16_t ethertype = eh->ether_type;
}

最后是修改ethernet-transport的收包流程，收包时跳过对应的帧头字段。

void
EthernetTransport::handleRead(const boost::system::error_code& error)
{
	  // pkt += ethernet::HDR_LEN;
      // len -= ethernet::HDR_LEN;
      pkt += pkt[2] + 4 + 12 + 16 + 2;  // radiotap(pkt[2] + 4), macaddr(12), LLC(16), type(2)
      len -= pkt[2] + 4 + 12 + 16 + 2 + 4; // radiotap(pkt[2] + 4), macaddr(12), LLC(16), type(2), FCS(4)
}