网络子系统48_ip协议数据帧的发送

//ip协议与l4协议接口，l4通过此接口向下l3传递数据帧
//函数主要任务：
//	1.通过路由子系统路由封包
//	2.填充l3报头
//	3.ip分片
//	4.计算校验和
//	5.衔接邻居子系统，向下层传送封包。
1.1 int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
{
struct sock *sk = skb->sk;
struct inet_sock *inet = inet_sk(sk);
struct ip_options *opt = inet->opt;//选项与sock相关
struct rtable *rt;
struct iphdr *iph;

//检查skb是否已经被路由
rt = (struct rtable *) skb->dst;
if (rt != NULL)
goto packet_routed;
//检测ip的可用性
//dst->obsolete
//		0 	默认值，该结构有效可以被使用
//		2 	表示该结构将被删除因而不能被使用
//	   -1   表示该结构被IPsec和IPv6使用但不被IPv4使用
rt = (struct rtable *)__sk_dst_check(sk, 0);
if (rt == NULL) {//没有可用的路由信息，重新路由封包
u32 daddr;

daddr = inet->daddr;//sock中指定的目标ip地址
if(opt && opt->srr)//源路由选项
daddr = opt->faddr;//将第一跳地址作为目标地址

{
struct flowi fl = { .oif = sk->sk_bound_dev_if,//出口设备
.nl_u = { .ip4_u =
{ .daddr = daddr,//对目标地址进行路由，为sock中指定的目的地址，或者在源路由选项时，使用的第一跳地址
.saddr = inet->saddr,//源地址
.tos = RT_CONN_FLAGS(sk) } },//sock中指定的tos
.proto = sk->sk_protocol,//l4协议
.uli_u = { .ports =
{ .sport = inet->sport,
.dport = inet->dport } } };//源端口，目的端口

if (ip_route_output_flow(&rt, &fl, sk, 0))//对出口skb进行路由
goto no_route;
}
__sk_dst_set(sk, &rt->u.dst);
tcp_v4_setup_caps(sk, &rt->u.dst);//根据网卡对tso的支持，更新sk的tso
}
skb->dst = dst_clone(&rt->u.dst);//增加dst的引用计数

packet_routed:
if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)//处理严路由选项，下一跳地址必须为网管地址
goto no_route;

iph = (struct iphdr *) skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));//移动skb->data向上，准备填写ip报头
*((__u16 *)iph)	= htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));//设置报头长度为20字节，选项的长度，在ip_options_build中增加
iph->tot_len = htons(skb->len);//总长度，skb中所有数据的长度，包括报头，选项，有效载荷
if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)//检查禁止了分片
iph->frag_off = htons(IP_DF);//设置报头指示禁止分片
else
iph->frag_off = 0;//分片中的偏移量
iph->ttl      = ip_select_ttl(inet, &rt->u.dst);//生存周期
iph->protocol = sk->sk_protocol;//指示ip上层的l4协议类型
iph->saddr    = rt->rt_src;//源地址，目的地址
iph->daddr    = rt->rt_dst;
skb->nh.iph   = iph;

if (opt && opt->optlen) {//sock中设置了选项
iph->ihl += opt->optlen >> 2;
ip_options_build(skb, opt, inet->daddr, rt, 0);//处理选项
}

ip_select_ident_more(iph, &rt->u.dst, sk, skb_shinfo(skb)->tso_segs);//为ip选择id

ip_send_check(iph);//ip报头校验和

skb->priority = sk->sk_priority;//skb的优先级为sock的优先级，在dev_queue_xmit中用于在规则队列中排队

return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
dst_output);//调用dst->output，由ip_route_output_flow设置

no_route:
IP_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
kfree_skb(skb);
return -EHOSTUNREACH;
}

//调用路径ip_queue_xmit->ip_output或ip_forward_finish->ip_output
1.2 int ip_output(struct sk_buff *skb)
{
IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

if (skb->len > dst_pmtu(skb->dst) && !skb_shinfo(skb)->tso_size)
return ip_fragment(skb, ip_finish_output);//ip分片
else
return ip_finish_output(skb);
}

//调用路径ip_output->ip_finish_output
1.3 int ip_finish_output(struct sk_buff *skb)
{
struct net_device *dev = skb->dst->dev;

skb->dev = dev;//出口设备
skb->protocol = htons(ETH_P_IP);//skb准备向l2层传送，在skb->protocol中告诉l2层，上层l3的协议类型

return NF_HOOK(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev,
ip_finish_output2);//skb被路由之后的netfilter拦截点
}
//调用路径ip_output->ip_finish_output->ip_finish_output2
//函数主要任务：
//	1.保证skb头部足够空间容纳l2帧头
//	2.通过l2帧头缓存，拷贝l2帧头，完成向下层的传输
//	3.没有可供使用的l2帧头缓存，则衔接邻居子系统，交由邻居子系统处理skb
1.4 static inline int ip_finish_output2(struct sk_buff *skb)
{
struct dst_entry *dst = skb->dst;
struct hh_cache *hh = dst->hh;
struct net_device *dev = dst->dev;
int hh_len = LL_RESERVED_SPACE(dev);

if (unlikely(skb_headroom(skb) < hh_len && dev->hard_header)) {//skb头空间不足l2头，设备驱动提供了在skb中填充l2头的功能
struct sk_buff *skb2;

skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));//重新分配skb头来容纳l2头
if (skb2 == NULL) {
kfree_skb(skb);
return -ENOMEM;
}
if (skb->sk)
skb_set_owner_w(skb2, skb->sk);
kfree_skb(skb);
skb = skb2;
}

if (hh) {//l2帧头缓存
int hh_alen;

read_lock_bh(&hh->hh_lock);
hh_alen = HH_DATA_ALIGN(hh->hh_len);
memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);//拷贝帧头缓存中的l2帧头到skb中
read_unlock_bh(&hh->hh_lock);
skb_push(skb, hh->hh_len);
return hh->hh_output(skb);//通过l2帧头缓存的output函数，完成skb向下的传递
} else if (dst->neighbour)//没有l2帧头缓存，则需要邻居子系统，获取数据帧的l2地址
return dst->neighbour->output(skb);

if (net_ratelimit())
printk(KERN_DEBUG "ip_finish_output2: No header cache and no neighbour!\n");
kfree_skb(skb);
return -EINVAL;
}