【lwip】08-ARP协议一图笔记及源码实现

前言
8.1 IP地址与MAC地址
8.2 ARP协议简介
8.3 ARP协议报文
8.4 ARP缓存表
8.5 ARP协议超时机制框图
8.6 ARP收发报文数据流图
8.7 ARP报文组包源码实现
8.8 数据包发送分析
8.9 数据包接收分析
8.10 LWIP ARP一图笔记

前言

主要简述TCPIP协议族相关的。

ARP协议源码在etharp.c和etharp.h中，也是本次笔记的主要内容。

ARP源码实现的重要数据结构：

ARP缓存表。
ARP报文。

原文：李柱明博客

8.1 IP地址与MAC地址

TCP/IP协议的网络层有自己的IP地址。

单看网络层，传输数据包时只需要知道目标主机的IP地址即可。

但是网络层数据包下传到链路层时，链路层需要知道下一个节点的MAC地址，才能发包。

为了实现网络层对MAC地址无感，又能实现数据包收发，就需要把IP地址和MAC地址绑定。

一个网卡，有IP地址，而网卡对接物理设备时，物理设备有MAC地址，可以把IP地址和网卡设备MAC地址绑定。

而有时候，IP地址可能是动态的，即是当前网卡设备根据需求被赋予不同的IP，所以IP地址与MAC地址映射也需要动态才能更好地把网络层和链路层分割。

8.2 ARP协议简介

地址解析协议，即ARP（Address Resolution Protocol），是根据IP地址获取物理地址的一个TCP/IP协议。

主机A知道主机B的ip地址，但是在二层链路，也就是数据链路层，是通过mac地址进行转发的，通过ARP协议实现IP和MAC地址绑定。

ARP协议有静态获取和动态获取：

静态获取：即是手动配置ARP映射表。
动态获取：主机通过ARP协议主机获取、主机维护ARP映射表。

8.3 ARP协议报文

ARP请求和应答分组的格式如图：

以太网首部：

目的MAC（6）：链路层的数据帧的下一个目标结点设备的MAC。当携带ARP请求报文时，以太网目的地址MAC为广播地址：0xFFFFFF。
源MAC（6）：当前设备的MAC。
帧类型（2）：为0x0806时，表示ARP报文。

ARP报文：

硬件类型（2）：硬件地址的类型。
- 为1即表示以太网地址。
- 其它还能表示令牌环地址等。
协议类型（2）：表示硬件地址要映射的协议地址类型。
- 0x0800表示IP地址。
- 其它还能表示ICMP/IGMP等。
硬件地址长度（1）：硬件地址的长度，以字节为单位。
- 以太网上IP地址的ARP请求或应答：该字段为MAC地址的长度，6。
协议地址长度（1）：
- 以太网上IP地址的ARP请求或应答：该字段为IP地址长度，4。
OP字段（2）：操作字段。
- 1：ARP请求。
- 2：ARP应答。
- 3：RARP请求。
- 4：RARP应答。
发送端以太网地址（6）。
发送端IP地址（4）。
目的以太网地址（6）。
目的IP地址（4）。

小笔记：

看到上述的报文简述后，会发现以太网的数据帧首部和ARP请求数据报中都有发送端的硬件地址。这个很正常，因为两者所处的OSI层级不一样，前者是链路层处理的数据帧头需要的硬件地址。后者是网络层处理的ARP请求数据报中的重要信息。
ARP请求有些信息会留空，如ARP请求时，目的端的硬件地址不需要填充。而协议中保留，是为了实现ARP请求和ARP应答的报文字段一致。

ARP简要交互：

对于一个ARP请求来说，除目的端硬件地址外的所有其他的字段都有填充值。

当系统收到一份目的端为本机的ARP请求报文后，它就把硬件地址填进去，然后用两个目的端地址分别替换两个发送端地址，并把操作字段置为2（ARP应答），最后把它发送回去。

ARP交互报文例子图，wireshark分析：

8.4 ARP缓存表

8.4.1 ARP缓存表简介

每台主机或路由器在其内存中具有一个ARP缓存表（ARP table），这张表包含IP地址到MAC地址的映射关系。

网络层的IP数据包需要经过链路层转发时，可以直接查询缓存表是否有这个IP映射的MAC。

如果有，目标链路层数据帧的目标MAC就直接使用这个MAC，就能转发了。

如果没有，通过ARP协议，往链路层局域网内广播一下，询问下有没有这个IP对应的结点设备，如果有就把这个IP对应的链路层设备的MAC返回到这个主机，然后这个主机的链路层使用这个MAC发送数据帧出去。而且可以把这个MAC及其对应的IP保存到自己的ARP缓存表中，方便下次直接使用。当然，这个映射也有过期检查，需要超时机制维护。

8.4.2 LWIP中的缓存表

lwip的缓存表：static struct etharp_entry arp_table[ARP_TABLE_SIZE];

ARP_TABLE_SIZE默认为10，即是默认能缓存10条ARP映射记录。

8.4.3 ARP缓存表数据结构

struct etharp_entry：

struct etharp_entry {
#if ARP_QUEUEING
  /* 指向此ARP表项上挂起的数据包队列的指针. */
  struct etharp_q_entry *q;
#else /* ARP_QUEUEING */
  /* 指向此ARP表项上的单个挂起的数据包队列的指针 */
  struct pbuf *q;
#endif /* ARP_QUEUEING */
  /* 目标IP地址 */
  ip4_addr_t ipaddr;
  /* 当前ARP映射记录对应网卡信息 */
  struct netif *netif;
  /* 目标IP对应的MAC地址 */
  struct eth_addr ethaddr;
  /* 当前netry的生存时间 */
  u16_t ctime;
  /* 当前netry的状态信息 */
  u8_t state;
};

8.4.4 ARP缓存表数据缓冲队列

struct etharp_q_entry *q;：

这个字段用于指向缓存表的数据包缓冲队列。

在IP层发送一个数据包时，会先在ARP映射表中查找与目的IP地址对应的MAC地址，这样才能封装以太网帧，才能在链路层把数据包发送出去。

但是如果IP层发送一个数据包时，在ARP映射表中查不到对应的硬件地址MAC，就发送一个ARP请求包，在请求过程中，把这个IP层的数据包缓存到这个队列q先，直到请求成功后，获取这个IP层数据包IP对应的MAC地址或请求失败为止。

对于PBUFF_ERF、PBUF_POOL、PBUF_RAM类型的数据包是不允许直接挂到ARP entry的挂起缓存队列上的，因为内核等待目标主机的ARP应答期间，这些数据有可能会被上层改动，所以LwIP需要将这些pbuf数据包拷贝到新的空间，等待发送。

这个队列的数据结构：

在memp.h的MEMP_ARP_QUEUE内存池中有这个数据结构的内存资源。共有MEMP_NUM_ARP_QUEUE个，默认为30个。

#if ARP_QUEUEING
struct etharp_q_entry {
  struct etharp_q_entry *next; /* 下一个节点 */
  struct pbuf *p; /* pbuf */
};
#endif /* ARP_QUEUEING */

8.4.5 ARP缓存表entry状态信息

u8_t state;：

/** ARP states */
enum etharp_state {
  ETHARP_STATE_EMPTY = 0, /* 空闲态 */
  ETHARP_STATE_PENDING, /* pending态 */
  ETHARP_STATE_STABLE, /* 有效态 */
  ETHARP_STATE_STABLE_REREQUESTING_1, /* 有效过渡态1 */
  ETHARP_STATE_STABLE_REREQUESTING_2 /* 有效过渡态2 */
#if ETHARP_SUPPORT_STATIC_ENTRIES
  , ETHARP_STATE_STATIC /* 静态entry */
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
};

当前netry的状态信息：

ETHARP_STATE_EMPTY：空状态。当前entry资源无效，可以被填充使用。
ETHARP_STATE_PENDING：PENDING态。当前entry正在ARP请求，但是还没收到ARP响应。
ETHARP_STATE_STABLE：有效态。当前entry记录的IP地址与MAC地址映射有效。
ETHARP_STATE_STABLE_REREQUESTING_1：有效过渡态1。就是为了防止entry块过期前频繁发起ARP请求。
ETHARP_STATE_STABLE_REREQUESTING_2：有效过渡态2。
ETHARP_STATE_STATIC：静态条目。手动配置的ARP映射，一直有效。

当表项是ETHARP_STATE_STABLE的时候又发送一个ARP请求包，那么表项状态会暂时被设置为THARP_STATE_STABLE_REREQUESTING_1，然后被设置为ETHARP_STATE_STABLE_REREQUESTING_2状态，这些是一个过渡状态，当收到ARP应答后，表项又会被设置为ETHARP_STATE_STABLE，这样能保持表项的有效。

比如，每个IP层的数据包都会先遍历ARP缓存表，如果找到有效的条目后，直接使用该条目，然后会继续调用etharp_output_to_arp_index()把数据发送出去，源码如下：

在发送IP包时检查当前被使用的ARP entry是否块过期，如果快过期，需要发起ARP请求更新当前条目，更新有两种级别：
- ARP_AGE_REREQUEST_USED_UNICAST：默认在条目超时前30秒，发起单播级别的ARP请求，减少不必要的广播。
- ARP_AGE_REREQUEST_USED_BROADCAST：默认在条目超时前15秒，发起广播级别的ARP请求。

/* 为避免由于ARP表项超时导致稳定使用的连接中断，需要在ARP表项过期前重新请求，更新ARP缓存表 */
#define ARP_AGE_REREQUEST_USED_UNICAST   (ARP_MAXAGE - 30)
#define ARP_AGE_REREQUEST_USED_BROADCAST (ARP_MAXAGE - 15)

/* Just a small helper function that sends a pbuf to an ethernet address in the arp_table specified by the index 'arp_idx'. */
static err_t
etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, netif_addr_idx_t arp_idx)
{
  LWIP_ASSERT("arp_table[arp_idx].state >= ETHARP_STATE_STABLE",
              arp_table[arp_idx].state >= ETHARP_STATE_STABLE);
  /* 在entry快过期前，发起ARP请求进行更新。
    为了防止在这段时间频繁发起ARP请求，所以引入有效过渡态。
    这里为有效态才能发起ARP请求。 */
  if (arp_table[arp_idx].state == ETHARP_STATE_STABLE) {
    if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_BROADCAST) {
      /* 使用广播级别（过期前15秒），发起标准ARP请求 */
      if (etharp_request(netif, &arp_table[arp_idx].ipaddr) == ERR_OK) {
        arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; /* 更新为有效过渡态1 */
      }
    } else if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_UNICAST) {
      /* 发出单播ARP请求(过期前30秒)，以防止不必要的广播 */
      if (etharp_request_dst(netif, &arp_table[arp_idx].ipaddr, &arp_table[arp_idx].ethaddr) == ERR_OK) {
        arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; /* 更新为有效过渡态1 */
      }
    }
  }
  /* IP层发送数据 */
  return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP);
}

8.4.6 ARP缓存表超时处理

ARP缓存表每条映射记录都是有有效期的（静态除外），在struct etharp_entry的u16_t ctime;这个字段中记录这点钱entry的生存时间。

ARP超时处理函数是etharp_tmr()，是一个周期定时函数。

8.4.7 ARP缓存表entry更新

能触发ARP缓存表entry更新的情况：

ARP超时处理。把过期或者ARP请求超时的arp entry删除。
IP层发送数据。经过ARP协议时：
- arp entry更新：在对应arp entry快过期前发起ARP请求（更新arp entry）。
- arp entry新建：ARP缓存表中没有找到对应entry时，新建一个。

新建arp entry逻辑：

调用etharp_find_entry()函数获取一个entry。

该函数的参数u8_t flags;表示申请arp entry资源的方式：

ETHARP_FLAG_TRY_HARD：允许覆盖已有arp entry。
- 在需要新建arp entry，且没有发现空闲的arp entry时，强制覆盖一条。优先被覆盖的顺序：empty entry > oldest stable entry > oldest pending entry without queued packets > oldest pending entry with queued packets。
ETHARP_FLAG_FIND_ONLY：只读模式。如果ARP缓存表中没有匹配IP（和网卡）的arp entry，则返回失败，数据包处理终止。

8.5 ARP协议超时机制框图

8.6 ARP收发报文数据流图

8.7 ARP报文组包源码实现

8.7.1 ARP报文数据结构

/** the ARP message, see RFC 826 ("Packet format") */
struct etharp_hdr {
  PACK_STRUCT_FIELD(u16_t hwtype); /* 硬件类型 */
  PACK_STRUCT_FIELD(u16_t proto); /* 协议类型 */
  PACK_STRUCT_FLD_8(u8_t  hwlen); /* 硬件地址长度 */
  PACK_STRUCT_FLD_8(u8_t  protolen); /* 协议地址长度 */
  PACK_STRUCT_FIELD(u16_t opcode); /* 操作字段 */
  PACK_STRUCT_FLD_S(struct eth_addr shwaddr); /* 源硬件地址 */
  PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned sipaddr); /* 源协议地址 */
  PACK_STRUCT_FLD_S(struct eth_addr dhwaddr); /* 目标硬件地址 */
  PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned dipaddr); /* 目标协议地址 */
} PACK_STRUCT_STRUCT;

8.7.2 ARP报文组建发送函数（基函数）

ARP请求包是通过etharp_raw()函数进行组包和发送的，然后通过封装该函数得出不同需求的ARP请求函数供给上层使用。

/**
 * Send a raw ARP packet (opcode and all addresses can be modified)
 *
 * @param netif the lwip network interface on which to send the ARP packet
 * @param ethsrc_addr the source MAC address for the ethernet header
 * @param ethdst_addr the destination MAC address for the ethernet header
 * @param hwsrc_addr the source MAC address for the ARP protocol header
 * @param ipsrc_addr the source IP address for the ARP protocol header
 * @param hwdst_addr the destination MAC address for the ARP protocol header
 * @param ipdst_addr the destination IP address for the ARP protocol header
 * @param opcode the type of the ARP packet
 * @return ERR_OK if the ARP packet has been sent
 *         ERR_MEM if the ARP packet couldn't be allocated
 *         any other err_t on failure
 */
static err_t
etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
           const struct eth_addr *ethdst_addr,
           const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr,
           const struct eth_addr *hwdst_addr, const ip4_addr_t *ipdst_addr,
           const u16_t opcode)
{
  struct pbuf *p;
  err_t result = ERR_OK;
  struct etharp_hdr *hdr;

  LWIP_ASSERT("netif != NULL", netif != NULL);

  /* 链路层组包，为ARP报文申请内存资源 */
  p = pbuf_alloc(PBUF_LINK, SIZEOF_ETHARP_HDR, PBUF_RAM);
  if (p == NULL) { /* 内存资源申请失败 */
    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
                ("etharp_raw: could not allocate pbuf for ARP request.\n"));
    ETHARP_STATS_INC(etharp.memerr);
    return ERR_MEM;
  }
  LWIP_ASSERT("check that first pbuf can hold struct etharp_hdr",
              (p->len >= SIZEOF_ETHARP_HDR));

  hdr = (struct etharp_hdr *)p->payload;
  LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n"));
  hdr->opcode = lwip_htons(opcode); /* 操作字段 */

  LWIP_ASSERT("netif->hwaddr_len must be the same as ETH_HWADDR_LEN for etharp!",
              (netif->hwaddr_len == ETH_HWADDR_LEN));

  SMEMCPY(&hdr->shwaddr, hwsrc_addr, ETH_HWADDR_LEN); /* 源MAC字段 */
  SMEMCPY(&hdr->dhwaddr, hwdst_addr, ETH_HWADDR_LEN); /* 目标MAC字段 */
  IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->sipaddr, ipsrc_addr); /* 源IP字段 */
  IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->dipaddr, ipdst_addr); /* 目标IP字段 */

  hdr->hwtype = PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET); /* 硬件类型 */
  hdr->proto = PP_HTONS(ETHTYPE_IP); /* 协议类型 */
  hdr->hwlen = ETH_HWADDR_LEN; /* 硬件地址长度 */
  hdr->protolen = sizeof(ip4_addr_t); /* 协议地址长度 */

  /* 发送ARP包 */

#if LWIP_AUTOIP
  /* 如果我们源IP为本地链路的IP，说明本ARP报文为ARP探测包，用于检查当前链路这个目标IP是否被占用了。所以需要用以太网帧的目标MAC需要设置为广播MAC(参见RFC3927第2.5节最后一段)*/
  if (ip4_addr_islinklocal(ipsrc_addr)) {
    ethernet_output(netif, p, ethsrc_addr, &ethbroadcast, ETHTYPE_ARP); /* 发送以太网帧 */
  } else
#endif /* LWIP_AUTOIP */
  { /* 非ARP探测包，可按指定MAC封装以太网首部的目标MAC */
    ethernet_output(netif, p, ethsrc_addr, ethdst_addr, ETHTYPE_ARP); /* 发送以太网帧 */
  }
  /* lwip状态记录 */
  ETHARP_STATS_INC(etharp.xmit);
  /* 释放当前ARP报文资源 */
  pbuf_free(p);
  p = NULL;
  return result;
}

8.7.3 发送ARP请求包

etharp_request_dst()：

发起ARP请求。
可指定目标MAC。

/**
 * Send an ARP request packet asking for ipaddr to a specific eth address.
 * Used to send unicast request to refresh the ARP table just before an entry times out.
 *
 * @param netif the lwip network interface on which to send the request
 * @param ipaddr the IP address for which to ask
 * @param hw_dst_addr the ethernet address to send this packet to
 * @return ERR_OK if the request has been sent
 *         ERR_MEM if the ARP packet couldn't be allocated
 *         any other err_t on failure
 */
static err_t
etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr)
{
  return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, hw_dst_addr,
                    (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), &ethzero,
                    ipaddr, ARP_REQUEST); /* ARP请求 */
}

etharp_request_dst()：

发起ARP标准请求包。（广播包）

/**
 * Send an ARP request packet asking for ipaddr.
 *
 * @param netif the lwip network interface on which to send the request
 * @param ipaddr the IP address for which to ask
 * @return ERR_OK if the request has been sent
 *         ERR_MEM if the ARP packet couldn't be allocated
 *         any other err_t on failure
 */
err_t
etharp_request(struct netif *netif, const ip4_addr_t *ipaddr)
{
  LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_request: sending ARP request.\n"));
  return etharp_request_dst(netif, ipaddr, &ethbroadcast);
}

8.7.4 发送ARP IP探测包

etharp_acd_probe()：

发起ARP IP探测。
用于发送探测消息进行地址冲突检测。

/**
 * Send an ARP request packet probing for an ipaddr.
 * Used to send probe messages for address conflict detection.
 *
 * @param netif the lwip network interface on which to send the request
 * @param ipaddr the IP address to probe
 * @return ERR_OK if the request has been sent
 *         ERR_MEM if the ARP packet couldn't be allocated
 *         any other err_t on failure
 */
err_t
etharp_acd_probe(struct netif *netif, const ip4_addr_t *ipaddr)
{
  return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, &ethbroadcast,
                    (struct eth_addr *)netif->hwaddr, IP4_ADDR_ANY4, &ethzero,
                    ipaddr, ARP_REQUEST);
}

8.7.5 发送ARP IP宣告包

etharp_acd_announce()：

发起ARP IP宣告。
用于发送地址冲突检测的公告消息。

/**
 * Send an ARP request packet announcing an ipaddr.
 * Used to send announce messages for address conflict detection.
 *
 * @param netif the lwip network interface on which to send the request
 * @param ipaddr the IP address to announce
 * @return ERR_OK if the request has been sent
 *         ERR_MEM if the ARP packet couldn't be allocated
 *         any other err_t on failure
 */
err_t
etharp_acd_announce(struct netif *netif, const ip4_addr_t *ipaddr)
{
  return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, &ethbroadcast,
                    (struct eth_addr *)netif->hwaddr, ipaddr, &ethzero,
                    ipaddr, ARP_REQUEST);
}

8.8 数据包发送分析

8.8.1 数据发包处理简述（ARP相关）

主要分析ARP协议层的处理。

IP层数据包通过ip4_output()函数传递到ARP协议处理。通过ARP协议获得目标IP主机的MAC地址才能封装以太网帧，在链路层转发。

etharp_output()收到IP层发来的数据包后按一下逻辑分支处理：

对于广播或者多播的数据包：调用ethernet_output()函数直接把数据包丢给网卡即可。
- MAC的多播地址范围：01:00:5E:00:00:00 —— 01:00:5E:7F:FF:FF
对于单播数据包：
- 遍历ARP缓存表：遍历时，可以从当前网卡上次发送数据包使用的arp entry开始查起，找到就调用etharp_output_to_arp_index()把IP数据包转交给链路层转发。
  - etharp_output_to_arp_index()概述里面会更新维护ARP缓存表当前arp entry。
- 发起ARP请求：如果缓存表中没有当前IP数据包目标IP映射的MAC地址，就需要调用etharp_query()，把IP数据包转交给ARP协议处理。
  - etharp_query()会发起ARP请求，在ARP请求过程中，把这些IP层的数据包保存到当前ARP条目的entry的挂起缓存队列中。直到收到ARP响应或者ARP请求超时为止。

8.8.2 etharp_output()：IP数据包是否ARP协议处理

解析和填写以太网地址头为传出IP数据包。

/**
 * Resolve and fill-in Ethernet address header for outgoing IP packet.
 *
 * For IP multicast and broadcast, corresponding Ethernet addresses are selected and the packet is transmitted on the link.
 *
 * For unicast addresses, the packet is submitted to etharp_query(). In case the IP address is outside the local network, the IP address of the gateway is used.
 *
 * @param netif The lwIP network interface which the IP packet will be sent on.
 * @param q The pbuf(s) containing the IP packet to be sent.
 * @param ipaddr The IP address of the packet destination.
 *
 * @return
 * - ERR_RTE No route to destination (no gateway to external networks),
 * or the return type of either etharp_query() or ethernet_output().
 */
err_t
etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
{
  const struct eth_addr *dest;
  struct eth_addr mcastaddr;
  const ip4_addr_t *dst_addr = ipaddr;
  /* tcpip内核锁上锁检查 */
  LWIP_ASSERT_CORE_LOCKED();
  /* 参数校验 */
  LWIP_ASSERT("netif != NULL", netif != NULL);
  LWIP_ASSERT("q != NULL", q != NULL);
  LWIP_ASSERT("ipaddr != NULL", ipaddr != NULL);

  if (ip4_addr_isbroadcast(ipaddr, netif)) {
    /* 目标IP为广播地址 */
    /* 目标MAC也设置为广播地址：FF-FF-FF-FF-FF-FF-FF */
    dest = (const struct eth_addr *)&ethbroadcast;
  } else if (ip4_addr_ismulticast(ipaddr)) {
    /* 目标IP为多播地址 */
    /* 目标MAC也设置为多播地址：01:00:5E:00:00:00 —— 01:00:5E:7F:FF:FF */
    mcastaddr.addr[0] = LL_IP4_MULTICAST_ADDR_0;
    mcastaddr.addr[1] = LL_IP4_MULTICAST_ADDR_1;
    mcastaddr.addr[2] = LL_IP4_MULTICAST_ADDR_2;
    mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f;
    mcastaddr.addr[4] = ip4_addr3(ipaddr);
    mcastaddr.addr[5] = ip4_addr4(ipaddr);
    dest = &mcastaddr;
  } else { /* 目标IP为单播地址 */
    netif_addr_idx_t i;
    /* 判断目标IP是否和原IP主机处于同一个子网上，如果不是，则修改要查找MAC的的IP为当前网卡的网关IP */
    if (!ip4_addr_net_eq(ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) &&
        !ip4_addr_islinklocal(ipaddr)) { /* 不是同一个子网，也不是本地链路地址，需要把数据包转发到网关 */
#if LWIP_AUTOIP
      struct ip_hdr *iphdr = LWIP_ALIGNMENT_CAST(struct ip_hdr *, q->payload);
      /* 根据RFC 3297 2.6.2章(转发规则)，如果IP地址为本地链路地址（169.254.0.0/16），这样的IP数据包是不能通过路由器转发的 */
      if (!ip4_addr_islinklocal(&iphdr->src)) /* 源IP地址不是本地链路地址 */
#endif /* LWIP_AUTOIP */
      {
#ifdef LWIP_HOOK_ETHARP_GET_GW
        /* 网关钩子函数，可以自定义选择网关 */
        dst_addr = LWIP_HOOK_ETHARP_GET_GW(netif, ipaddr);
        if (dst_addr == NULL)
#endif /* LWIP_HOOK_ETHARP_GET_GW */
        {
          /* 查看网卡是否有默认网关 */
          if (!ip4_addr_isany_val(*netif_ip4_gw(netif))) {
            /* 获取网卡默认网关 */
            dst_addr = netif_ip4_gw(netif);
          } else { /* 没找到有效网关 */
            /* 没有路由到目的地错误(缺省网关丢失) */
            return ERR_RTE;
          }
        }
      }
    }
#if LWIP_NETIF_HWADDRHINT
    if (netif->hints != NULL) {
      /* 网卡中上次发包时使用的arp entry优先遍历 */
      netif_addr_idx_t etharp_cached_entry = netif->hints->addr_hint;
      if (etharp_cached_entry < ARP_TABLE_SIZE) {
#endif /* LWIP_NETIF_HWADDRHINT */
        if ((arp_table[etharp_cached_entry].state >= ETHARP_STATE_STABLE) && /* arp entry有效 */
#if ETHARP_TABLE_MATCH_NETIF
            (arp_table[etharp_cached_entry].netif == netif) && /* arp entry对应网卡匹配 */
#endif
            (ip4_addr_eq(dst_addr, &arp_table[etharp_cached_entry].ipaddr))) { /* 找到目标IP的MAC映射 */
          ETHARP_STATS_INC(etharp.cachehit); /* 记录lwip arp相关状态 */
          /* 发送IP数据包 */
          return etharp_output_to_arp_index(netif, q, etharp_cached_entry);
        }
#if LWIP_NETIF_HWADDRHINT
      }
    }
#endif /* LWIP_NETIF_HWADDRHINT */

    /* 如果网卡指定先遍历的arp entry没有找到合法映射，就需要遍历ARP缓存表 */
    for (i = 0; i < ARP_TABLE_SIZE; i++) {
      if ((arp_table[i].state >= ETHARP_STATE_STABLE) && /* arp entry有效 */
#if ETHARP_TABLE_MATCH_NETIF
          (arp_table[i].netif == netif) && /* 网卡匹配对应 */
#endif
          (ip4_addr_eq(dst_addr, &arp_table[i].ipaddr))) { /* 目标IP对应 */
        /* 找到目标IP的MAC映射 */
        /* 把当前arp entry索引保存到网卡中，以便下次快速遍历 */
        ETHARP_SET_ADDRHINT(netif, i);
        /* 发送IP数据包 */
        return etharp_output_to_arp_index(netif, q, i);
      }
    }
    /* 在ARP缓存表中没有找到对应的ARP entry，就需要发起ARP 请求 */
    return etharp_query(netif, dst_addr, q);
  }

  /* 对于广播或组播的数据包，直接知道了目标硬件字段的MAC地址，可以直接往链路层发送 */
  return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), dest, ETHTYPE_IP);
}

8.8.3 etharp_output_to_arp_index()：需要维护arp entry的IP数据包转发函数

etharp_output_to_arp_index()这个函数实现维护arp entry超时前更新，然后把数据包通过ethernet_output()转交给链路层。

其源码参考前面缓存表状态。

8.8.4 etharp_query()：需要发起ARP请求的IP数据包转发函数

如果IP数据包为单播包，且在 ARP 缓存表中没有找到对应的MAC地址，就需要调用etharp_query()函数发起ARP请求处理。

主要内容：

IP地址校验。只能是有效的单播IP地址。
找到可操作的arp entry。
发起ARP请求。
拷贝pbuf保存到arp entry缓存队列。

/**
 * Send an ARP request for the given IP address and/or queue a packet.
 *
 * If the IP address was not yet in the cache, a pending ARP cache entry
 * is added and an ARP request is sent for the given address. The packet
 * is queued on this entry.
 *
 * If the IP address was already pending in the cache, a new ARP request
 * is sent for the given address. The packet is queued on this entry.
 *
 * If the IP address was already stable in the cache, and a packet is
 * given, it is directly sent and no ARP request is sent out.
 *
 * If the IP address was already stable in the cache, and no packet is
 * given, an ARP request is sent out.
 *
 * @param netif The lwIP network interface on which ipaddr
 * must be queried for.
 * @param ipaddr The IP address to be resolved.
 * @param q If non-NULL, a pbuf that must be delivered to the IP address.
 * q is not freed by this function.
 *
 * @note q must only be ONE packet, not a packet queue!
 *
 * @return
 * - ERR_BUF Could not make room for Ethernet header.
 * - ERR_MEM Hardware address unknown, and no more ARP entries available
 *   to query for address or queue the packet.
 * - ERR_MEM Could not queue packet due to memory shortage.
 * - ERR_RTE No route to destination (no gateway to external networks).
 * - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
 *
 */
err_t
etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q)
{
  struct eth_addr *srcaddr = (struct eth_addr *)netif->hwaddr;
  err_t result = ERR_MEM;
  int is_new_entry = 0;
  s16_t i_err;
  netif_addr_idx_t i;

  /* 如果是广播、组播或者无效的单播，不需要发起ARP请求，不用在继续往下处理 */
  if (ip4_addr_isbroadcast(ipaddr, netif) ||
      ip4_addr_ismulticast(ipaddr) ||
      ip4_addr_isany(ipaddr)) {
    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: will not add non-unicast IP address to ARP cache\n"));
    return ERR_ARG;
  }

  /* 按规则找到arp entry进行操作 */
  i_err = etharp_find_entry(ipaddr, ETHARP_FLAG_TRY_HARD, netif);

  if (i_err < 0) { /* 没找到能用的arp entry */
    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not create ARP entry\n"));
    if (q) {
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: packet dropped\n"));
      ETHARP_STATS_INC(etharp.memerr);
    }
    return (err_t)i_err;
  }
  LWIP_ASSERT("type overflow", (size_t)i_err < NETIF_ADDR_IDX_MAX);
  i = (netif_addr_idx_t)i_err; /* 找到合法的arp entry */

  if (arp_table[i].state == ETHARP_STATE_EMPTY) { /* 是新的arp entry，做下标记 */
    is_new_entry = 1; /* 标记下当前为新的arp entry */
    arp_table[i].state = ETHARP_STATE_PENDING; /* 更新为pending态 */
    /* 保存网卡到arp entry中 */
    arp_table[i].netif = netif;
  }

  /* arp请求中或者arp entry有效即可往下走 */
  LWIP_ASSERT("arp_table[i].state == PENDING or STABLE",
              ((arp_table[i].state == ETHARP_STATE_PENDING) ||
               (arp_table[i].state >= ETHARP_STATE_STABLE)));

  /* do we have a new entry? or an implicit query request? */
  if (is_new_entry || (q == NULL)) { /* 新的arp entry或者隐式ARP请求都需要重新发起ARP请求 */
    /* 发送ARP请求 */
    result = etharp_request(netif, ipaddr);
    if (result != ERR_OK) {
      /* ARP请求发送失败 */
      /* 该故障可能只是暂时的，而且在etharp_tmr()周期定时函数中会重新发出ARP请求，所以这里先跳过 */
    } else {
      /* ARP请求发送成功 */
      if ((arp_table[i].state == ETHARP_STATE_PENDING) && !is_new_entry) {
        /* 隐式ARP请求，发送请求成功，重置下ctime，不让其快过期 */
        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: reset ctime for entry %"S16_F"\n", (s16_t)i));
        arp_table[i].ctime = 0;
      }
    }
    if (q == NULL) {
      return result; /* 隐式ARP请求的话，不需要往下保存数据了 */
    }
  }

  LWIP_ASSERT("q != NULL", q != NULL);

  if (arp_table[i].state >= ETHARP_STATE_STABLE) { /* 当前条目已经有效 */
    /* 更新下当前网卡发送IP数据包时使用的arp entry，方便下次优先遍历 */
    ETHARP_SET_ADDRHINT(netif, i);
    /* 可以直接把IP数据包交给链路层转发 */
    result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP);
  } else if (arp_table[i].state == ETHARP_STATE_PENDING) { /* ARP请求中 */
    /* 需要把当前IP数据包放到当前arp entry的缓存队列中 */
    struct pbuf *p;
    int copy_needed = 0;
    /* 如果q这个pbuf链中包含一个可改动的pbuf（即是PBUFF_ERF、PBUF_POOL、PBUF_RAM），都需要拷贝整个pbuf链到arp entry的缓存队列中. */
    p = q;
    while (p) {
      LWIP_ASSERT("no packet queues allowed!", (p->len != p->tot_len) || (p->next == NULL));
      if (PBUF_NEEDS_COPY(p)) { /* 遍历pbuf链中各个pbuf，是否含有可改动的pbuf */
        copy_needed = 1; /* 需要拷贝整个pbuf链 */
        break;
      }
      p = p->next;
    }
    if (copy_needed) {
      /* 将整个包复制到新的pbuf中 */
      p = pbuf_clone(PBUF_LINK, PBUF_RAM, q);
    } else {
      /* 引用旧的pbuf就足够了 */
      p = q;
      pbuf_ref(p);
    }

    if (p != NULL) {
#if ARP_QUEUEING
      struct etharp_q_entry *new_entry;
      /* 申请一个新的 arp entry queue 节点资源 */
      new_entry = (struct etharp_q_entry *)memp_malloc(MEMP_ARP_QUEUE);
      if (new_entry != NULL) {
        unsigned int qlen = 0; /* 记录队列节点数 */
        new_entry->next = NULL;
        new_entry->p = p; /* 把IP层需要发送的数据包先放到当前arp entry queue节点 */
        if (arp_table[i].q != NULL) {
          /* 队列已经存在，将新条目插入到队列尾 */
          struct etharp_q_entry *r;
          r = arp_table[i].q;
          qlen++;
          while (r->next != NULL) {
            r = r->next;
            qlen++;
          }
          r->next = new_entry;
        } else {
          /* 队列不存在，当前节点放到队列首部 */
          arp_table[i].q = new_entry;
        }
#if ARP_QUEUE_LEN
        if (qlen >= ARP_QUEUE_LEN) { /* 队列超员后，需要丢弃旧报文，为新报文腾位 */
          struct etharp_q_entry *old;
          old = arp_table[i].q;
          arp_table[i].q = arp_table[i].q->next; /* 删除最老的报文 */
          pbuf_free(old->p); /* 释放该报文资源 */
          memp_free(MEMP_ARP_QUEUE, old); /* 回收该节点资源 */
        }
#endif
        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, i));
        result = ERR_OK; /* ARP请求处理完毕 */
      } else { /* ARP缓存节点MEMP_ARP_QUEUE内存池没有资源了 */
        pbuf_free(p); /* 释放拷贝的的pbuf资源 */
        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
        result = ERR_MEM; /* 返回内存不足 */
      }
#else /* ARP_QUEUEING */ /* arp entry缓存队列只能是单包配置 */
      /* 对于每个ARP请求总是只排队一个包，释放之前排队的包 */
      if (arp_table[i].q != NULL) {
        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: dropped previously queued packet %p for ARP entry %"U16_F"\n", (void *)q, (u16_t)i));
        pbuf_free(arp_table[i].q);
      }
      arp_table[i].q = p;
      result = ERR_OK;
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, (u16_t)i));
#endif /* ARP_QUEUEING */
    } else { /* 拷贝pbuf链表时PBUF_RAM内存堆空间不足 */
      ETHARP_STATS_INC(etharp.memerr);
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
      result = ERR_MEM; /* 返回内存不足 */
    }
  }
  return result; /* 搞完 */
}

8.8.5 etharp_find_entry()：查找可被新建的arp entry

优先寻找匹配IP（和网卡）的arp entry。
然后再寻找最不重要的arp entry。优先被覆盖的顺序：empty entry > oldest stable entry > oldest pending entry without queued packets > oldest pending entry with queued packets。

/**
 * Search the ARP table for a matching or new entry.
 *
 * If an IP address is given, return a pending or stable ARP entry that matches
 * the address. If no match is found, create a new entry with this address set,
 * but in state ETHARP_EMPTY. The caller must check and possibly change the
 * state of the returned entry.
 *
 * If ipaddr is NULL, return a initialized new entry in state ETHARP_EMPTY.
 *
 * In all cases, attempt to create new entries from an empty entry. If no
 * empty entries are available and ETHARP_FLAG_TRY_HARD flag is set, recycle
 * old entries. Heuristic choose the least important entry for recycling.
 *
 * @param ipaddr IP address to find in ARP cache, or to add if not found.
 * @param flags See @ref etharp_state
 * @param netif netif related to this address (used for NETIF_HWADDRHINT)
 *
 * @return The ARP entry index that matched or is created, ERR_MEM if no
 * entry is found or could be recycled.
 */
static s16_t
etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif *netif)
{
  s16_t old_pending = ARP_TABLE_SIZE; /* pending态没有阻塞数据最老的arp entry */
  s16_t old_stable = ARP_TABLE_SIZE; /* 有效态最老的arp entry */
  s16_t empty = ARP_TABLE_SIZE;
  s16_t i = 0;
  s16_t old_queue = ARP_TABLE_SIZE; /* pending态有阻塞数据最老的arp entry */
  /* 对应的age */
  u16_t age_queue = 0, age_pending = 0, age_stable = 0;

  LWIP_UNUSED_ARG(netif); /* 防止编译警告 */

  /**
   * a) do a search through the cache, remember candidates
   * b) select candidate entry
   * c) create new entry
   */

  /* a) in a single search sweep, do all of this
   * 1) remember the first empty entry (if any)
   * 2) remember the oldest stable entry (if any)
   * 3) remember the oldest pending entry without queued packets (if any)
   * 4) remember the oldest pending entry with queued packets (if any)
   * 5) search for a matching IP entry, either pending or stable
   *    until 5 matches, or all entries are searched for.
   */

  for (i = 0; i < ARP_TABLE_SIZE; ++i) { /* 遍历ARP缓存表 */
    u8_t state = arp_table[i].state;
    if ((empty == ARP_TABLE_SIZE) && (state == ETHARP_STATE_EMPTY)) {
      /* 检索到空闲的arp entry */
      LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_find_entry: found empty entry %d\n", (int)i));
      /* 记住第一个空闲的arp entry */
      empty = i;
    } else if (state != ETHARP_STATE_EMPTY) { /* 当前遍历到的arp entry不是空闲态 */
      LWIP_ASSERT("state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE",
                  state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE);
      if (ipaddr && ip4_addr_eq(ipaddr, &arp_table[i].ipaddr) /* 匹配当前arp entry的IP */
#if ETHARP_TABLE_MATCH_NETIF
          && ((netif == NULL) || (netif == arp_table[i].netif)) /* 匹配当前arp entry的网卡 */
#endif /* ETHARP_TABLE_MATCH_NETIF */
         ) {
        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: found matching entry %d\n", (int)i));
        /* 已经找到符合要求，且已经存在的arp entry了 */
        return i;
      }
      if (state == ETHARP_STATE_PENDING) { /* peding态 */
        if (arp_table[i].q != NULL) { /* 有阻塞数据包 */
          if (arp_table[i].ctime >= age_queue) { /* 当前arp entry更老 */
            /* 更新值 */
            old_queue = i;
            age_queue = arp_table[i].ctime;
          }
        } else
        { /* 没有阻塞数据包 */
          if (arp_table[i].ctime >= age_pending) { /* 当前arp entry更老 */
            /* 更新值 */
            old_pending = i;
            age_pending = arp_table[i].ctime;
          }
        }
      } else if (state >= ETHARP_STATE_STABLE) { /* 有效态 */
#if ETHARP_SUPPORT_STATIC_ENTRIES
        /* 不要处理静态的arp entry */
        if (state < ETHARP_STATE_STATIC)
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
        {
          if (arp_table[i].ctime >= age_stable) { /* 当前arp entry更老 */
            /* 更新值 */
            old_stable = i;
            age_stable = arp_table[i].ctime;
          }
        }
      }
    }
  }

  /* 已经遍历ARP缓存表完毕，没找到匹配IP已有的arp entry。 */

  if (((flags & ETHARP_FLAG_FIND_ONLY) != 0) || /* 只读模式，没有匹配的arp entry就直接退出 */
      ((empty == ARP_TABLE_SIZE) && ((flags & ETHARP_FLAG_TRY_HARD) == 0))) { /* 非只读模式，但是没找到空闲arp entry，又不能覆盖，也直接退出 */
    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty entry found and not allowed to recycle\n"));
    return (s16_t)ERR_MEM;
  }

  /* b) choose the least destructive entry to recycle:
   * 1) empty entry
   * 2) oldest stable entry
   * 3) oldest pending entry without queued packets
   * 4) oldest pending entry with queued packets
   *
   * { ETHARP_FLAG_TRY_HARD is set at this point }
   */

  if (empty < ARP_TABLE_SIZE) { /* 找到空闲的arp entry */
    i = empty;
    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting empty entry %d\n", (int)i));
  } else { /* 没找到空闲的arp entry */
    if (old_stable < ARP_TABLE_SIZE) { /* 2) 先找最老的有效态arp entry */
      /* 回收最老的有效态arp entry */
      i = old_stable;
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest stable entry %d\n", (int)i));
      /* stable态arp entry上不应该存在排队的数据包 */
      LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL);
    } else if (old_pending < ARP_TABLE_SIZE) { /* 3) 再找没有阻塞数据的pending态的arp entry */
      /* 回收这条arp entry */
      i = old_pending;
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d (without queue)\n", (int)i));
    } else if (old_queue < ARP_TABLE_SIZE) {  /* 4) 最后才找有阻塞数据的pending态的arp entry */
      /* 回收这条arp entry */
      i = old_queue;
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d, freeing packet queue %p\n", (int)i, (void *)(arp_table[i].q)));
    } else { /* 没找到 */
      LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty or recyclable entries found\n"));
      return (s16_t)ERR_MEM;
    }

    LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE);
    /* 找到需要需要回收的arp entry，将其回收 */
    etharp_free_entry(i);
  }

  /* 确保当前arp entry已经为空闲态，且索引不超限制 */
  LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE);
  LWIP_ASSERT("arp_table[i].state == ETHARP_STATE_EMPTY",
              arp_table[i].state == ETHARP_STATE_EMPTY);

  if (ipaddr != NULL) {
    /* 保存IP到新建arp entry */
    ip4_addr_copy(arp_table[i].ipaddr, *ipaddr);
  }
  arp_table[i].ctime = 0; /* 重置age */
#if ETHARP_TABLE_MATCH_NETIF
  arp_table[i].netif = netif; /* 保存网卡到新建arp entry */
#endif /* ETHARP_TABLE_MATCH_NETIF */
  return (s16_t)i; /* 返回找到符合要求的arp entry */
}

8.9 数据包接收分析