TCP/IP学习(33)——ARP数据包的处理流程分析

1050阅读　0评论2013-11-08　491357604
分类：LINUX

本文的copyleft归gfree.wind@gmail.com所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。
作者：gfree.wind@gmail.com
博客：linuxfocus.blog.chinaunix.net    

在IPv4中，ARP是Linux TCP/IP中的neighbour system的实现，今天主要是学习一下Linux kernel的ARP代码。

ARP模块的初始化函数arp_init是由inet_init()调用。
  1. void __init arp_init(void)
  2. {
  3.     /* 初始化ARP neighbor table */
  4.     neigh_table_init(&arp_tbl);
  5.     /* 注册ARP数据包类型到L2 */
  6.     dev_add_pack(&arp_packet_type);
  7.     /* 
  8.     初始化ARP对应的/proc/net/arp
  9.     */
  10.     arp_proc_init();
  11. #ifdef CONFIG_SYSCTL
  12.     neigh_sysctl_register(NULL, &arp_tbl.parms, "ipv4", NULL);
  13. #endif
  14.     /* 
  15.     加入到netdevice的通知链。
  16.     因为ARP module需要handle网络设备的事件
  17.     */
  18.     register_netdevice_notifier(&arp_netdev_notifier);
  19. }
下面看ARP数据包的接收处理函数
  1. static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
  2.          struct packet_type *pt, struct net_device *orig_dev)
  3. {
  4.     struct arphdr *arp;

  6.     /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
  7.     /* 
  8.     确保buffer可以容纳ARP包。
  9.     这里arp_hdr_len从名字上看，似乎是arp的报文头长。
  10.     但是该函数返回的是return sizeof(struct arphdr) + (dev->addr_len + sizeof(u32)) * 2;
  11.     也就是整个儿ARP报文的长度。与函数名字不符。
  12.     另外，其它协议的接收处理函数，都是确保有首部的长度，而这里确实验证完整的ARP包长。
  13.     我认为是因为ARP本身就没有首部和数据部得概念的区分。
  14.     */
  15.     if (!pskb_may_pull(skb, arp_hdr_len(dev)))
  16.         goto freeskb;
     /* 拿到arp报文的指针 */ 
  1.     arp = arp_hdr(skb);
     /* 
     sanity check:
     1. arp中的l2地址长度与接收包的dev的l2地址长度不符；
     2. 接收包的device不支持ARP；
     3. 该数据包的l2地址是发送到别的主机的；
     4. 该数据包是发送到回环口的；
     5. arp中的l3地址长度不是4字节；
     */
  1.     if (arp->ar_hln != dev->addr_len ||
  2.      dev->flags & IFF_NOARP ||
  3.      skb->pkt_type == PACKET_OTHERHOST ||
  4.      skb->pkt_type == PACKET_LOOPBACK ||
  5.      arp->ar_pln != 4)
  6.         goto freeskb;
     /* 做skb的share check，因为后面的代码会修改skb，所以需要获得唯一的skb */
  1.     if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
  2.         goto out_of_mem;
     /* 到此，已确定该数据包由ARP处理，所以初始化skb中的cb字段，用于arp后面的处理 */
  1.     memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
     /* 通过netfilter的检查点 */
  1.     return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);

  3. freeskb:
  4.     kfree_skb(skb);
  5. out_of_mem:
  6.     return 0;
  7. }
继续看ARP的数据包的处理
  1. static int arp_process(struct sk_buff *skb)
  2. {
  3.     struct net_device *dev = skb->dev;
  4.     struct in_device *in_dev = __in_dev_get_rcu(dev);
  5.     struct arphdr *arp;
  6.     unsigned char *arp_ptr;
  7.     struct rtable *rt;
  8.     unsigned char *sha;
  9.     __be32 sip, tip;
  10.     u16 dev_type = dev->type;
  11.     int addr_type;
  12.     struct neighbour *n;
  13.     struct net *net = dev_net(dev);

  15.     /* arp_rcv below verifies the ARP header and verifies the device
  16.      * is ARP'able.
  17.      */
  18.     /* 该dev没有指定IP */
  19.     if (in_dev == NULL)
  20.         goto out;

  22.     arp = arp_hdr(skb);

  24.     switch (dev_type) {
  25.     default:
  26.         /* arp的l3 协议类型不是IP或者dev的l2类型与arp的l2类型不符 */
  27.         if (arp->ar_pro != htons(ETH_P_IP) ||
  28.          htons(dev_type) != arp->ar_hrd)
  29.             goto out;
  30.         break;
  31.     case ARPHRD_ETHER:
  32.     case ARPHRD_IEEE802_TR:
  33.     case ARPHRD_FDDI:
  34.     case ARPHRD_IEEE802:
  35.         /*
  36.          * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
  37.          * devices, according to RFC 2625) devices will accept ARP
  38.          * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
  39.          * This is the case also of FDDI, where the RFC 1390 says that
  40.          * FDDI devices should accept ARP hardware of (1) Ethernet,
  41.          * however, to be more robust, we'll accept both 1 (Ethernet)
  42.          * or 6 (IEEE 802.2)
  43.          */
  44.         /* 仍然是做sanity check，原因如上面的注释 */
  45.         if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
  46.          arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
  47.          arp->ar_pro != htons(ETH_P_IP))
  48.             goto out;
  49.         break;
  50.     case ARPHRD_AX25:
  51.         if (arp->ar_pro != htons(AX25_P_IP) ||
  52.          arp->ar_hrd != htons(ARPHRD_AX25))
  53.             goto out;
  54.         break;
  55.     case ARPHRD_NETROM:
  56.         if (arp->ar_pro != htons(AX25_P_IP) ||
  57.          arp->ar_hrd != htons(ARPHRD_NETROM))
  58.             goto out;
  59.         break;
  60.     }

  62.     /* Understand only these message types */
     /* 只支持ARP的正向查询 */
  1.     if (arp->ar_op != htons(ARPOP_REPLY) &&
  2.      arp->ar_op != htons(ARPOP_REQUEST))
  3.         goto out;

  5. /*
  6.  *    Extract fields
  7.  */
  8.     /* 得到ARP中的源l2地址sha，源l3地址sip和目的l3地址dip */
  9.     arp_ptr= (unsigned char *)(arp+1);
  10.     sha    = arp_ptr;
  11.     arp_ptr += dev->addr_len;
  12.     memcpy(&sip, arp_ptr, 4);
  13.     arp_ptr += 4;
  14.     arp_ptr += dev->addr_len;
  15.     memcpy(&tip, arp_ptr, 4);
  16. /*
  17.  *    Check for bad requests for 127.x.x.x and requests for multicast
  18.  *    addresses. If this is one such, delete it.
  19.  */
  20.     /* 如果目的IP为回环或者组播地址，也不处理该ARP包 */
  21.     if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
  22.         goto out;

  24. /*
  25.  * Special case: We must set Frame Relay source Q.922 address
  26.  */
  27.     if (dev_type == ARPHRD_DLCI)
  28.         sha = dev->broadcast;

  30. /*
  31.  * Process entry. The idea here is we want to send a reply if it is a
  32.  * request for us or if it is a request for someone else that we hold
  33.  * a proxy for. We want to add an entry to our cache if it is a reply
  34.  * to us or if it is a request for our address.
  35.  * (The assumption for this last is that if someone is requesting our
  36.  * address, they are probably intending to talk to us, so it saves time
  37.  * if we cache their address. Their address is also probably not in
  38.  * our cache, since ours is not in their cache.)
  39.  *
  40.  * Putting this another way, we only care about replies if they are to
  41.  * us, in which case we add them to the cache. For requests, we care
  42.  * about those for us and those for our proxies. We reply to both,
  43.  * and in the case of requests for us we add the requester to the arp
  44.  * cache.
  45.  */

  47.     /* Special case: IPv4 duplicate address detection packet (RFC2131) */
  48.     if (sip == 0) {
  49.         /* 
  50.         如果源ip为0，则是一种特殊的ARP，用于检测重复的IP地址。
  51.         如果为ARP request，且通过检查目的地址，确认该包需要本机处理，
  52.         且不忽略ARP，则回复ARP。
  53.         */
  54.         if (arp->ar_op == htons(ARPOP_REQUEST) &&
  55.          inet_addr_type(net, tip) == RTN_LOCAL &&
  56.          !arp_ignore(in_dev, sip, tip))
  57.             arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
  58.                  dev->dev_addr, sha);
  59.         goto out;
  60.     }

  62.     if (arp->ar_op == htons(ARPOP_REQUEST) &&
  63.      ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
  64.         /* ARP为request， ip_route_input_noref返回成功。即查找input route成功 */
  65.         rt = skb_rtable(skb);
  66.         addr_type = rt->rt_type;
         /* 路由的类型进行ARP的不同处理 */
  1.         if (addr_type == RTN_LOCAL) {
  2.             /* 该ARP应有本机处理 */
  3.             int dont_send = 0;
             /* 做是否dont send的检查 */
  1.             if (!dont_send)
  2.                 dont_send |= arp_ignore(in_dev,sip,tip);
  3.             if (!dont_send && IN_DEV_ARPFILTER(in_dev))
  4.                 dont_send |= arp_filter(sip,tip,dev);
  5.             if (!dont_send) {
  6.                 /* 
  7.                 查找sip对应的neibour信息，如没有，则将数据包的源l2地址sha和l3地址sip加入到表中                     */
  8.                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
  9.                 if (n) {
  10.                     /* 发送ARP reply */
  11.                     arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
  12.                     neigh_release(n);
  13.                 }
  14.             }
  15.             goto out;
  16.         } else if (IN_DEV_FORWARD(in_dev)) {
  17.             /* dev支持转发 */
  18.             if (addr_type == RTN_UNICAST &&
  19.              (arp_fwd_proxy(in_dev, dev, rt) ||
  20.              arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
  21.              pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))
  22.             {
  23.                 /* 
  24.                 本机enable了ARP proxy，并且与目的地址tip直连，且有tip对应的neighbour信息。
  25.                 那么，就要做arp proxy的工作了。
  26.                 */
                 
                 /*
                 将sha和sip加入到arp table中。 
                 */
  1.                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
  2.                 if (n)
  3.                     neigh_release(n);

  5.                 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
  6.                  skb->pkt_type == PACKET_HOST ||
  7.                  in_dev->arp_parms->proxy_delay == 0) {
  8.                     /* 回复ARP请求 */
  9.                     arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
  10.                 } else {
  11.                     /* 将数据包加入到arp table的队列中，由对应的timer handler处理 */
  12.                     pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb);
  13.                     return 0;
  14.                 }
  15.                 goto out;
  16.             }
  17.         }
  18.     }

  20.     /* Update our ARP tables */

  22.     n = __neigh_lookup(&arp_tbl, &sip, dev, 0);

  24.     if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
  25.         /* 如果dev指定接收所有的ARP */
  26.         /* Unsolicited ARP is not accepted by default.
  27.          It is possible, that this option should be enabled for some
  28.          devices (strip is candidate)
  29.          */
         /* 
         默认情况下，只接受回复自己请求的ARP，防止ARP攻击。
         但是有的情况下，linux作为中间设备，需要学习所有经过它的ARP，那么就需要打开这个option。
         当然这就引入了风险。
         */

         /*
         没有找到对应neighbou时且本机与sip直连，那么下面的2种情况下，
         本机会学习非回复请求的ARP，即unsolicited ARP；
         1. ARP是reply；
         2. ARP为gratuitous ARP；
         */
  1.         if (n == NULL &&
  2.          (arp->ar_op == htons(ARPOP_REPLY) ||
  3.          (arp->ar_op == htons(ARPOP_REQUEST) && tip == sip)) &&
  4.          inet_addr_type(net, sip) == RTN_UNICAST)
  5.             n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
  6.     }

  8.     if (n) {
  9.         /* 找到了对应的neighbour信息，那么就更新其时间戳即状态 */
  10.         int state = NUD_REACHABLE;
  11.         int override;

  13.         /* If several different ARP replies follows back-to-back,
  14.          use the FIRST one. It is possible, if several proxy
  15.          agents are active. Taking the first reply prevents
  16.          arp trashing and chooses the fastest router.
  17.          */
  18.         override = time_after(jiffies, n->updated + n->parms->locktime);

  20.         /* Broadcast replies and request packets
  21.          do not assert neighbour reachability.
  22.          */
  23.         if (arp->ar_op != htons(ARPOP_REPLY) ||
  24.          skb->pkt_type != PACKET_HOST)
  25.             state = NUD_STALE;
  26.         neigh_update(n, sha, state, override ? NEIGH_UPDATE_F_OVERRIDE : 0);
  27.         neigh_release(n);
  28.     }

  30. out:
  31.     consume_skb(skb);
  32.     return 0;
  33. }

ARP的接收流程比较简单，但是有一些特殊的ARP数据包，如检测重复IP，如果不看这个源代码，我都有些忘记了。而且从通过阅读代码，彻底搞清楚了，Linux更新ARP表的条件。
1. 如果数据包的L2地址是发送给别的主机或者回环的，则不处理；
2. 如ARP是发给本机且为request，则回复ARP并更新本机的ARP table；
3. 如ARP是需要转发，且本机为arp proxy，则回复并更新本机的ARP table；
4. 如本机指定了接收所有ARP，即接收unsolicited的ARP数据包，则在没有对应的ARP条目，且sip与本机直连：1）ARP为reply；2）ARP为gratuitous ARP时，更新ARP table；

上面的总结，并不是特别严谨，但大致的条件就是如此。


上一篇：Linux如何实现在一个CPU上只能有一个软中断运行实例
下一篇：TCP/IP学习(29)——kernel如何选择socket接收数据