数据包接收系列 — IP协议处理流程（二）
本文主要内容：在接收数据包时，IP协议的处理流程。
内核版本：2.6.37
Author：zhangskd @ csdn blog
我们接着来看数据包如何发往本地的四层协议。
ip_local_deliver
在ip_local_deliver()中，如果发现数据报有被分片，则进行组装。
然后调用NF_INET_LOCAL_IN处的钩子函数，如果数据包被钩子函数放行，
则调用ip_local_deliver_finish()继续处理。
/* Deliver IP Packets to the higher protocol layers. */
int ip_local_deliver(struct sk_buff *skb)
{
/*
* Reassemble IP fragments.
* 如果IP数据报有被分片，则在这里进行组装还原。
*/
if (ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)) {
if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))
return 0;
}
/* 调用netfilter的NF_INET_LOCAL_IN的钩子函数，如果此数据包被钩子函数放行，则调用
* ip_local_deliver_finish()继续处理。
*/
return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
ip_local_deliver_finish);
}
ip_local_deliver_finish
ip_local_deliver_finish()主要做了：
处理RAW IP，如果有配置安全策略，则进行IPsec安全检查。
根据IP报头的protocol字段，找到对应的L4协议(net_protocol)，调用该协议的接收函数net_protocol->handler()。
对于TCP协议，net_protocol实例为tcp_protocol，协议处理函数为tcp_v4_rcv()。
接下来就进入四层协议的处理流程了，TCP协议的入口函数为tcp_v4_rcv()。
static int ip_local_deliver_finish(struct sk_buff *skb)
{
struct net *net = dev_net(skb->dev);
/* 把skb->data指向L4协议头，更新skb->len */
__skb_pull(skb, ip_hdrlen(skb));
/* 赋值skb->transport_header */
skb_reset_transport_header(skb);
rcu_read_lock();
{
int protocol = ip_hdr(skb)->protocol; /* L4协议号 */
int hash, raw;
const struct net_protocol *ipprot;
resubmit:
/* 处理RAW IP */
raw = raw_local_deliver(skb, protocol);
hash = protocol & (MAX_INET_PROTOS - 1); /* 作为数组索引 */
/* 从inet_protos数组中取出对应的net_protocol元素，TCP的为tcp_protocol */
ipprot = rcu_dereference(inet_protos[hash]);
if (ipprot != NULL) {
int ret;
if (! net_eq(net, &init_net) && ! ipprot->netns_ok) {
if (net_ratelimit())
printk("%s: proto %d isn't netns-ready\n", __func__, protocol);
kfree_skb(skb);
goto out;
}
/* 如果需要检查IPsec安全策略 */
if (! ipprot->no_policy) {
if (! xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
kfree_skb(skb);
goto out;
}
nf_reset(skb);
}
/* 调用L4协议的处理函数，对于TCP，调用tcp_protocol->handler，为tcp_v4_rcv() */
ret = ipprot->handler(skb);
if (ret < 0) {
protocol = - ret;
goto resubmit;
}
IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
} else {
if (! raw) {
if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
IP_INC_STATS_BH(net, IPSTATS_MIB_INUNKNOWNPROTOS);
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0);
} else
IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);
kfree_skb(skb);
}
}
out:
rcu_read_unlock();
return 0;
}
L4协议处理函数
数据包从L2传递到L3时，通过packet_type结构来找到L3协议的处理函数。
同理，数据包从L3传递到L4时，通过net_protocol结构来找到L4协议的处理函数。
/* This is used to register protocols. */
struct net_protocol {
int (*handler) (struct sk_buff *skb); /* L4协议的接收函数 */
void (*error_handler) (struct sk_buff *skb, u32 info); /* ICMP用的 */
...
unsigned int no_policy:1, /* 不需要检查IPsec策略 */
netns_ok:1;
};
#define MAX_INET_PROTOS 256 /* MUST be a power of 2 */
把协议号作为索引，可以从数组找到对应协议的net_protocol元素。
const struct net_protocol __rcu *inet_protos[MAX_INET_PROTOS];
enum {
...
IPPROTO_ICMP = 1, /* Internet Control Message Protocol */
...
IPPROTO_TCP = 6, /* Transmission Control Protocol */
...
IPPROTO_UDP = 17, /* User Datagram Protocol */
...
IPPROTO_RAW = 255, /* Raw IP packets */
IPPROTO_MAX
};
/* TCP协议的net_protocol */
static const struct net_protocol tcp_protocol = {
.handler = tcp_v4_rcv,
.err_handler = tcp_v4_err,
...
.no_policy = 1,
.netns_ok = 1,
};
/* UDP协议的net_protocol */
static const struct net_protocol udp_protocol = {
.handler = udp_rcv,
.err_handler = upd_err,
...
.no_policy = 1,
.netns_ok = 1,
};
/* ICMP协议的net_protocl */
static const struct net_protocol icmp_protocol = {
.handler = icmp_rcv,
.no_policy = 1,
.netns_ok = 1,
};
初始化
static int __init inet_init(void)
{
...
/* Add all the base protocols */
if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
...
}
RAW IP
struct raw_hashinfo {
rwlock_t lock;
struct hlist_head ht[RAW_HTABLE_SIZE];
};
static struct raw_hashinfo raw_v4_hashinfo = {
.lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock);
};
#define RAW_HTABLE_SIZE MAX_INET_PROTOS
RAW IP报的处理函数为raw_v4_input()。
int raw_local_deliver(struct sk_buff *skb, int protocol)
{
int hash;
struct sock *raw_sk;
hash = protocol & (RAW_HTABLE_SIZE - 1); /* L4协议号作为key */
raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]); /* 取出哈希桶的第一个sock */
/* If there maybe a raw socket we must check - if not we don't care less.
* raw_v4_input(): IP input processing comes here for RAW socket delivery.
* 如果该协议上有连接，那么调用raw_v4_input()来处理。
*/
if (raw_sk && ! raw_v4_input(skb, ip_hdr(skb), hash))
raw_sk = NULL;
return raw_sk != NULL;
}
