ip_rcv && ip_rcv

ip层收包流程概述：

(1) 在inet_init中注册了类型为ETH_P_IP协议的数据包的回调ip_rcv

(2) 当二层数据包接收完毕，会调用netif_receive_skb根据协议进行向上层分发

(3) 类型为ETH_P_IP类型的数据包，被传递到三层，调用ip_rcv函数

(4) ip_rcv完成基本的校验和处理工作后，经过PRE_ROUTING钩子点

(5) 经过PRE_ROUTING钩子点之后，调用ip_rcv_finish完成数据包接收，包括选项处理，路由查询，并且根据路由决定数据包是发往本机还是转发

以下为源码分析：

 static struct packet_type ip_packet_type __read_mostly = {

     .type = cpu_to_be16(ETH_P_IP),

     .func = ip_rcv,

 };

 /*

  *     Main IP Receive routine.

  */

 int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)

 {

     const struct iphdr *iph;

     struct net *net;

     u32 len;

     /* When the interface is in promisc. mode, drop all the crap

      * that it receives, do not try to analyse it.

      */

     /* 混杂模式下，非本机包 */

     if (skb->pkt_type == PACKET_OTHERHOST)

         goto drop;

     /* 获取net */

     net = dev_net(dev);

     __IP_UPD_PO_STATS(net, IPSTATS_MIB_IN, skb->len);

     /* 检查skb共享 */

     skb = skb_share_check(skb, GFP_ATOMIC);

     if (!skb) {

         __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);

         goto out;

     }

     /* 测试是否可以取得ip头 */

     if (!pskb_may_pull(skb, sizeof(struct iphdr)))

         goto inhdr_error;

     /* 取ip头 */

     iph = ip_hdr(skb);

     /*

      *    RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.

      *

      *    Is the datagram acceptable?

      *

      *    1.    Length at least the size of an ip header

      *    2.    Version of 4

      *    3.    Checksums correctly. [Speed optimisation for later, skip loopback checksums]

      *    4.    Doesn't have a bogus length

      */

     /* 头部长度不足20 或者版本不是4 */

     if (iph->ihl <  || iph->version != )

         goto inhdr_error;

     BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);

     BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);

     BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);

     __IP_ADD_STATS(net,

                IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),

                max_t(unsigned short, , skb_shinfo(skb)->gso_segs));

     /* 测试实际应取的ip头 */

     if (!pskb_may_pull(skb, iph->ihl*))

         goto inhdr_error;

     /* 取ip头 */

     iph = ip_hdr(skb);

     /* 校验和错误 */

     if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))

         goto csum_error;

     /* 取总长度 */

     len = ntohs(iph->tot_len);

     /* skb长度比ip包总长度小 */

     if (skb->len < len) {

         __IP_INC_STATS(net, IPSTATS_MIB_INTRUNCATEDPKTS);

         goto drop;

     }

     /* 比头部长度还小 */

     else if (len < (iph->ihl*))

         goto inhdr_error;

     /* Our transport medium may have padded the buffer out. Now we know it

      * is IP we can trim to the true length of the frame.

      * Note this now means skb->len holds ntohs(iph->tot_len).

      */

     /* 设置总长度为ip包的长度 */

     if (pskb_trim_rcsum(skb, len)) {

         __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);

         goto drop;

     }

     /* 取得传输层头部 */

     skb->transport_header = skb->network_header + iph->ihl*;

     /* Remove any debris in the socket control block */

     /* 重置cb */

     memset(IPCB(skb), , sizeof(struct inet_skb_parm));

     /* 保存输入设备信息 */

     IPCB(skb)->iif = skb->skb_iif;

     /* Must drop socket now because of tproxy. */

     skb_orphan(skb);

     /* 经过PRE_ROUTING钩子点 */

     return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,

                net, NULL, skb, dev, NULL,

                ip_rcv_finish);

 csum_error:

     __IP_INC_STATS(net, IPSTATS_MIB_CSUMERRORS);

 inhdr_error:

     __IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);

 drop:

     kfree_skb(skb);

 out:

     return NET_RX_DROP;

 }

 static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)

 {

     const struct iphdr *iph = ip_hdr(skb);

     struct rtable *rt;

     struct net_device *dev = skb->dev;

     void (*edemux)(struct sk_buff *skb);

     /* if ingress device is enslaved to an L3 master device pass the

      * skb to its handler for processing

      */

     skb = l3mdev_ip_rcv(skb);

     if (!skb)

         return NET_RX_SUCCESS;

     /*

         启用了early_demux

         skb路由缓存为空

         skb的sock为空

         不是分片包

     */

     if (net->ipv4.sysctl_ip_early_demux &&

         !skb_dst(skb) &&

         !skb->sk &&

         !ip_is_fragment(iph)) {

         const struct net_protocol *ipprot;

         /* 找到上层协议 */

         int protocol = iph->protocol;

         /* 获取协议对应的prot */

         ipprot = rcu_dereference(inet_protos[protocol]);

         /* 找到early_demux函数，如tcp_v4_early_demux */

         if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) {

             /* 调用该函数，将路由信息缓存到skb->refdst */

             edemux(skb);

             /* must reload iph, skb->head might have changed */

             /* 重新取ip头 */

             iph = ip_hdr(skb);

         }

     }

     /*

      *    Initialise the virtual path cache for the packet. It describes

      *    how the packet travels inside Linux networking.

      */

     /* 校验路由失败 */

     if (!skb_valid_dst(skb)) {

         /* 查路由 */

         int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,

                            iph->tos, dev);

         if (unlikely(err)) {

             if (err == -EXDEV)

                 __NET_INC_STATS(net, LINUX_MIB_IPRPFILTER);

             goto drop;

         }

     }

 #ifdef CONFIG_IP_ROUTE_CLASSID

     if (unlikely(skb_dst(skb)->tclassid)) {

         struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);

         u32 idx = skb_dst(skb)->tclassid;

         st[idx&0xFF].o_packets++;

         st[idx&0xFF].o_bytes += skb->len;

         st[(idx>>)&0xFF].i_packets++;

         st[(idx>>)&0xFF].i_bytes += skb->len;

     }

 #endif

     /* 处理ip选项 */

     if (iph->ihl >  && ip_rcv_options(skb))

         goto drop;

     /* 找到路由缓存项 */

     rt = skb_rtable(skb);

     if (rt->rt_type == RTN_MULTICAST) {

         __IP_UPD_PO_STATS(net, IPSTATS_MIB_INMCAST, skb->len);

     } else if (rt->rt_type == RTN_BROADCAST) {

         __IP_UPD_PO_STATS(net, IPSTATS_MIB_INBCAST, skb->len);

     } else if (skb->pkt_type == PACKET_BROADCAST ||

            skb->pkt_type == PACKET_MULTICAST) {

         struct in_device *in_dev = __in_dev_get_rcu(dev);

         /* RFC 1122 3.3.6:

          *

          *   When a host sends a datagram to a link-layer broadcast

          *   address, the IP destination address MUST be a legal IP

          *   broadcast or IP multicast address.

          *

          *   A host SHOULD silently discard a datagram that is received

          *   via a link-layer broadcast (see Section 2.4) but does not

          *   specify an IP multicast or broadcast destination address.

          *

          * This doesn't explicitly say L2 *broadcast*, but broadcast is

          * in a way a form of multicast and the most common use case for

          * this is 802.11 protecting against cross-station spoofing (the

          * so-called "hole-196" attack) so do it for both.

          */

         if (in_dev &&

             IN_DEV_ORCONF(in_dev, DROP_UNICAST_IN_L2_MULTICAST))

             goto drop;

     }

     /* 调用路由项的input函数，可能为ip_local_deliver或者ip_forward */

     return dst_input(skb);

 drop:

     kfree_skb(skb);

     return NET_RX_DROP;

 }

巴特西

ip_rcv && ip_rcv_finish

最新文章

热门文章