linux协议栈ip层分析

学习目标：

熟悉ip层的职责？

熟练数据包如何通过ip层？

熟练ip数据重组的设计思路？

熟悉ip路由的思路？

熟悉netfilter的钩子函数处理？

 

1数据流路径

 

 

 

2职责

ip层的主要任务有下面5个方面： 

1、ip数据包的校验（包括数据包的完整性、格式正确性、校验和等）。

2、防火墙的处理(也就是netfilter子系统)。

3、处理options(这里的options包含了一些可选的信息。比如时间戳或者源路由option)。

4、分片和重组(由于mtu的存在，因此我们需要切包和组包)。

5、接收，输出和转发操作。

3分析各自函数的实现（直接上源码分析）

3.1ip_rcv

该函数主要功能是对ip格式合法性进行检查，然后将报文交给一下流程处理。如ip_rcv_finish。

/*

 *  Main IP Receive routine.

 */

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

{

struct iphdr *iph;

u32 len;

 

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

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

 *当网络结构设定为混杂模式时。当网卡处于混杂模式时，收到不是发往该主机的数据包，由net_rx_action()设置。在调用ip_rcv之前，内核会将该数据包交给嗅探器，所以该函数仅丢弃该包。

 */

if (skb->pkt_type == PACKET_OTHERHOST)

goto drop;

 

/* SNMP所需要的统计数据，暂不进行分析*/

IP_UPD_PO_STATS_BH(dev_net(dev), IPSTATS_MIB_IN, skb->len);

 

/* skb是否被其他模块共享进行检查。

 *ip_rcv是由netif_receive_skb函数调用，如果嗅探器或者其他的用户对数据包需要进

 *进行处理，则在调用ip_rcv之前，netif_receive_skb会增加skb的引用计数，既该引

 *用计数会大于1。若如此次，则skb_share_check会创建sk_buff的一份拷贝。

 */

if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {

IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);

goto out;

}

 

/*

 *pskb_may_pull确保skb->data指向的内存包含的数据至少为IP头部大小，由于每个

 *IP数据包包括IP分片必须包含一个完整的IP头部。如果小于IP头部大小，则缺失

 *的部分将从数据分片中拷贝。这些分片保存在skb_shinfo(skb)->frags[]中。

 */

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

goto inhdr_error;

 

/* 返回一个iph结构体，数据已经进行填充 */

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 至少一个20自己的ip头

 * 2. Version of 4  ipv4

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

校验和正确

 * 4. Doesn't have a bogus length

 */

 

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

goto inhdr_error;

 

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

goto inhdr_error;

 

iph = ip_hdr(skb);

 

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

goto inhdr_error;

 

/*确保skb的数据长度大于等于IP头部中指示的IP数据包总长度及数据包总长度必须

 *大于等于IP头部长度。

 */

len = ntohs(iph->tot_len);

if (skb->len < len) {

IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INTRUNCATEDPKTS);

goto drop;

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

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_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);

goto drop;

}

 

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

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

 

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

skb_orphan(skb);

/* 与netfilter子系统交互，如果防火墙未开，使用默认ip_rcv_finish*/

return NF_HOOK(PF_INET, NF_INET_PRE_ROUTING, skb, dev, NULL,

       ip_rcv_finish);

 

inhdr_error:

IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INHDRERRORS);

drop:

kfree_skb(skb);

out:

return NET_RX_DROP;

}

红色处，参考：http://blog.csdn.net/qy532846454/article/details/6605592

NF_HOOK(PF_INET, NF_INET_PRE_ROUTING, skb, dev, NULL,ip_rcv_finish)
执行顺序：

NF_HOOK()->NF_HOOK_THRESH()->nf_hook_thresh()->nf_hook_slow()；

NF_ACCEPT：表示允许报文完成后续操作，执行ip_rcv_finish。

3.2ip_rcv_finish

主要工作是完成路由表的查询，决定报文经过IP层处理后，是继续向上传递，还是进行转发，还是丢弃。

static int ip_rcv_finish(struct sk_buff *skb)

{

    const struct iphdr *iph = ip_hdr(skb);

    struct rtable *rt;

 

    /*

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

     *    how the packet travels inside Linux networking.

     */

    /*

     通常从外界接收的数据包,skb->dst不会包含路由信息，刚开始没有进行路由表查询，所以还没有相应的路由表项：skb_dst(skb) == NULL。 ip_route_input函数会根据路由表设置路由信息，暂时不分析路由系统。

     */

    if (skb->dst == NULL) {

        int err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos,

                     skb->dev);

        if (unlikely(err)) {

            if (err == -EHOSTUNREACH)

                IP_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);

            else if (err == -ENETUNREACH)

                IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES);

            goto drop;

        }

    }

/* 更新流量控制所需要的统计数据，暂不考虑 */

#ifdef  CONFIG_NET_CLS_ROUTE

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

        struct ip_rt_acct *st = ip_rt_acct + 256*smp_processor_id();

        u32 idx = skb->dst->tclassid;

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

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

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

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

    }

#endif

    /* 如果IP头部大于20字节，则表示IP头部包含IP选项，需要进行选项处理.暂不分析，毕竟很少用 */

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

        goto drop;

 

    /* skb->dst上面已经查找了路由表，所以有了路由信息。根据路由类型更新SNMP统计数据。*/

    rt = (struct rtable*)skb->dst;

    if (rt->rt_type == RTN_MULTICAST)

        IP_INC_STATS_BH(IPSTATS_MIB_INMCASTPKTS);

    else if (rt->rt_type == RTN_BROADCAST)

        IP_INC_STATS_BH(IPSTATS_MIB_INBCASTPKTS);

    /*

     * dst_input实际上会调用skb->dst->input(skb).input函数会根据路由信息设置为合适的函数指针，如果是递交到本地的则为ip_local_deliver，若是转发则为ip_forward.。暂时仅先考虑ip_local_deliver。

     */

    return dst_input(skb);

drop:

    kfree_skb(skb);

    return NET_RX_DROP;

}

3.3ip_local_deliver发往本机

主要功能：收集IP分片，然后调用ip_local_deliver_finish将一个完整的数据包传送给上层协议。

/*

 *     Deliver IP Packets to the higher protocol layers.

 */

int ip_local_deliver(struct sk_buff *skb)

{

    /*

     * 判断该IP数据包是否是一个分片，如果IP_MF置位，则表示该包是分片之一，其

     * 后还有更多分片，最后一个IP分片未置位IP_MF但是其offset是非0。

     * 如果是一个IP分片，则调用ip_defrag重新组织IP数据包。

     */

    if (ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)) {

        if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))

            return 0;

    }

    /* 调用ip_local_deliver_finish(skb) */

    return NF_HOOK(PF_INET, NF_IP_LOCAL_IN, skb, skb->dev, NULL,

         ip_local_deliver_finish);

}

3.3.1int ip_defrag(struct sk_buff *skb, u32 user)

Ip分片包进行重组，看看linux是如何对ip分片进行处理的，可以为以后一些开发提供好的思维。如dpdk中样例就是仿照linux中进行编写。

参考：http://blog.csdn.net/qy532846454/article/details/6744252

基本思想：

(1) 当内核接收到本地的IP包, 在传递给上层协议处理之前,先进行碎片重组。IP包片段之间的标识号(id)是相同的.当IP包片偏量(frag_off)第14位(IP_MF)为1时, 表示该IP包有后继片段。片偏量的低13位则为该片段在完整数据包中的偏移量, 以8字节为单位.。当IP_MF位为0时,表示IP包是最后一块碎片。

(2) 碎片重组由重组队列完成, 每一重组队列对应于(daddr,saddr,protocol,id)构成的键值,它们存在于ipq结构构成的散列链之中. 重组队列将IP包按照将片段偏移量的顺序进行排列,当所有的片段都到齐后, 就可以将队列中的包碎片按顺序拼合成一个完整的IP包.

(3) 如果30秒后重组队列内包未到齐, 则重组过程失败, 重组队列被释放,同时向发送方以ICMP协议通知失败信息.重组队列的内存消耗不得大于256k(sysctl_ipfrag_high_thresh),否则将会调用(ip_evictor)释放每支散列尾端的重组队列。、

几个问题：

1、hash值是否唯一？

jhash_3word 采用了一种hash算法，可以避免类似发生。

2、分片重叠和分片丢失、重发如何处理？

丢失：如果分片包不会到来，则删除整个队列和清楚hash表。

重叠/重发：重叠可能发生两种情况（与前一片重叠，后一片重叠）

 

在收到IP分片时，会暂时存储到一个哈希表ip4_frags中，它在IP协议模块加载时初始化，inet_init() -> ipfrag_init()。要留意的是ip4_frag_match用于匹配IP分片是否属于同一个报文；ip_expire用于在IP分片超时时进行处理。

初始化过程：

void __init ipfrag_init(void)

{

 ip4_frags_ctl_register();

 register_pernet_subsys(&ip4_frags_ops);

 ip4_frags.hashfn = ip4_hashfn;

 ip4_frags.constructor = ip4_frag_init;

 ip4_frags.destructor = ip4_frag_free;

 ip4_frags.skb_free = NULL;

 ip4_frags.qsize = sizeof(struct ipq);

 ip4_frags.match = ip4_frag_match; 

 ip4_frags.frag_expire = ip_expire;

 ip4_frags.secret_interval = 10 * 60 * HZ;

 inet_frags_init(&ip4_frags);

}

 

/* Process an incoming IP datagram fragment. */

int ip_defrag(struct sk_buff *skb, u32 user)

{

    struct ipq *qp;

 

    IP_INC_STATS_BH(IPSTATS_MIB_REASMREQDS);

 

    /* Start by cleaning up the memory. */

    /*

     * 首先检查所有IP分片所消耗的内存是否大于系统允许的最高阀值，如果是，则调用ip_evictor()丢弃未完全到达的IP分片，从最旧的分片开始释放。此举一来是为了节约内存，二来是未了防止黑客的恶意攻击。使分片在系统中累计，降低系统性能。

     */

    if (atomic_read(&ip4_frags.mem) > ip4_frags_ctl.high_thresh)

        ip_evictor();

 

    /* Lookup (or create) queue header */

    /* 如果该分片是数据报的第一个分片，则ip_find返回一个新的队列来搜集分片，否则返回其所属于的分片队列。*/

    if ((qp = ip_find(ip_hdr(skb), user)) != NULL) {

        int ret;

 

        spin_lock(&qp->q.lock);

    /* 将该分片加入到队列中，重组分片队列，如果所有的包都收到了，则该函数负责重组IP包*/

        ret = ip_frag_queue(qp, skb);

 

        spin_unlock(&qp->q.lock);

        ipq_put(qp);    /* 引用计数减1 */

        return ret;

    }

 

    IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);

    kfree_skb(skb);

    return -ENOMEM;

}

 

/* Find the correct entry in the "incomplete datagrams" queue for

 * this IP datagram, and create new one, if nothing is found.

 */

/* u32 user这个参数有点迷惑，其表示以何种理由需要对数据包进行重组，在ip_local_deliver的调用序列当中，这个值是IP_DEFRAG_LOCAL_DELIVER。*/

static inline struct ipq *ip_find(struct iphdr *iph, u32 user)

{

    struct inet_frag_queue *q;

    struct ip4_create_arg arg;

    unsigned int hash;

 

    arg.iph = iph;

    arg.user = user;

    /* hash值为：(识，源IP，目的IP，协议号)

     * hash算法，该算法除了使用所给的这四个参数之外，还使用了一个随机值

     * ip4_frags.rnd,，其初始化为

     * (u32) ((num_physpages ^ (num_physpages>>7)) ^ (jiffies ^ (jiffies >> 6)));

     * 这是为了防止黑客根据固定的hash算法，通过设置ip头部的这些字段，生成同样

     * HASH值，从而使某一HASH队列长度急剧增大而影响性能。

     */

    hash = ipqhashfn(iph->id, iph->saddr, iph->daddr, iph->protocol);

    /* 若存在该分片所属的分片队列则返回这个队列，否则创建一个新的队列 */

    q = inet_frag_find(&ip4_frags, &arg, hash);

    if (q == NULL)

        goto out_nomem;

 

    return container_of(q, struct ipq, q);

 

out_nomem:

    LIMIT_NETDEBUG(KERN_ERR "ip_frag_create: no memory left !\n");

    return NULL;

}

inet_frag_find根据hash值取ip4_frag->hash[hash]项 – inet_frag_queue，它是一个队列，然后遍历该队列，当net, id, saddr, daddr, protocol, user相匹配时，就是要找的IP分片。如果没有匹配的，则调用inet_frag_create创建它。

struct inet_frag_queue *inet_frag_find(struct inet_frags *f, void *key,

        unsigned int hash)

{

    struct inet_frag_queue *q;

    struct hlist_node *n;

 

    /* f->lock是读写锁，先搜索是否存在该IP分段所属的队列 */

    read_lock(&f->lock);

    hlist_for_each_entry(q, n, &f->hash[hash], list) { 

/* 扫描该HASH槽中所有节点 f->match中match字段在ipfrag_init中初始化为ip4_frag_match函数。对比分片队列中的散列字段和user是否和key相等，key指向的是struct ip4_create_arg结构，包含IP头部和user字段。 */

        if (f->match(q, key)) {

            atomic_inc(&q->refcnt);     /* 若找到，则增加该队列引用计数。 */

            read_unlock(&f->lock);

            return q;                /* 返回该队列 */

        }

    }

    read_unlock(&f->lock);

    /* 该分片是第一个IP分片，创建一个新的分片队列并添加到合适的HASH队列 */

    return inet_frag_create(f, key, hash);

}

ip_frag_queue将到来的分片进行重组：

/* Add new segment to existing queue. */

ip_frag_queue()函数将新来的skb包插入队列节点中，这个函数是防御各种碎片攻击的关键，要能处理各种异常的重组过程：

static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)

{

struct sk_buff *prev, *next;

struct net_device *dev;

int flags, offset;

int ihl, end;

int err = -ENOENT;

/* 对已经有INET_FRAG_COMPLETE标志的的队列节点，后续来的数据包都丢弃。*/

if (qp->q.last_in & INET_FRAG_COMPLETE)

goto err;

 

if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) &&

    unlikely(ip_frag_too_far(qp)) &&

    unlikely(err = ip_frag_reinit(qp))) {

ipq_kill(qp);

goto err;

}

/* 计算当前包的偏移值，IP头中的偏移值只有13位,但表示的是8字节的倍数。*/

offset = ntohs(ip_hdr(skb)->frag_off);

flags = offset & ~IP_OFFSET;

offset &= IP_OFFSET;

offset <<= 3; /* offset is in 8-byte chunks */

ihl = ip_hdrlen(skb);

 

/* Determine the position of this fragment. --计算片段的位置 */

end = offset + skb->len - ihl;

err = -EINVAL;

 

/* Is this the final fragment?  -- 是最后一个分片吗？*/

if ((flags & IP_MF) == 0) {

/* If we already have some bits beyond end

 * or have different end, the segment is corrrupted.

如果我们有一些位已经超过了结束end，或者有不同的结束，这个分片时被破坏。

 */

if (end < qp->q.len ||

    ((qp->q.last_in & INET_FRAG_LAST_IN) && end != qp->q.len))

goto err;

qp->q.last_in |= INET_FRAG_LAST_IN; //最后一个分包

qp->q.len = end;

} else {

//仍然存在后续的分片包,检查数据长度是否是8字节对齐的

if (end&7) {

end &= ~7;

if (skb->ip_summed != CHECKSUM_UNNECESSARY)

skb->ip_summed = CHECKSUM_NONE;

}

//长度超过当前记录的长度

if (end > qp->q.len) {

/* Some bits beyond end -> corruption. */

if (qp->q.last_in & INET_FRAG_LAST_IN)

goto err;

qp->q.len = end;

}

}

if (end == offset)

goto err;

 

err = -ENOMEM;

//去掉IP头部分，只保留数据部分

if (pskb_pull(skb, ihl) == NULL)

goto err;

//将skb包长度调整为end-offset, 该值为该skb包中的实际有效数据长度

err = pskb_trim_rcsum(skb, end - offset);

if (err)

goto err;

 

/* Find out which fragments are in front and at the back of us

 * in the chain of fragments so far. We must know where to put

 * this fragment, right?

 */

//确定当前包在完整包中的位置,分片包不一定是顺序到达目的端的,有可能是杂乱顺序的,因此需要调整包的顺序.

prev = NULL;

for (next = qp->q.fragments; next != NULL; next = next->next) {

if (FRAG_CB(next)->offset >= offset)

break; /* bingo! */

prev = next;

}

 

/* We found where to put this one.  Check for overlap with

 * preceding fragment, and, if needed, align things so that

 * any overlaps are eliminated.

 */

//检查偏移是否有重叠,重叠是允许的,只要是正确的

if (prev) {

int i = (FRAG_CB(prev)->offset + prev->len) - offset;

//大于0 说明发生了重叠

if (i > 0) {

offset += i;

err = -EINVAL;

if (end <= offset)

goto err;

err = -ENOMEM;

if (!pskb_pull(skb, i))

goto err;

if (skb->ip_summed != CHECKSUM_UNNECESSARY)

skb->ip_summed = CHECKSUM_NONE;

}

}

 

err = -ENOMEM;

//如果重叠,则队列后面的所有包的偏移值都要调整,数据包长度的累加值也要相应减小。

while (next && FRAG_CB(next)->offset < end) {

int i = end - FRAG_CB(next)->offset; /* overlap is 'i' bytes */

 

if (i < next->len) {

/* Eat head of the next overlapped fragment

 * and leave the loop. The next ones cannot overlap.

 */

if (!pskb_pull(next, i))

goto err;

FRAG_CB(next)->offset += i;

qp->q.meat -= i;

if (next->ip_summed != CHECKSUM_UNNECESSARY)

next->ip_summed = CHECKSUM_NONE;

break;

} else {

struct sk_buff *free_it = next;

 

/* Old fragment is completely overridden with

 * new one drop it.

 */

next = next->next;

 

if (prev)

prev->next = next;

else

qp->q.fragments = next;

 

qp->q.meat -= free_it->len;

frag_kfree_skb(qp->q.net, free_it, NULL);

}

}

// skb记录自己的偏移值

FRAG_CB(skb)->offset = offset;

 

/* Insert this fragment in the chain of fragments. */

skb->next = next;

if (prev)

prev->next = skb;

else

qp->q.fragments = skb;

 

dev = skb->dev;

if (dev) {

qp->iif = dev->ifindex;

skb->dev = NULL;

}

qp->q.stamp = skb->tstamp;

qp->q.meat += skb->len;

atomic_add(skb->truesize, &qp->q.net->mem);

if (offset == 0)

qp->q.last_in |= INET_FRAG_FIRST_IN;

 

if (qp->q.last_in == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) &&

    qp->q.meat == qp->q.len)

return ip_frag_reasm(qp, prev, dev);

 

write_lock(&ip4_frags.lock);

list_move_tail(&qp->q.lru_list, &qp->q.net->lru_list);

write_unlock(&ip4_frags.lock);

return -EINPROGRESS;

 

err:

kfree_skb(skb);

return err;

}

3.3.2ip_local_deliver_finish

如果忽略掉原始套接字和IPSec，则该函数仅仅是根据IP头部中的协议字段选择上层L4协议，并交给它来处理。

static int ip_local_deliver_finish(struct sk_buff *skb)

{

    /* 跳过IP头部 */

    __skb_pull(skb, ip_hdrlen(skb));

 

    /* Point into the IP datagram, just past the header. */

    /* 设置传输层头部位置 */

    skb_reset_transport_header(skb);

 

    rcu_read_lock();

    {

        /* Note: See raw.c and net/raw.h, RAWV4_HTABLE_SIZE==MAX_INET_PROTOS */

        int protocol = ip_hdr(skb)->protocol;

        int hash;

        struct sock *raw_sk;

        struct net_protocol *ipprot;

 

    resubmit:

    /* 这个hash根本不是哈希值，仅仅只是inet_protos数组中的下表而已 */

        hash = protocol & (MAX_INET_PROTOS - 1);

        raw_sk = sk_head(&raw_v4_htable[hash]);

 

        /* If there maybe a raw socket we must check - if not we

         * don't care less

         */

    /* 原始套接字？？ 忽略... */

        if (raw_sk && !raw_v4_input(skb, ip_hdr(skb), hash))

            raw_sk = NULL;

    /* 查找注册的L4层协议处理结构。 */

        if ((ipprot = rcu_dereference(inet_protos[hash])) != NULL) {

            int ret;

    /* 启用了安全策略，则交给IPSec */

            if (!ipprot->no_policy) {

                if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {

                    kfree_skb(skb);

                    goto out;

                }

                nf_reset(skb);

            }

    /* 调用L4层协议处理函数 */

    /* 通常会是tcp_v4_rcv, udp_rcv, icmp_rcv和igmp_rcv */

    /* 如果注册了其他的L4层协议处理，则会进行相应的调用。 系统启动的时候回初始化相应的四层函数*/

            ret = ipprot->handler(skb);

            if (ret < 0) {

                protocol = -ret;

                goto resubmit;

            }

            IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);

        } else {

            if (!raw_sk) {    /* 无原始套接字，提交给IPSec */

                if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {

                    IP_INC_STATS_BH(IPSTATS_MIB_INUNKNOWNPROTOS);

                    icmp_send(skb, ICMP_DEST_UNREACH,

                         ICMP_PROT_UNREACH, 0);

                }

            } else

                IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);

            kfree_skb(skb);

        }

    }

 out:

    rcu_read_unlock();

 

    return 0;

}

3.4转发ip_forward

主要做一些路由转发的功能，一般PC上不会使用转发功能（PC如果不是自己处理的包，肯定就不会要），只有那些需要开启转发业务的数据包才有用。

int ip_forward(struct sk_buff *skb)

{

struct iphdr *iph; /* Our header */

struct rtable *rt; /* Route we use */

struct ip_options * opt = &(IPCB(skb)->opt);

/* gso相关设置，对gso不熟悉 */

if (skb_warn_if_lro(skb))

goto drop;

/* 策略检查 */

if (!xfrm4_policy_check(NULL, XFRM_POLICY_FWD, skb))

goto drop;

/*

 *如果router alert option被设置了,则立即交由ip_call_ra_chain处理数据包.ip_call_ra_chain函数轮询一个全局链表ip_ra_chain.此全局链表中是一些设置了IP_ROUTER_ALERT的sockets.因为这些sockets对设置了Router Alert option的ip包感兴趣.如果数据包为分片的,则将分片数据包组装好后发给ip_ra_chain链表中的原始套接口中的相关接收函数.(raw sockets)

 */

if (IPCB(skb)->opt.router_alert && ip_call_ra_chain(skb))

return NET_RX_SUCCESS;

 

if (skb->pkt_type != PACKET_HOST)

goto drop;

 

skb_forward_csum(skb);

 

/*

 * According to the RFC, we must first decrease the TTL field. If

 * that reaches zero, we must reply an ICMP control message telling

 * that the packet's lifetime expired.

 */

if (ip_hdr(skb)->ttl <= 1)

goto too_many_hops;

 

if (!xfrm4_route_forward(skb))

goto drop;

 

rt = skb_rtable(skb);

/*设置了严格ip源站选路选项(必须按发送者指定的路线走),目的地址不是网关*/

if (opt->is_strictroute && rt->rt_dst != rt->rt_gateway)

goto sr_failed;

 

if (unlikely(skb->len > dst_mtu(&rt->u.dst) && !skb_is_gso(skb) &&

     (ip_hdr(skb)->frag_off & htons(IP_DF))) && !skb->local_df) {

IP_INC_STATS(dev_net(rt->u.dst.dev), IPSTATS_MIB_FRAGFAILS);

icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,

  htonl(dst_mtu(&rt->u.dst)));

goto drop;

}

 

/* We are about to mangle packet. Copy it! */

if (skb_cow(skb, LL_RESERVED_SPACE(rt->u.dst.dev)+rt->u.dst.header_len))

goto drop;

iph = ip_hdr(skb);

 

/* Decrease ttl after skb cow done */

ip_decrease_ttl(iph);

 

/*

 * We now generate an ICMP HOST REDIRECT giving the route

 * we calculated.

 */

if (rt->rt_flags&RTCF_DOREDIRECT && !opt->srr && !skb_sec_path(skb))

ip_rt_send_redirect(skb);

 

skb->priority = rt_tos2priority(iph->tos);

 

return NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, rt->u.dst.dev,

       ip_forward_finish);

 

sr_failed:

/*

 * Strict routing permits no gatewaying

 */

 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0);

 goto drop;

 

too_many_hops:

/* Tell the sender its packet died... */

IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_INHDRERRORS);

icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);

drop:

kfree_skb(skb);

return NET_RX_DROP;

}

3.4.1转发 ip_forward_finish

static int ip_forward_finish(struct sk_buff *skb)

{

struct ip_options * opt = &(IPCB(skb)->opt);

 

IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);

 

if (unlikely(opt->optlen))

ip_forward_options(skb);

 

return dst_output(skb);

}