Chinaunix首页 | 论坛 | 博客

一个在外面滚动的球rainballdh.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

rainballdh

  • 博客访问： 963432
  • 博文数量： 58
  • 博客积分： 10192
  • 博客等级： 上将
  • 技术积分： 1845
  • 用 户 组： 普通用户
  • 注册时间： 2010-11-22 21:24
文章分类

全部博文（58）

文章存档

2011年（11）

2010年（12）

2009年（20）

2008年（15）

我的朋友
最近访客
推荐博文
相关博文
Linux下IP数据包的接受流程分析和选项处理初步分析

分类： LINUX

2010-12-18 12:11:16

一.内核会在每层上都把流量传送至正确的协议，就是调用该协议所注册的处理程序函数。IP协议注册的处理程序函数就是ip_rcv函数（可以查看我写的《IP协议注册流程》）。

 

  1. /*

  3.  * Main IP Receive routine.

  5.  */

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

  9. {

  11. struct iphdr *iph;


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

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

  18.                * 如果数据帧的L2的目的地址和接收接口的地址不同时，

  20.  * skb->pkt_type就会设置为 PACKET_OTHERHOST。

  22.                * 通常情况下都会被NIC本身丢弃

  24.  */

  26. if (skb->pkt_type == PACKET_OTHERHOST)

  28. goto drop;


  31. IP_INC_STATS_BH(IPSTATS_MIB_INRECEIVES);


  34. /*

  36.                * skb的引用计数是否大于1？

  38.                * 如果大于1，克隆一份缓冲区副本使其可以修改其封包

  40.                *

  42.                */

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

  46. IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);

  48. goto out;

  50. }


  53. /*

  55.                * 判断skb->data所指区域的数据区块至少和IP报头一样大

  57.                * sizeof(struct iphdr) <= skb_headlen(skb)

  59.                */

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

  63. goto inhdr_error;


  66. /*

  68.                * skb空间可能会被pskb_may_pull改变

  70.                * iph需要重新赋值

  72.                */

  74. iph = skb->nh.iph;


  77. /*

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

  81.  *

  83.  * Is the datagram acceptable?

  85.  *

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

  89.  * 2. Version of 4

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

  93.  * 4. Doesn't have a bogus length

  95.  */


  98. /* 5*4 == ip header ，IP头至少为20个字节 */

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

  102. goto inhdr_error;


  105. /*

  107.                * 完整的IP报头大小：ip header length + ip options length

  109.                */

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

  113. goto inhdr_error;


  116. iph = skb->nh.iph;


  119. if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)

  121. goto inhdr_error;


  124. {

  126. __u32 len = ntohs(iph->tot_len);

  128. if (skb->len < len || len < (iph->ihl<<2))

  130. goto inhdr_error;


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

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

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

  139.  */

  141. if (skb->len > len) {

  143. __pskb_trim(skb, len);

  145.                                           /*

  147.                                            * __pskb_trim会修改skb，

  149.                                            * 硬件支持校验的话，就会出错

  151.                                            * 所以重置为 CHECKSUM_NONE

  153.                                            */

  155. if (skb->ip_summed == CHECKSUM_HW)

  157. skb->ip_summed = CHECKSUM_NONE;

  159. }

  161. }


  164. return NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, dev, NULL,

  166.        ip_rcv_finish);


  169. inhdr_error:

  171. IP_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);

  173. drop:

  175.         kfree_skb(skb);

  177. out:

  179.         return NET_RX_DROP;

  181. }

 

二.ip_rcv所做的仅是封包的基本健康检查。真正数据包操作是ip_rcv_finish完成的。

 

  1. static inline int ip_rcv_finish(struct sk_buff *skb)

  3. {

  5. struct net_device *dev = skb->dev;

  7. struct iphdr *iph = skb->nh.iph;


  10. /*

  12.  * skb->dst包含目的地的路由信息。

  14.  * 如果没有包含目的地的路由信息，就会调用ip_route_input()。

  16.  * 询问路由子系统往哪里发送，如果路由子系统没找到路由，就丢弃skb。

  18.  */

  20. if (skb->dst == NULL) {

  22. if (ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, dev))

  24. goto drop;

  26. }


  29.               ...省略

  31. if (iph->ihl > 5) {

  33. struct ip_options *opt;


  36. /* It looks as overkill, because not all

  38.    IP options require packet mangling.

  40.    But it is the easiest for now, especially taking

  42.    into account that combination of IP options

  44.    and running sniffer is extremely rare condition.

  46.                                       --ANK (980813)

  48. */


  51. if (skb_cow(skb, skb_headroom(skb))) {

  53. IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);

  55. goto drop;

  57. }

  59. iph = skb->nh.iph;


  62.                             /*

  64.                              * 解析报头中携带的IP选项

  66.                              * 如果封包是由来源地路由的话，

  68.                              * 则需要分析选项是否配置“严格和松散路由选项”

  70.                              */

  72. if (ip_options_compile(NULL, skb))

  74. goto inhdr_error;


  77. opt = &(IPCB(skb)->opt);

  79. if (opt->srr) {

  81.                                           /*

  83.                                            * 以下操作主要判断数据包是发往本地还是转发

  85.                                            * 对skb->dst（路由信息）进行赋值操作

  87.                                            */

  89. struct in_device *in_dev = in_dev_get(dev);

  91. if (in_dev) {

  93. if (!IN_DEV_SOURCE_ROUTE(in_dev)) {

  95. if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())

  97. printk(KERN_INFO "source route option %u.%u.%u.%u -> %u.%u.%u.%u\n",

  99.        NIPQUAD(iph->saddr), NIPQUAD(iph->daddr));

  101. in_dev_put(in_dev);

  103. goto drop;

  105. }

  107. /* 转发还是本地发送 */

  109. in_dev_put(in_dev);

  111. }

  113. if (ip_options_rcv_srr(skb))

  115. goto drop;

  117. }

  119. }

  121. /*
  122.                 * dst_input（存储与skb->dst->input）会根据IP包是发送本地还是转发

  124.                 * 发往本地(dst_input等于ip_local_deliver)调用ip_local_deliver

  126.                 * 转发调用ip_forward

  128.                 */

  130. return dst_input(skb);


  133. inhdr_error:

  135. IP_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);

  137. drop:

  139.         kfree_skb(skb);

  141.         return NET_RX_DROP;

  143. }

 

三. 选项处理

1.struct ip_options结构体：

 

  1. struct ip_options表示IP选项


  4. struct ip_options {


  7.     __be32 faddr;


  10.     unsigned char optlen;


  13.     unsigned char srr;


  16.     unsigned char rr;


  19.     unsigned char ts;


  22.     unsigned char is_data:1,


  25.                     is_strictroute:1,


  28.                     srr_is_hit:1,


  31.                     is_changed:1,


  34.                     rr_needaddr:1,


  37.                     ts_needtime:1,


  40.                     ts_needaddr:1;


  43.     unsigned char router_alert;


  46.     unsigned char cipso;


  49.     unsigned char __pad2;


  52.     unsigned char __data[0];


  55. };


  58.     faddr用于在IPOPT_LSRR和IPOPT_SSRR选项时，记录下一站的IP地址


  61.     optlen是IP首部中选项所占据的长度


  64.     srr记录IPOPT_LSRR或IPOPT_SSRR选项在IP首部中的偏移量(选项的第一个字节的地址减去IP首部的第一个 字节的地址)


  67.     rr用于记录 IPOPT_RR选项在IP首部中的偏移量


  70.     ts用于记录IPOPT_TIMESTAMP选项在IP首部中的偏移量


  73.     is_data表示该IP选项拥有数据，选项数据存放在__data中


  76.     is_strictroute表示该选项是IPOPT_SSRR，而不是IPOPT_LSRR


  79.     srr_is_hit跟源站路由选项相关，对IP选项作过任何的修改，需要把is_changed置1


  82.     rr_needaddr表示有IPOPT_RR选项，需要记录IP地址


  85.     ts_needtime表示IPOPT_TIMESTAMP选项需要记录时间戳


  88.     ts_needaddr表示IPOPT_TIMESTAMP选项需要记录IP地址


  91.     router_alert用于IPOPT_RA选项

 

2.ip_options_compile函数主要是分析skb中的IP选项。

  1. int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)

  3. {

  5. int l;

  7. unsigned char * iph;

  9. unsigned char * optptr;

  11. int optlen;

  13. unsigned char * pp_ptr = NULL;

  15. struct rtable *rt = skb ? (struct rtable*)skb->dst : NULL;


  18. if (!opt) {

  20.                             /* opt == NULL 处理入口的封包 */

  22. opt = &(IPCB(skb)->opt);

  24. memset(opt, 0, sizeof(struct ip_options));

  26. iph = skb->nh.raw;

  28. opt->optlen = ((struct iphdr *)iph)->ihl*4 - sizeof(struct iphdr);

  30. optptr = iph + sizeof(struct iphdr);

  32. opt->is_data = 0;

  34. } else {

  36.                             /* opt ！= NULL 封包正被传输 */

  38. optptr = opt->is_data ? opt->__data : (unsigned char*)&(skb->nh.iph[1]);

  40. iph = optptr - sizeof(struct iphdr);

  42. }


  45. for (l = opt->optlen; l > 0; ) {

  47. switch (*optptr) {/* 单字节选项 */

  49.       case IPOPT_END:/* 当IP选项不是4字节倍数时，以IPOPT_END选项为IP报头补白 */

  51. for (optptr++, l--; l>0; optptr++, l--) {

  53. if (*optptr != IPOPT_END) {

  55. *optptr = IPOPT_END;

  57. opt->is_changed = 1;

  59. }

  61. }

  63. goto eol;

  65.       case IPOPT_NOOP:/* 填补选项之间的空白 */

  67. l--;

  69. optptr++;

  71. continue;

  73. }

  75. optlen = optptr[1];

  77. if (optlen<2 || optlen>l) {

  79. pp_ptr = optptr;

  81. goto error;

  83. }

  85. switch (*optptr) {/* 多字节选项 */

  87.       case IPOPT_SSRR:

  89.       case IPOPT_LSRR:

  91. if (optlen < 3) {

  93. pp_ptr = optptr + 1;

  95. goto error;

  97. }

  99. if (optptr[2] < 4) { /* optptr[2]存放的偏移量 */

  101. pp_ptr = optptr + 2;

  103. goto error;

  105. }

  107. /* NB: cf RFC-1812 5.2.4.1 */

  109. if (opt->srr) {

  111. pp_ptr = optptr;

  113. goto error;

  115. }

  117. if (!skb) {/* skb == NULL解析一个由本地产生的外出封包 */

  119. if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {

  121. pp_ptr = optptr + 1;

  123. goto error;

  125. }

  127.                                                          /* &optptr[3]表示第一个IP地址的指针 */

  129. memcpy(&opt->faddr, &optptr[3], 4);

  131. if (optlen > 7)

  133. memmove(&optptr[3], &optptr[7], optlen-7);

  135. }

  137.                                            /* optptr[0] == IPOPT_SSRR表示严格路由否则为松散路由 */

  139. opt->is_strictroute = (optptr[0] == IPOPT_SSRR);

  141. opt->srr = optptr - iph;

  143. break;

  145.       case IPOPT_RR:/* Record Route选项 */

  147. if (opt->rr) {

  149. pp_ptr = optptr;

  151. goto error;

  153. }

  155. if (optlen < 3) {

  157. pp_ptr = optptr + 1;

  159. goto error;

  161. }

  163. if (optptr[2] < 4) {

  165. pp_ptr = optptr + 2;

  167. goto error;

  169. }

  171. if (optptr[2] <= optlen) {

  173. if (optptr[2]+3 > optlen) {

  175. pp_ptr = optptr + 2;

  177. goto error;

  179. }

  181. if (skb) {/* 处理入口封包 */

  183. memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);

  185. opt->is_changed = 1;/* 重新计算校验和 */

  187. }

  189. optptr[2] += 4; /* 偏移加上4 */

  191. opt->rr_needaddr = 1; /* 还有空间，继续把IP地址写入IP报头 */

  193. }

  195. opt->rr = optptr - iph;

  197. break;

  199.       case IPOPT_TIMESTAMP:

  201. if (opt->ts) {

  203. pp_ptr = optptr;

  205. goto error;

  207. }

  209. if (optlen < 4) {

  211. pp_ptr = optptr + 1;

  213. goto error;

  215. }

  217. if (optptr[2] < 5) {

  219. pp_ptr = optptr + 2;

  221. goto error;

  223. }

  225. if (optptr[2] <= optlen) {

  227. __u32 * timeptr = NULL;

  229. if (optptr[2]+3 > optptr[1]) {

  231. pp_ptr = optptr + 2;

  233. goto error;

  235. }

  237. switch (optptr[3]&0xF) {/* 低四位表示子命令 */

  239.       case IPOPT_TS_TSONLY:

  241. opt->ts = optptr - iph;

  243. if (skb)

  245. timeptr = (__u32*)&optptr[optptr[2]-1];

  247. opt->ts_needtime = 1;

  249. optptr[2] += 4;

  251. break;

  253.       case IPOPT_TS_TSANDADDR:

  255. if (optptr[2]+7 > optptr[1]) {

  257. pp_ptr = optptr + 2;

  259. goto error;

  261. }

  263. opt->ts = optptr - iph;

  265. if (skb) {

  267. memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);

  269. timeptr = (__u32*)&optptr[optptr[2]+3];

  271. }

  273. opt->ts_needaddr = 1;

  275. opt->ts_needtime = 1;

  277. optptr[2] += 8;

  279. break;

  281.       case IPOPT_TS_PRESPEC:

  283. if (optptr[2]+7 > optptr[1]) {

  285. pp_ptr = optptr + 2;

  287. goto error;

  289. }

  291. opt->ts = optptr - iph;

  293. {

  295. u32 addr;

  297. memcpy(&addr, &optptr[optptr[2]-1], 4);

  299. if (inet_addr_type(addr) == RTN_UNICAST)

  301. break;

  303. if (skb)

  305. timeptr = (__u32*)&optptr[optptr[2]+3];

  307. }

  309. opt->ts_needtime = 1;

  311. optptr[2] += 8;

  313. break;

  315.       default:

  317. if (!skb && !capable(CAP_NET_RAW)) {

  319. pp_ptr = optptr + 3;

  321. goto error;

  323. }

  325. break;

  327. }

  329. if (timeptr) {/* 写入时间戳并更新校验和 */

  331. struct timeval tv;

  333. __u32 midtime;

  335. do_gettimeofday(&tv);

  337. midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);

  339. memcpy(timeptr, &midtime, sizeof(__u32));

  341. opt->is_changed = 1;

  343. }

  345. } else {/* 是否溢出 */

  347. unsigned overflow = optptr[3]>>4;

  349. if (overflow == 15) {

  351. pp_ptr = optptr + 3;

  353. goto error;

  355. }

  357. opt->ts = optptr - iph;

  359. if (skb) {

  361. optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);

  363. opt->is_changed = 1;

  365. }

  367. }

  369. break;

  371.       case IPOPT_RA:

  373. if (optlen < 4) {

  375. pp_ptr = optptr + 1;

  377. goto error;

  379. }

  381. if (optptr[2] == 0 && optptr[3] == 0)

  383. opt->router_alert = optptr - iph;

  385. break;

  387.       case IPOPT_SEC:

  389.       case IPOPT_SID:

  391.       default:

  393. if (!skb && !capable(CAP_NET_RAW)) {

  395. pp_ptr = optptr;

  397. goto error;

  399. }

  401. break;

  403. }

  405. l -= optlen;

  407. optptr += optlen;

  409. }


  412. eol:

  414. if (!pp_ptr)

  416. return 0;


  419. error:

  421. if (skb) {

  423. icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));

  425. }

  427. return -EINVAL;

  429. }
阅读(3986) | 评论(0) | 转发(0) |
0

上一篇：Linux下数据包的转发流程和本地传递流程分析

下一篇：Linux下TCP协议和SCTP协议的数据包传输流程分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6