LWIP_ARP协议(4数据包发送)

ARP数据包发送

我们知道一个数据包从底层传递进来的流程是怎么样的，如果是ARP数据包就会给ARP去处理，如果是IP数据报就使用ip4_input()函数传递到上层，这些处理在后面的章节讲解。那么如果上层协议想要发送数据，也肯定需要经过ARP协议将IP地址映射为MAC地址才能完成发送操作，IP数据报通过ip4_output()函数将上层数据包传递到ARP协议处理，关于IP协议是怎么样传递的我们暂且不说，那么ARP通过etharp_output()函数接收到IP数据报后，就会进行发送，ARP会先从数据包中进行分析，看看这个IP数据报是单播数据包还是多播或者是广播数据包，然后进行不同的处理：

对于多播或者是广播数据包，这种处理就很简单，直接将数据包丢给网卡就行了（调用ethernet_output()函数）。
对于单播包的处理稍微麻烦一点，ARP协议需要根据IP地址找到对应的MAC地址，然后才能正确发送，如果找不到MAC地址的话，还要延迟发送数据包，ARP协议首先会创建一个ARP表项，然后将数据包挂到ARP表项对应的缓存队列上，与此同时会发出一个ARP请求包，等待目标主机的回应后再发送IP数据报。
此处需要注意的是，对于PBUFF_ERF、PBUF_POOL、PBUF_RAM类型的数据包是不允许直接挂到ARP表项对应的缓存队列上的，因为此时内核需要等待目标主机的ARP应答，而这段时间里，这些数据有可能会被上层改动，这是不允许的，所以LwIP需要将这些pbuf数据包拷贝到新的空间，等待发送。

etharp_output()函数被IP层的ip4_output()函数调用，IP层传递一个数据包到ARP中，etharp_output()会根据数据包的目标IP地址选择不同的处理。

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;

  if (ip4_addr_isbroadcast(ipaddr, netif)) 
  {
    /* 如果是广播数据包，目标MAC地址设置为FF-FF-FF-FF-FF-FF-FF */
    dest = (const struct eth_addr *)&ethbroadcast;
  } 
  else if (ip4_addr_ismulticast(ipaddr)) 
  {
    /* 如果是多播数据包，目标MAC地址设置为多播地址：01-00-5E-XX-XX-XX */
    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);
    /* destination Ethernet address is multicast */
    dest = &mcastaddr;
  } 
  else 
  {
    /* 如果是单播目标地IP地址 */
    netif_addr_idx_t i;
    /* 判断目标IP地址是否与主机处于同一子网上，
       如果不是，则修改IP地址，发向网关，请求网关转发，
	   则需要修改IP地址，IP地址为网关的IP地址，目的是为了让网关进行转发。*/
    if (!ip4_addr_netcmp(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);
      if (!ip4_addr_islinklocal(&iphdr->src))
#endif 
      {
#ifdef LWIP_HOOK_ETHARP_GET_GW
        dst_addr = LWIP_HOOK_ETHARP_GET_GW(netif, ipaddr);
        if (dst_addr == NULL)
#endif 
        {
           /* 判断一下网关地址是否有效 */
          if (!ip4_addr_isany_val(*netif_ip4_gw(netif)))
		  {
            /* 发送到默认网关，让网关进行转发 */
            dst_addr = netif_ip4_gw(netif);
            
          }
		  else
		  {
            /* 没有默认网关可用，返回错误 */
            return ERR_RTE;
          }
        }
      }
    }
	
    /* 遍历ARP缓存表 */
    for (i = 0; i < ARP_TABLE_SIZE; i++)
	{
      if ((arp_table[i].state >= ETHARP_STATE_STABLE) &&
#if ETHARP_TABLE_MATCH_NETIF
          (arp_table[i].netif == netif) &&
#endif
          (ip4_addr_cmp(dst_addr, &arp_table[i].ipaddr))) 
	  {
        /* 如果找到目标IP地址对应的表项，直接发送 */
        ETHARP_SET_ADDRHINT(netif, i);
        return etharp_output_to_arp_index(netif, q, i);
      }
    }
    /* 如果没有找到与目标IP地址对应的ARP表项 */
    return etharp_query(netif, dst_addr, q);
  }

  /* 而对于多播、广播数据包，直接能得到对应的MAC地址，可以进行发送*/
  return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), dest, ETHTYPE_IP);
}

在上一个函数中，会调用etharp_output_to_arp_index()这个函数，因为是ARP找到了IP地址与MAC地址对应的表项，从而能直接进行发送，除此之外，ARP还需要更新ARP表项，我们知道，LwIP中的ARP表项生存时间是5分钟（300秒），那么在APP表项的生存时间即将到来的时候，ARP需要更新表项，为什么要在发送数据的时候更新呢？因为如果不发送数据，那就没必要更新ARP表项，这样子表项在生存时间到来的时候就会被系统删除，回收ARP表项空间，而一直使用的ARP表项需要是谁更新，更新的方式也有两种：

如果ARP表项还差15秒就过期了，LwIP会通过广播的方式发送一个ARP请求包，试图得到主机的回应。
而如果ARP表项还差30秒就过期了，那么LwIP会通过单播的方式向目标主机发送一个请求包并试图得到回应。
在这种情况下发送ARP请求包的时候，表项的状态会由ETHARP_STATE_STABLE变成ETHARP_STATE_STABLE_REREQUESTING_1，如果目标主机回应了，那就更新ARP缓存表中的表项。
当然，如果还没那么快到期的话，那就直接调用ethernet_output()函数将数据包传递给网卡进行发送。

#define ARP_MAXAGE                      300

/* 即将到期的时间 */
#define ARP_AGE_REREQUEST_USED_UNICAST   (ARP_MAXAGE - 30)
#define ARP_AGE_REREQUEST_USED_BROADCAST (ARP_MAXAGE - 15)

static err_t
etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, netif_addr_idx_t arp_idx)
{
  /* 如果arp表项即将过期：LwIP会发送一个ARP请求包，但只有当它的状态是ETHARP_STATE_STABLE才能请求*/
  if (arp_table[arp_idx].state == ETHARP_STATE_STABLE) 
  {
    /* 还差15秒到期 */
    if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_BROADCAST) 
	{
      /* 使用广播方式发出请求包 */
      if (etharp_request(netif, &arp_table[arp_idx].ipaddr) == ERR_OK) 
	  {
        arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1;
      }
    } 
	/* 还差30秒到期 */
	else if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_UNICAST) 
	{
      /* 发出单播请求（持续15秒），以防止不必要的广播 */
      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;
      }
    }
  }

  return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP);
}

而如果在ARP缓存表中没有找到目标IP地址对应的表项，LwIP就会调用etharp_query()函数，那么ARP协议就会创建一个表项，这也是ARP协议的核心处理，对于刚创建的表项，它在初始化网卡信息后会被设置为ETHARP_STATE_PENDING状态，与此同时一个ARP请求包将被广播出去，这个时候的表项是无法发送数据的，只有等待到目标主机回应了一个ARP应答包才能发送数据，那么这些数据在这段时间中将被挂到表项的等待队列上，在ARP表项处于ETHARP_STATE_STABLE状态完成数据的发送。
函数的处理逻辑是很清晰的，首先调用etharp_find_entry()函数在ARP缓存表中查找表项，如果没有找到就尝试创建表项并且返回表项的索引，当然ARP缓存表中可能存在表项，可能为新创建的表项（ETHARP_STATE_EMPTY），也可能为ETHARP_STATE_PENDING或者ETHARP_STATE_STABLE状态。如果是新创建的表项，那么表项肯定没有其他信息，LwIP就会初始化一些信息，如网卡，然后就将表项设置为ETHARP_STATE_PENDING状态。
挂载的这些数据在等待到目标主机产生ARP应答的时候会发送出去，此时的发送就是延时了，所以在没有ARP表项的时候，发送数据会产生延时，在指定等待ARP应答时间内如果等不到目标主机的应答，那么这个表项将被系统回收，同时数据也无法发送出去。

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;

  /* 检是否为单播地址 */
  if (ip4_addr_isbroadcast(ipaddr, netif) ||
      ip4_addr_ismulticast(ipaddr) ||
      ip4_addr_isany(ipaddr)) {
    return ERR_ARG;
  }

  /* 在ARP缓存中查找表项，如果没有则尝试创建表项 */
  i_err = etharp_find_entry(ipaddr, ETHARP_FLAG_TRY_HARD, netif);

  /* 没有发现表项或者没有创建表项成功 */
  if (i_err < 0) {
    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;

 /* 将新表项标记为待处理 */
  if (arp_table[i].state == ETHARP_STATE_EMPTY)
  {
    is_new_entry = 1;
	//设置表项的状态
    arp_table[i].state = ETHARP_STATE_PENDING;
	
    /* 记录网卡 */
    arp_table[i].netif = netif;
  }

  /* 是否有新的表项 */
  if (is_new_entry || (q == NULL)) 
  {
    /* 发送ARP请求包*/
    result = etharp_request(netif, ipaddr);
    if (result != ERR_OK)
	{

    }
    if (q == NULL) {
      return result;
    }
  }

  LWIP_ASSERT("q != NULL", q != NULL);
  /* 表项状态是否稳定 */
  if (arp_table[i].state >= ETHARP_STATE_STABLE)
  {
    ETHARP_SET_ADDRHINT(netif, i);
	
    /* 发送数据包 */
    result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP);
	
    
  } 
  else if (arp_table[i].state == ETHARP_STATE_PENDING)
  {
    /* 如果表项是ETHARP_STATE_PENDING状态 */
	/* 将给数据包'q'排队 */
    struct pbuf *p;
    int copy_needed = 0;
	
	/* 如果q包含必须拷贝的pbuf，请将整个链复制到一个新的PBUF_RAM */
    p = q;
    while (p) 
	{
      LWIP_ASSERT("no packet queues allowed!", (p->len != p->tot_len) || (p->next == 0));
      if (PBUF_NEEDS_COPY(p)) 
	  {
	    //需要拷贝
        copy_needed = 1;
        break;
      }
      p = p->next;
    }
    if (copy_needed) 
	{
      /* 将整个数据包复制到新的pbuf中 */
      p = pbuf_clone(PBUF_LINK, PBUF_RAM, q);
    }
	else 
	{
      /* 引用旧的pbuf就足够了 */
      p = q;
      pbuf_ref(p);
    }
    /* packet could be taken over? */
    if (p != NULL) {
      
#if ARP_QUEUEING		/* 如果使用队列 */
      struct etharp_q_entry *new_entry;
	  
      /* 分配一个新的arp队列表项 */
      new_entry = (struct etharp_q_entry *)memp_malloc(MEMP_ARP_QUEUE);
	  
      if (new_entry != NULL) 
	  {
        unsigned int qlen = 0;
        new_entry->next = 0;
        new_entry->p = p;
        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
      
        result = ERR_OK;
      }
	  else 
	  {
        /* 申请内存失败 */
        pbuf_free(p);
        result = ERR_MEM;
      }
#else 
      /* 如果只是挂载单个数据包，那么始终只为每个ARP请求排队一个数据包，就需要释放先前排队的数据包*/
      if (arp_table[i].q != NULL)
	  {
        pbuf_free(arp_table[i].q);
      }
      arp_table[i].q = p;
      result = ERR_OK;
#endif
    } else {
      ETHARP_STATS_INC(etharp.memerr);
      result = ERR_MEM;
    }
  }
  return result;
}