Chinaunix首页 | 论坛 | 博客

瀚海书香forever.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

瀚海书香

  • 博客访问： 3934651
  • 博文数量： 93
  • 博客积分： 3189
  • 博客等级： 中校
  • 技术积分： 4229
  • 用 户 组： 普通用户
  • 注册时间： 2009-02-02 13:29
个人简介

出没于杭州和青岛的程序猿一枚，对内核略懂一二

文章分类

全部博文（93）

文章存档

2016年（2）

2015年（3）

2014年（11）

2013年（29）

2012年（16）

2011年（5）

2010年（5）

2009年（22）

我的朋友
最近访客
推荐博文
相关博文
libnids tcp重组分析

分类： LINUX

2011-03-18 18:20:11

 

  1. void
  2. process_tcp(u_char * data, int skblen)
  3. {
  4.   
  5.   struct ip *this_iphdr = (struct ip *)data;
  6.   /*tcphdr 的头*/
  7.   struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl);
  8.   int datalen, iplen;
  9.   int from_client = 1; /*客户发送数据*/
  10.   unsigned int tmp_ts;
  11.      
  12.   /*流分为客户端服务端*/
  13.   struct tcp_stream *a_tcp;
  14.   struct half_stream *snd, *rcv;
  15.   
  16.   ugly_iphdr = this_iphdr;
  17.   iplen = ntohs(this_iphdr->ip_len);
  18.      
  19.   if ((unsigned)iplen < 4 * this_iphdr->ip_hl + sizeof(struct tcphdr)) {
  20.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  21.                this_tcphdr);
  22.     return;
  23.   } // ktos sie bawi

  25.   
  26.   /*tcp 数据长度*/
  27.   datalen = iplen - 4 * this_iphdr->ip_hl - 4 * this_tcphdr->th_off;
  28.      
  29.   if (datalen < 0) {
  30.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  31.                this_tcphdr);
  32.     return;
  33.   } // ktos sie bawi

  35.   
  36.   
  37.   /*源和目的地址都存在*/
  38.   
  39.   if ((this_iphdr->ip_src.s_addr | this_iphdr->ip_dst.s_addr) == 0) {
  40.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  41.                this_tcphdr);
  42.     return;
  43.   }
  44.   
  45.   /*如果没有th_ack 包，则进行扫描是否有攻击包*/
  46.   if (!(this_tcphdr->th_flags & TH_ACK))
  47.     detect_scan(this_iphdr);
  48.     /*

  50.    /* 表示有扫描攻击发生 */
  51.          
  52.   if (!nids_params.n_tcp_streams) return;
  53.     
  54.   /*tcp 头的长度，iplen -4*this_iphdr->ip_hl, 进行包头的校验*/
  55.   if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl,
  56.            this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) {
  57.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  58.                this_tcphdr);
  59.     return;
  60.        
  61.   }
  62.     
  63. #if 0
  64.   check_flags(this_iphdr, this_tcphdr);
  65. //ECN

  67. #endif
  68.   
  69. /*查找添加流*/
  70.   
  71. /*

  73.     ************* 三次握手的第一次握手*****************************************

  75. */
  76.   
  77.   if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) {
  78.   
  79.    /*是三次握手的第一个包*/
  80.   /*tcp里流不存在时:且tcp数据包里的(syn=1 && ack==0 && rst==0)时,添加一条tcp流*/
  81.  /*tcp第一次握手*/
  82.     if ((this_tcphdr->th_flags & TH_SYN) &&
  83.     !(this_tcphdr->th_flags & TH_ACK) &&
  84.     !(this_tcphdr->th_flags & TH_RST))
  85.     /*并且没有收到th_rest 包*/
  86.       add_new_tcp(this_tcphdr, this_iphdr);/*节点加入链表中*/
  87.   
  88.    /*第一次握手完毕返回*/
  89.     return;
  90.   }
  91.   
  92.     
  93.   if (from_client) { /*从client --> server的包*/
  94.     snd = &a_tcp->client;
  95.     rcv = &a_tcp->server;
  96.   }
  97.   else {/* server --> client的包 */
  98.     rcv = &a_tcp->client;
  99.     snd = &a_tcp->server;
  100.   }
  101.   
  102.   
  103. /**********************************************************************

  105.                 三次握手的第二次握手
  106.    
  107. ************************************************************************/
  108.   
  109.    /*tcp 三次握手， SYN ==1，ACK==1,tcp第二次握手(server -> client的同步响应)*/
  110.   if ((this_tcphdr->th_flags & TH_SYN)) {
  111.     if (from_client || a_tcp->client.state != TCP_SYN_SENT ||
  112.       a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK))
  113.       return;
  114.   
  115.   
  116. /*第二次回应包的ACK 值为第一个包的序列号+1,在初始化的时候已经加一*/
  117.     if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack))
  118.       return;
  119.        
  120.        
  121.     /*第二个包服务端赋值*/
  122.     /*a_tcp 中服务端赋值，*/
  123.   
  124.     a_tcp->server.state = TCP_SYN_RECV;
  125.     a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1;
  126.     a_tcp->server.first_data_seq = a_tcp->server.seq;
  127.     a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack);
  128.     a_tcp->server.window = ntohs(this_tcphdr->th_win);
  129.   
  130.   
  131.   /*对于tcp 选项的赋值*/
  132.   //初始化客户端和服务器的时间截

  134.     if (a_tcp->client.ts_on) {
  135.         a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts);
  136.     if (!a_tcp->server.ts_on)
  137.         a_tcp->client.ts_on = 0;
  138.     } else a_tcp->server.ts_on = 0;
  139.   
  140.   
  141. //初始化窗口大小

  143.     if (a_tcp->client.wscale_on) {
  144.         a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale);
  145.     if (!a_tcp->server.wscale_on) {
  146.         a_tcp->client.wscale_on = 0;
  147.         a_tcp->client.wscale = 1;
  148.         a_tcp->server.wscale = 1;
  149.     }
  150.     } else {
  151.         a_tcp->server.wscale_on = 0;
  152.         a_tcp->server.wscale = 1;
  153.     }
  154.  /*第二次握手完毕，返回*/
  155.        
  156.     return;
  157.   }
  158.      
  159.   
  160.   
  161.   
  162.   
  163.    /*
  164.                 (如果有数据存在或者修列号不等于确认号的)并且

  166.         序列号在窗口之外
  167.         已经确认过的序号

  169.    */
  170.     
  171.   if (
  172.     ! ( !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq )
  173.     &&
  174.   
  175.     /*th_seq - (ack_seq+ wscale) > 0 或者th_seq+datalen - ack_sql < 0*/
  176.     ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) ||
  177.           before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq)
  178.         )
  179.      )
  180.      return;
  181.   
  182.      
  183.   
  184.   /*发送th_rst 重新开启一个连接*/
  185.   if ((this_tcphdr->th_flags & TH_RST)) {
  186.     /*是tcp 数据*/
  187.     if (a_tcp->nids_state == NIDS_DATA) {
  188.       struct lurker_node *i;
  189.       a_tcp->nids_state = NIDS_RESET;
  190.       for (i = a_tcp->listeners; i; i = i->next)
  191.     (i->item) (a_tcp, &i->data);
  192.     }
  193.     nids_free_tcp_stream(a_tcp);
  194.     return;
  195.   }
  196.   
  197.   
  198.   
  199.   
  200.   /* PAWS check */
  201.   if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) &&
  202.     before(tmp_ts, snd->curr_ts))
  203.   return;
  204.   
  205.   
  206.   
  207.   
  208.   
  209.   
  210. /*
  211.     **********************************************************************
  212.                         第三次握手包

  214.     **********************************************************************
  215. */
  216.   
  217.   /*
  218.     

  220.   从client --> server的包

  222.    是从三次握手的第三个包分析开始的，进行一部分数据分析，和初始化
  223.    连接状态

  225.   */
  226.      
  227.   if ((this_tcphdr->th_flags & TH_ACK)) {
  228.     if (from_client && a_tcp->client.state == TCP_SYN_SENT &&
  229.     a_tcp->server.state == TCP_SYN_RECV) {
  230.       if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) {
  231.     a_tcp->client.state = TCP_ESTABLISHED;
  232.     a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack);
  233.     {
  234.       struct proc_node *i;
  235.       struct lurker_node *j;
  236.       void *data;
  237.          
  238.       a_tcp->server.state = TCP_ESTABLISHED;
  239.       a_tcp->nids_state = NIDS_JUST_EST;
  240.       /*开始全双工传输，client server 连接已经建立起来了*/
  241.   
  242.       /*三次握手tcp ip 连接建立*/
  243.       for (i = tcp_procs; i; i = i->next) {
  244.         char whatto = 0;
  245.            
  246.         char cc = a_tcp->client.collect;
  247.         char sc = a_tcp->server.collect;
  248.         char ccu = a_tcp->client.collect_urg;
  249.         char scu = a_tcp->server.collect_urg;
  250.   
  251.         /*进入回调函数处理*/
  252.   
  253.         /*

  255.             如果在相应端口出现

  257.         client.collect ++ ;

  259.         测审计次数据
  260.         对应用来说tcp 连接已经建立

  262.        */
  263.           
  264.           
  265.         (i->item) (a_tcp, &data);
  266.   
  267.        /**/
  268.         if (cc < a_tcp->client.collect)
  269.           whatto |= COLLECT_cc;
  270.         if (ccu < a_tcp->client.collect_urg)
  271.           whatto |= COLLECT_ccu;
  272.         if (sc < a_tcp->server.collect)
  273.           whatto |= COLLECT_sc;
  274.         if (scu < a_tcp->server.collect_urg)
  275.           whatto |= COLLECT_scu;
  276.         if (nids_params.one_loop_less) {
  277.                 if (a_tcp->client.collect >=2) {
  278.                     a_tcp->client.collect=cc;
  279.                     whatto&=~COLLECT_cc;
  280.                 }
  281.                 if (a_tcp->server.collect >=2 ) {
  282.                     a_tcp->server.collect=sc;
  283.                     whatto&=~COLLECT_sc;
  284.                 }
  285.         }
  286.               
  287.        /*加入监听队列，开始数据接收*/
  288.         if (whatto) {
  289.           j = mknew(struct lurker_node);
  290.           j->item = i->item;/*放入监听队列*/
  291.           j->data = data;
  292.           j->whatto = whatto;
  293.              
  294.           j->next = a_tcp->listeners;
  295.           a_tcp->listeners = j;
  296.         }
  297.            
  298.       }
  299.          
  300.          
  301.       /*不存在监听着*/{
  302.         nids_free_tcp_stream(a_tcp);
  303.         return;
  304.       }
  305.       if (!a_tcp->listeners)
  306.          
  307.       a_tcp->nids_state = NIDS_DATA;
  308.     }
  309.       }
  310.       // return;

  312.     }
  313.   }
  314.   
  315.   
  316.   
  317. /*
  318. ************************************************************

  320.                 挥手过程

  322. *************************************************************

  324. */
  325.   
  326. /*数据结束的包的判断*/
  327.   
  328.   if ((this_tcphdr->th_flags & TH_ACK)) {
  329.        
  330.   
  331.    /* 从数据传输过程不断更新服务器客户端的ack_seq
  332.     一直到接收到fin 包，数据传输结束

  334.    */
  335.     handle_ack(snd, ntohl(this_tcphdr->th_ack));
  336.        
  337.     if (rcv->state == FIN_SENT)
  338.       rcv->state = FIN_CONFIRMED;
  339.     if (rcv->state == FIN_CONFIRMED && snd->state == FIN_CONFIRMED) {
  340.       struct lurker_node *i;
  341.   
  342.       a_tcp->nids_state = NIDS_CLOSE;
  343.       for (i = a_tcp->listeners; i; i = i->next)
  344.     (i->item) (a_tcp, &i->data);
  345.       nids_free_tcp_stream(a_tcp);
  346.       return;
  347.     }
  348.   }
  349.   
  350.   
  351.  /*

  353. *************************************************************
  354.                         数据处理过程
  355. *************************************************************

  357.  */
  358.   
  359.   
  360.     
  361.      
  362.   if (datalen + (this_tcphdr->th_flags & TH_FIN) > 0)
  363.   
  364.   /*
  365.           
  366.     a_tcp -----a_tcp 客户端连接包
  367.     this_tcphdr tcp 包头
  368.     snd-----发送包
  369.     rcv -----接收包

  371.     (char *) (this_tcphdr) + 4 * this_tcphdr->th_off -----数据包内容
  372.     datalen---------数据包长度
  373.       

  375.   */
  376.      
  377.     tcp_queue(a_tcp, this_tcphdr, snd, rcv,
  378.           (char *) (this_tcphdr) + 4 * this_tcphdr->th_off,
  379.           datalen, skblen);
  380.      
  381.   snd->window = ntohs(this_tcphdr->th_win);
  382.      
  383.   if (rcv->rmem_alloc > 65535)
  384.        
  385.     prune_queue(rcv, this_tcphdr);
  386.      
  387.   if (!a_tcp->listeners)
  388.     nids_free_tcp_stream(a_tcp);
  389.   
  390.   
  391. }
  392. void
  393. process_tcp(u_char * data, int skblen)
  394. {
  395.   struct ip *this_iphdr = (struct ip *)data;
  396.   /*tcphdr 的头*/
  397.   struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl);
  398.   int datalen, iplen;
  399.   int from_client = 1; /*客户发送数据*/
  400.   unsigned int tmp_ts;
  401.   
  402.   /*流分为客户端服务端*/
  403.   struct tcp_stream *a_tcp;
  404.   struct half_stream *snd, *rcv;
  405.   ugly_iphdr = this_iphdr;
  406.   iplen = ntohs(this_iphdr->ip_len);
  407.   
  408.   if ((unsigned)iplen < 4 * this_iphdr->ip_hl + sizeof(struct tcphdr)) {
  409.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  410.          this_tcphdr);
  411.     return;
  412.   } // ktos sie bawi

  414.   /*tcp 数据长度*/
  415.   datalen = iplen - 4 * this_iphdr->ip_hl - 4 * this_tcphdr->th_off;
  416.   
  417.   if (datalen < 0) {
  418.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  419.          this_tcphdr);
  420.     return;
  421.   } // ktos sie bawi


  424.   /*源和目的地址都存在*/
  425.   if ((this_iphdr->ip_src.s_addr | this_iphdr->ip_dst.s_addr) == 0) {
  426.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  427.          this_tcphdr);
  428.     return;
  429.   }
  430.   /*如果没有th_ack 包，则进行扫描是否有攻击包*/
  431.   if (!(this_tcphdr->th_flags & TH_ACK))
  432.     detect_scan(this_iphdr);
  433.     /*
  434.    /* 表示有扫描攻击发生 */
  435.    
  436.   if (!nids_params.n_tcp_streams) return;

  438.   /*tcp 头的长度，iplen -4*this_iphdr->ip_hl, 进行包头的校验*/
  439.   if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl,
  440.      this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) {
  441.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr,
  442.          this_tcphdr);
  443.     return;

  445.   }
  446.   
  447. #if 0
  448.   check_flags(this_iphdr, this_tcphdr);
  449. //ECN

  451. #endif
  452. /*查找添加流*/
  453. /*
  454.  ************* 三次握手的第一次握手*****************************************
  455. */
  456.   if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) {
  457.    /*是三次握手的第一个包*/
  458.   /*tcp里流不存在时:且tcp数据包里的(syn=1 && ack==0 && rst==0)时,添加一条tcp流*/
  459.  /*tcp第一次握手*/
  460.     if ((this_tcphdr->th_flags & TH_SYN) &&
  461.  !(this_tcphdr->th_flags & TH_ACK) &&
  462.  !(this_tcphdr->th_flags & TH_RST))
  463.  /*并且没有收到th_rest 包*/
  464.       add_new_tcp(this_tcphdr, this_iphdr);/*节点加入链表中*/
  465.    /*第一次握手完毕返回*/
  466.     return;
  467.   }

  469.   if (from_client) { /*从client --> server的包*/
  470.     snd = &a_tcp->client;
  471.     rcv = &a_tcp->server;
  472.   }
  473.   else {/* server --> client的包 */
  474.     rcv = &a_tcp->client;
  475.     snd = &a_tcp->server;
  476.   }

  478. /**********************************************************************
  479.     三次握手的第二次握手

  481. ************************************************************************/
  482.    /*tcp 三次握手， SYN ==1，ACK==1,tcp第二次握手(server -> client的同步响应)*/
  483.   if ((this_tcphdr->th_flags & TH_SYN)) {
  484.     if (from_client || a_tcp->client.state != TCP_SYN_SENT ||
  485.       a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK))
  486.       return;

  488. /*第二次回应包的ACK 值为第一个包的序列号+1,在初始化的时候已经加一*/
  489.     if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack))
  490.       return;


  493.  /*第二个包服务端赋值*/
  494.  /*a_tcp 中服务端赋值，*/
  495.     a_tcp->server.state = TCP_SYN_RECV;
  496.     a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1;
  497.     a_tcp->server.first_data_seq = a_tcp->server.seq;
  498.     a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack);
  499.     a_tcp->server.window = ntohs(this_tcphdr->th_win);

  501.   /*对于tcp 选项的赋值*/
  502.   //初始化客户端和服务器的时间截

  504.     if (a_tcp->client.ts_on) {
  505.      a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts);
  506.  if (!a_tcp->server.ts_on)
  507.   a_tcp->client.ts_on = 0;
  508.     } else a_tcp->server.ts_on = 0;

  510. //初始化窗口大小

  512.     if (a_tcp->client.wscale_on) {
  513.      a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale);
  514.  if (!a_tcp->server.wscale_on) {
  515.   a_tcp->client.wscale_on = 0;
  516.   a_tcp->client.wscale = 1;
  517.   a_tcp->server.wscale = 1;
  518.  }
  519.     } else {
  520.      a_tcp->server.wscale_on = 0;
  521.      a_tcp->server.wscale = 1;
  522.     }
  523.  /*第二次握手完毕，返回*/

  525.     return;
  526.   }
  527.   


  530.    /*
  531.                 (如果有数据存在或者修列号不等于确认号的)并且
  532.   序列号在窗口之外
  533.    已经确认过的序号
  534.    */

  536.   if (
  537.    ! ( !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq )
  538.    &&
  539.   /*th_seq - (ack_seq+ wscale) > 0 或者th_seq+datalen - ack_sql < 0*/
  540.    ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) ||
  541.           before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq)
  542.         )
  543.      )
  544.      return;
  545.   
  546.   /*发送th_rst 重新开启一个连接*/
  547.   if ((this_tcphdr->th_flags & TH_RST)) {
  548.    /*是tcp 数据*/
  549.     if (a_tcp->nids_state == NIDS_DATA) {
  550.       struct lurker_node *i;
  551.       a_tcp->nids_state = NIDS_RESET;
  552.       for (i = a_tcp->listeners; i; i = i->next)
  553.  (i->item) (a_tcp, &i->data);
  554.     }
  555.     nids_free_tcp_stream(a_tcp);
  556.     return;
  557.   }


  560.   /* PAWS check */
  561.   if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) &&
  562.    before(tmp_ts, snd->curr_ts))
  563.   return;



  567. /*
  568.  **********************************************************************
  569.       第三次握手包
  570.  **********************************************************************
  571. */
  572.   /*
  573.   
  574.   从client --> server的包
  575.    是从三次握手的第三个包分析开始的，进行一部分数据分析，和初始化
  576.    连接状态
  577.   */
  578.   
  579.   if ((this_tcphdr->th_flags & TH_ACK)) {
  580.     if (from_client && a_tcp->client.state == TCP_SYN_SENT &&
  581.  a_tcp->server.state == TCP_SYN_RECV) {
  582.       if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) {
  583.  a_tcp->client.state = TCP_ESTABLISHED;
  584.  a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack);
  585.  {
  586.    struct proc_node *i;
  587.    struct lurker_node *j;
  588.    void *data;
  589.    
  590.    a_tcp->server.state = TCP_ESTABLISHED;
  591.    a_tcp->nids_state = NIDS_JUST_EST;
  592.    /*开始全双工传输，client server 连接已经建立起来了*/
  593.    /*三次握手tcp ip 连接建立*/
  594.    for (i = tcp_procs; i; i = i->next) {
  595.      char whatto = 0;
  596.   
  597.      char cc = a_tcp->client.collect;
  598.      char sc = a_tcp->server.collect;
  599.      char ccu = a_tcp->client.collect_urg;
  600.      char scu = a_tcp->server.collect_urg;
  601.      /*进入回调函数处理*/
  602.      /*
  603.          如果在相应端口出现
  604.   client.collect ++ ;
  605.   测审计次数据
  606.   对应用来说tcp 连接已经建立
  607.     */
  608.     
  609.     
  610.      (i->item) (a_tcp, &data);
  611.     /**/
  612.      if (cc < a_tcp->client.collect)
  613.        whatto |= COLLECT_cc;
  614.      if (ccu < a_tcp->client.collect_urg)
  615.        whatto |= COLLECT_ccu;
  616.      if (sc < a_tcp->server.collect)
  617.        whatto |= COLLECT_sc;
  618.      if (scu < a_tcp->server.collect_urg)
  619.        whatto |= COLLECT_scu;
  620.      if (nids_params.one_loop_less) {
  621.        if (a_tcp->client.collect >=2) {
  622.         a_tcp->client.collect=cc;
  623.         whatto&=~COLLECT_cc;
  624.        }
  625.        if (a_tcp->server.collect >=2 ) {
  626.         a_tcp->server.collect=sc;
  627.         whatto&=~COLLECT_sc;
  628.        }
  629.      }
  630.            
  631.     /*加入监听队列，开始数据接收*/
  632.      if (whatto) {
  633.        j = mknew(struct lurker_node);
  634.        j->item = i->item;/*放入监听队列*/
  635.        j->data = data;
  636.        j->whatto = whatto;
  637.     
  638.        j->next = a_tcp->listeners;
  639.        a_tcp->listeners = j;
  640.      }
  641.   
  642.    }
  643.    
  644.    
  645.    /*不存在监听着*/{
  646.      nids_free_tcp_stream(a_tcp);
  647.      return;
  648.    }
  649.    if (!a_tcp->listeners)
  650.    
  651.    a_tcp->nids_state = NIDS_DATA;
  652.  }
  653.       }
  654.       // return;

  656.     }
  657.   }

  659. /*
  660. ************************************************************
  661.     挥手过程
  662. *************************************************************
  663. */
  664. /*数据结束的包的判断*/
  665.   if ((this_tcphdr->th_flags & TH_ACK)) {
  666.    
  667.    /* 从数据传输过程不断更新服务器客户端的ack_seq
  668.  一直到接收到fin 包，数据传输结束
  669.    */
  670.     handle_ack(snd, ntohl(this_tcphdr->th_ack));

  672.     if (rcv->state == FIN_SENT)
  673.       rcv->state = FIN_CONFIRMED;
  674.     if (rcv->state == FIN_CONFIRMED && snd->state == FIN_CONFIRMED) {
  675.       struct lurker_node *i;
  676.       a_tcp->nids_state = NIDS_CLOSE;
  677.       for (i = a_tcp->listeners; i; i = i->next)
  678.  (i->item) (a_tcp, &i->data);
  679.       nids_free_tcp_stream(a_tcp);
  680.       return;
  681.     }
  682.   }

  684.  /*
  685. *************************************************************
  686.       数据处理过程
  687. *************************************************************
  688.  */


  691.   
  692.   if (datalen + (this_tcphdr->th_flags & TH_FIN) > 0)
  693.   /*
  694.   
  695.  a_tcp -----a_tcp 客户端连接包
  696.  this_tcphdr tcp 包头
  697.  snd-----发送包
  698.  rcv -----接收包
  699.  (char *) (this_tcphdr) + 4 * this_tcphdr->th_off -----数据包内容
  700.  datalen---------数据包长度

  702.   */
  703.   
  704.     tcp_queue(a_tcp, this_tcphdr, snd, rcv,
  705.        (char *) (this_tcphdr) + 4 * this_tcphdr->th_off,
  706.        datalen, skblen);
  707.   
  708.   snd->window = ntohs(this_tcphdr->th_win);
  709.   
  710.   if (rcv->rmem_alloc > 65535)
  711.    
  712.     prune_queue(rcv, this_tcphdr);
  713.   
  714.   if (!a_tcp->listeners)
  715.     nids_free_tcp_stream(a_tcp);

  717. }

  719. view plaincopy to clipboardprint?
  720. //判断 该TCP 数据包是添加到数据区还是添加到list双向链表中

  722. static void
  723. tcp_queue(struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr,
  724.       struct half_stream * snd, struct half_stream* rcv,
  725.       char *data, int datalen, int skblen
  726.       )
  727. {
  728.   
  729.   u_int this_seq = ntohl(this_tcphdr->th_seq);
  730.      
  731.   struct skbuff *pakiet, *tmp;
  732.   
  733.   
  734.  /*
  735.         #define EXP_SEQ (snd->first_data_seq + rcv->count + rcv->urg_count)
  736.     EXP_SEQ > this_seq
  737.   */
  738.   
  739.   /* 如果EXP_SEQ > = this_seq */
  740.   /*

  742.   EXP_SEQ 期望到达的数据
  743.   this_seq 实际到达的数据

  745.   */
  746.      
  747.   if ( !after(this_seq, EXP_SEQ) ) {
  748.   
  749.     /*this_seq + datalen + (this_tcphdr->th_flags & TH_FIN)> EXP_SEQ*/
  750.   
  751.        
  752.     /*有重叠数据存在(重叠数据怎么处理呢)

  754.         也可能没有重叠数据
  755.      */
  756.        
  757.     if ( after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ) ) {
  758.            
  759.       /* the packet straddles our window end */
  760.       get_ts(this_tcphdr, &snd->curr_ts);
  761.          
  762.       add_from_skb(a_tcp, rcv, snd, data, datalen, this_seq,
  763.            (this_tcphdr->th_flags & TH_FIN),
  764.            (this_tcphdr->th_flags & TH_URG),
  765.                    ntohs(this_tcphdr->th_urp) + this_seq - 1);
  766.     /*
  767.     * Do we have any old packets to ack that the above
  768.     * made visible? (Go forward from skb)
  769.     */
  770.   
  771.   
  772.   
  773.      /*从头节点释放节点*/
  774.       pakiet = rcv->list;
  775.       while (pakiet) {
  776.      /*

  778.         期望的序列号小于该包的序列号则直接返回

  780.      */
  781.     if (after(pakiet->seq, EXP_SEQ))
  782.       break;
  783.        
  784.     /*

  786.     对失序队列数据包的处理

  788.        如果包序列号加上长度还小于期望序列号
  789.        则把该包添加到数据区，并在失序队列中删除该包

  791.     */
  792.     if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) {
  793.       add_from_skb(a_tcp, rcv, snd, pakiet->data,
  794.                pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg,
  795.                pakiet->urg_ptr + pakiet->seq - 1);
  796.         }
  797.     rcv->rmem_alloc -= pakiet->truesize;
  798.        
  799.         /*从头节点释放链表*/
  800.            
  801.     if (pakiet->prev)
  802.       pakiet->prev->next = pakiet->next;
  803.     else
  804.       rcv->list = pakiet->next;
  805.     if (pakiet->next)
  806.       pakiet->next->prev = pakiet->prev;
  807.     else
  808.       rcv->listtail = pakiet->prev;
  809.     tmp = pakiet->next;
  810.     free(pakiet->data);
  811.     free(pakiet);
  812.     pakiet = tmp;
  813.       }
  814.     }
  815.     else
  816.       return;
  817.   }
  818.   
  819.      
  820. /*提前到达数据的加入失去顺序队列中链表*/
  821.   
  822. //序列号大于我们期望的序列号，则把该包添加到list双向链表中

  824.   
  825.   
  826.   /*链表加入节点 */
  827.   else {
  828.   
  829.     /*初始化*/
  830.     struct skbuff *p = rcv->listtail;
  831.        /*
  832.     pakiet 加入rcv->listtal 链表中
  833.        */
  834.        /*
  835.     pakiet 节点的初始化
  836.       
  837.     */
  838.        
  839.     pakiet = mknew(struct skbuff);
  840.     pakiet->truesize = skblen;
  841.     rcv->rmem_alloc += pakiet->truesize;
  842.   
  843.     /*数据包填充pakiet->data 中*/
  844.     pakiet->len = datalen;
  845.     pakiet->data = malloc(datalen);
  846.     if (!pakiet->data)
  847.     nids_params.no_mem("tcp_queue");
  848.     memcpy(pakiet->data, data, datalen);
  849.   
  850.     /*是否是结束包*/
  851.     pakiet->fin = (this_tcphdr->th_flags & TH_FIN);
  852.       
  853.     /* Some Cisco - at least - hardware accept to close a TCP connection
  854.      * even though packets were lost before the first TCP FIN packet and
  855.      * never retransmitted; this violates RFC 793, but since it really
  856.      * happens, it has to be dealt with... The idea is to introduce a 10s
  857.      * timeout after TCP FIN packets were sent by both sides so that
  858.      * corresponding libnids resources can be released instead of waiting
  859.      * for retransmissions which will never happen. -- Sebastien Raveau
  860.      */
  861.       /*

  863.          硬件接收一个tcp 终止的链接，
  864.          即使包在一个结束包的时候丢失，并且不再重传，
  865.          处理这种方法就是引入时间机制处理

  867.       */
  868.          
  869.     if (pakiet->fin) {
  870.       snd->state = TCP_CLOSING;
  871.       if (rcv->state == FIN_SENT || rcv->state == FIN_CONFIRMED)
  872.     add_tcp_closing_timeout(a_tcp);
  873.     }
  874.        
  875.      /*
  876.       
  877.      seq,urg ,urg_ptr 赋值

  879.     */
  880.        
  881.     pakiet->seq = this_seq;
  882.     pakiet->urg = (this_tcphdr->th_flags & TH_URG);
  883.     pakiet->urg_ptr = ntohs(this_tcphdr->th_urp);
  884.        
  885.     for (;;) {
  886.            
  887.       if (!p || !after(p->seq, this_seq))
  888.     break;
  889.       p = p->prev;
  890. }
  891.        
  892.     if (!p) {
  893. /*建立首节点*/
  894.       pakiet->prev = 0;
  895.       pakiet->next = rcv->list;
  896.       if (rcv->list)
  897.          rcv->list->prev = pakiet;
  898.          
  899.       rcv->list = pakiet;
  900.       if (!rcv->listtail)
  901.     rcv->listtail = pakiet;
  902.     }
  903.   
  904. /*链表后插入*/
  905.     else {
  906.       pakiet->next = p->next;
  907.       p->next = pakiet;
  908.       pakiet->prev = p;
  909.       if (pakiet->next)
  910.     pakiet->next->prev = pakiet;
  911.       else
  912.     rcv->listtail = pakiet;
  913.     }
  914.        
  915.   }
  916.      
  917. }
  918. //判断 该TCP 数据包是添加到数据区还是添加到list双向链表中

  920. static void
  921. tcp_queue(struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr,
  922.    struct half_stream * snd, struct half_stream* rcv,
  923.    char *data, int datalen, int skblen
  924.    )
  925. {
  926.   u_int this_seq = ntohl(this_tcphdr->th_seq);
  927.   
  928.   struct skbuff *pakiet, *tmp;

  930.  /*
  931.         #define EXP_SEQ (snd->first_data_seq + rcv->count + rcv->urg_count)
  932.  EXP_SEQ > this_seq
  933.   */
  934.   /* 如果EXP_SEQ > = this_seq */
  935.   /*
  936.   EXP_SEQ 期望到达的数据
  937.   this_seq 实际到达的数据
  938.   */
  939.   
  940.   if ( !after(this_seq, EXP_SEQ) ) {
  941.     /*this_seq + datalen + (this_tcphdr->th_flags & TH_FIN)> EXP_SEQ*/

  943.     /*有重叠数据存在(重叠数据怎么处理呢)
  944.         也可能没有重叠数据
  945.      */

  947.     if ( after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ) ) {
  948.   
  949.       /* the packet straddles our window end */
  950.       get_ts(this_tcphdr, &snd->curr_ts);
  951.    
  952.       add_from_skb(a_tcp, rcv, snd, data, datalen, this_seq,
  953.      (this_tcphdr->th_flags & TH_FIN),
  954.      (this_tcphdr->th_flags & TH_URG),
  955.        ntohs(this_tcphdr->th_urp) + this_seq - 1);
  956.  /*
  957.  * Do we have any old packets to ack that the above
  958.  * made visible? (Go forward from skb)
  959.  */

  961.      /*从头节点释放节点*/
  962.       pakiet = rcv->list;
  963.       while (pakiet) {
  964.   /*
  965.   期望的序列号小于该包的序列号则直接返回
  966.   */
  967.  if (after(pakiet->seq, EXP_SEQ))
  968.    break;

  970.  /*
  971.  对失序队列数据包的处理
  972.     如果包序列号加上长度还小于期望序列号
  973.     则把该包添加到数据区，并在失序队列中删除该包
  974.  */
  975.  if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) {
  976.    add_from_skb(a_tcp, rcv, snd, pakiet->data,
  977.          pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg,
  978.          pakiet->urg_ptr + pakiet->seq - 1);
  979.         }
  980.  rcv->rmem_alloc -= pakiet->truesize;

  982.         /*从头节点释放链表*/
  983.   
  984.  if (pakiet->prev)
  985.    pakiet->prev->next = pakiet->next;
  986.  else
  987.    rcv->list = pakiet->next;
  988.  if (pakiet->next)
  989.    pakiet->next->prev = pakiet->prev;
  990.  else
  991.    rcv->listtail = pakiet->prev;
  992.  tmp = pakiet->next;
  993.  free(pakiet->data);
  994.  free(pakiet);
  995.  pakiet = tmp;
  996.       }
  997.     }
  998.     else
  999.       return;
  1000.   }
  1001.   
  1002. /*提前到达数据的加入失去顺序队列中链表*/
  1003. //序列号大于我们期望的序列号，则把该包添加到list双向链表中


  1006.   /*链表加入节点 */
  1007.   else {
  1008.     /*初始化*/
  1009.     struct skbuff *p = rcv->listtail;
  1010.        /*
  1011.  pakiet 加入rcv->listtal 链表中
  1012.        */
  1013.        /*
  1014.  pakiet 节点的初始化

  1016.  */

  1018.     pakiet = mknew(struct skbuff);
  1019.     pakiet->truesize = skblen;
  1020.     rcv->rmem_alloc += pakiet->truesize;
  1021.     /*数据包填充pakiet->data 中*/
  1022.     pakiet->len = datalen;
  1023.     pakiet->data = malloc(datalen);
  1024.     if (!pakiet->data)
  1025.     nids_params.no_mem("tcp_queue");
  1026.     memcpy(pakiet->data, data, datalen);
  1027.     /*是否是结束包*/
  1028.     pakiet->fin = (this_tcphdr->th_flags & TH_FIN);
  1029.    
  1030.     /* Some Cisco - at least - hardware accept to close a TCP connection
  1031.      * even though packets were lost before the first TCP FIN packet and
  1032.      * never retransmitted; this violates RFC 793, but since it really
  1033.      * happens, it has to be dealt with... The idea is to introduce a 10s
  1034.      * timeout after TCP FIN packets were sent by both sides so that
  1035.      * corresponding libnids resources can be released instead of waiting
  1036.      * for retransmissions which will never happen. -- Sebastien Raveau
  1037.      */
  1038.       /*
  1039.          硬件接收一个tcp 终止的链接，
  1040.          即使包在一个结束包的时候丢失，并且不再重传，
  1041.          处理这种方法就是引入时间机制处理
  1042.       */
  1043.       
  1044.     if (pakiet->fin) {
  1045.       snd->state = TCP_CLOSING;
  1046.       if (rcv->state == FIN_SENT || rcv->state == FIN_CONFIRMED)
  1047.  add_tcp_closing_timeout(a_tcp);
  1048.     }

  1050.      /*

  1052.      seq,urg ,urg_ptr 赋值
  1053.     */
  1054.     
  1055.     pakiet->seq = this_seq;
  1056.     pakiet->urg = (this_tcphdr->th_flags & TH_URG);
  1057.     pakiet->urg_ptr = ntohs(this_tcphdr->th_urp);

  1059.     for (;;) {
  1060.   
  1061.       if (!p || !after(p->seq, this_seq))
  1062.  break;
  1063.       p = p->prev;
  1064. }

  1066.     if (!p) {
  1067. /*建立首节点*/
  1068.       pakiet->prev = 0;
  1069.       pakiet->next = rcv->list;
  1070.       if (rcv->list)
  1071.          rcv->list->prev = pakiet;
  1072.    
  1073.       rcv->list = pakiet;
  1074.       if (!rcv->listtail)
  1075.  rcv->listtail = pakiet;
  1076.     }
  1077. /*链表后插入*/
  1078.     else {
  1079.       pakiet->next = p->next;
  1080.       p->next = pakiet;
  1081.       pakiet->prev = p;
  1082.       if (pakiet->next)
  1083.  pakiet->next->prev = pakiet;
  1084.       else
  1085.  rcv->listtail = pakiet;
  1086.     }

  1088.   }
  1089.   
  1090. }

  1092. view plaincopy to clipboardprint?
  1093. /*

  1095. 分配空间，数据保存rcv->data 中
  1096. 长度为:rcv->count
  1097. 新数据为date
  1098. 长度为datalen


  1101. 接收到新数据，重新分配空间，要根据收到的数据的大小
  1102. buffersize重分配的空间
  1103. */
  1104. static void
  1105. add2buf(struct half_stream * rcv, char *data, int datalen)
  1106. {
  1107.   
  1108.   int toalloc;
  1109.   
  1110.   /*datalen + rcv->count - rcv->offset 如果大于buffersize 需要重新分配空间*/
  1111.      
  1112.   if (datalen + rcv->count - rcv->offset > rcv->bufsize) {
  1113.     /*如果rcv->data 不存在*/
  1114.     if (!rcv->data) {
  1115.       if (datalen < 2048)
  1116.     toalloc = 4096;
  1117.       else
  1118.     toalloc = datalen * 2;
  1119.   
  1120.       /*数据分配空间,bufsize 为分配空间的大小*/
  1121.       rcv->data = malloc(toalloc);
  1122.       rcv->bufsize = toalloc;
  1123.     }
  1124.    /*第一次分配空间，如果空间不够重新分配*/
  1125.     else {
  1126.            
  1127.       if (datalen < rcv->bufsize)
  1128.         toalloc = 2 * rcv->bufsize;
  1129.       else
  1130.         toalloc = rcv->bufsize + 2*datalen;
  1131.          
  1132.       rcv->data = realloc(rcv->data, toalloc);
  1133.       rcv->bufsize = toalloc;
  1134.     }
  1135.     if (!rcv->data)
  1136.       nids_params.no_mem("add2buf");
  1137.   }
  1138.   
  1139.   
  1140.   memcpy(rcv->data + rcv->count - rcv->offset, data, datalen);
  1141.      
  1142.   rcv->count_new = datalen;
  1143.      
  1144.   rcv->count += datalen; /*count 累加为收到的数据之和，从流开始建立*/
  1145.   
  1146. }
  1147. /*
  1148. 分配空间，数据保存rcv->data 中
  1149. 长度为:rcv->count
  1150. 新数据为date
  1151. 长度为datalen

  1153. 接收到新数据，重新分配空间，要根据收到的数据的大小
  1154. buffersize重分配的空间
  1155. */
  1156. static void
  1157. add2buf(struct half_stream * rcv, char *data, int datalen)
  1158. {
  1159.   int toalloc;
  1160.   /*datalen + rcv->count - rcv->offset 如果大于buffersize 需要重新分配空间*/
  1161.   
  1162.   if (datalen + rcv->count - rcv->offset > rcv->bufsize) {
  1163.    /*如果rcv->data 不存在*/
  1164.     if (!rcv->data) {
  1165.       if (datalen < 2048)
  1166.  toalloc = 4096;
  1167.       else
  1168.  toalloc = datalen * 2;
  1169.       /*数据分配空间,bufsize 为分配空间的大小*/
  1170.       rcv->data = malloc(toalloc);
  1171.       rcv->bufsize = toalloc;
  1172.     }
  1173.    /*第一次分配空间，如果空间不够重新分配*/
  1174.     else {
  1175.   
  1176.       if (datalen < rcv->bufsize)
  1177.        toalloc = 2 * rcv->bufsize;
  1178.       else
  1179.        toalloc = rcv->bufsize + 2*datalen;
  1180.    
  1181.       rcv->data = realloc(rcv->data, toalloc);
  1182.       rcv->bufsize = toalloc;
  1183.     }
  1184.     if (!rcv->data)
  1185.       nids_params.no_mem("add2buf");
  1186.   }

  1188.   memcpy(rcv->data + rcv->count - rcv->offset, data, datalen);
  1189.   
  1190.   rcv->count_new = datalen;
  1191.   
  1192.   rcv->count += datalen; /*count 累加为收到的数据之和，从流开始建立*/
  1193. }
  1194. view plaincopy to clipboardprint?
  1195. /*

  1197. 通知服务器或者客户端接受数据

  1199. */
  1200.   
  1201. static void
  1202. notify(struct tcp_stream * a_tcp, struct half_stream * rcv)
  1203. {
  1204.   
  1205. /*

  1207. 监听节点

  1209. */
  1210.   struct lurker_node *i, **prev_addr;
  1211.   char mask;
  1212.   
  1213. /*

  1215. 紧急数据


  1218. */
  1219.   if (rcv->count_new_urg) {
  1220.     if (!rcv->collect_urg)
  1221.       return;
  1222.     if (rcv == &a_tcp->client)
  1223.       mask = COLLECT_ccu;
  1224.     else
  1225.       mask = COLLECT_scu;
  1226.        
  1227.     ride_lurkers(a_tcp, mask);
  1228.     goto prune_listeners;
  1229.   }
  1230.   
  1231.   
  1232. /*

  1234. 常规数据

  1236. */
  1237.   
  1238.   if (rcv->collect) {
  1239.     if (rcv == &a_tcp->client)
  1240.       mask = COLLECT_cc;
  1241.     else
  1242.       mask = COLLECT_sc;
  1243.   
  1244.   /*

  1246.   不断读取数据，一直到


  1249.   读取到数据结束

  1251.   */
  1252.        
  1253.    do {
  1254.             int total;
  1255.   
  1256.         /*

  1258.             a_tcp 为为收到的datalen

  1260.             total = dalalen;

  1262.         */
  1263.         a_tcp->read = rcv->count - rcv->offset;
  1264.         total = a_tcp->read;
  1265.            
  1266.                /*处理监听节点上报信息*/
  1267.   
  1268.         ride_lurkers(a_tcp, mask);
  1269.   
  1270.   
  1271.                   
  1272.            
  1273.         if (a_tcp->read > total-rcv->count_new)
  1274.             rcv->count_new = total-a_tcp->read;
  1275.            
  1276.         if (a_tcp->read > 0) {
  1277.                
  1278.         /*
  1279.             已经读过的数据部再读，把没有读的数据放在rcv->data 中，
  1280.             继续循环，hlf->data 指向新数据

  1282.             rcv->count_new 为新数据的长度
  1283.               

  1285.         */
  1286.         memmove(rcv->data, rcv->data + a_tcp->read, rcv->count - rcv->offset - a_tcp->read);
  1287.   
  1288.           /*rcv->ofset 最终== rcv->count */
  1289.           rcv->offset += a_tcp->read;
  1290.         }
  1291.     }while (nids_params.one_loop_less && a_tcp->read>0 && rcv->count_new);
  1292. // we know that if one_loop_less!=0, we have only one callback to notify

  1294.   
  1295. /*

  1297. rcv->count_new 初始化为0

  1299. */
  1300.    rcv->count_new=0;
  1301.   }
  1302.   
  1303.      
  1304.  prune_listeners:
  1305.   prev_addr = &a_tcp->listeners;
  1306.   i = a_tcp->listeners;
  1307.   while (i)
  1308.     if (!i->whatto) {
  1309.       *prev_addr = i->next;
  1310.       free(i);
  1311.       i = *prev_addr;
  1312.     }
  1313.     else {
  1314.       prev_addr = &i->next;
  1315.       i = i->next;
  1316.     }
  1317.        
  1318. }
  1319. /*
  1320. 通知服务器或者客户端接受数据
  1321. */
  1322. static void
  1323. notify(struct tcp_stream * a_tcp, struct half_stream * rcv)
  1324. {
  1325. /*
  1326. 监听节点
  1327. */
  1328.   struct lurker_node *i, **prev_addr;
  1329.   char mask;
  1330. /*
  1331. 紧急数据

  1333. */
  1334.   if (rcv->count_new_urg) {
  1335.     if (!rcv->collect_urg)
  1336.       return;
  1337.     if (rcv == &a_tcp->client)
  1338.       mask = COLLECT_ccu;
  1339.     else
  1340.       mask = COLLECT_scu;

  1342.     ride_lurkers(a_tcp, mask);
  1343.     goto prune_listeners;
  1344.   }

  1346. /*
  1347. 常规数据
  1348. */
  1349.   if (rcv->collect) {
  1350.     if (rcv == &a_tcp->client)
  1351.       mask = COLLECT_cc;
  1352.     else
  1353.       mask = COLLECT_sc;
  1354.   /*
  1355.   不断读取数据，一直到

  1357.   读取到数据结束
  1358.   */

  1360.    do {
  1361.          int total;
  1362.   /*
  1363.    a_tcp 为为收到的datalen
  1364.    total = dalalen;
  1365.   */
  1366.   a_tcp->read = rcv->count - rcv->offset;
  1367.   total = a_tcp->read;
  1368.   
  1369.                /*处理监听节点上报信息*/
  1370.   ride_lurkers(a_tcp, mask);

  1372.       
  1373.   
  1374.      if (a_tcp->read > total-rcv->count_new)
  1375.       rcv->count_new = total-a_tcp->read;
  1376.      
  1377.      if (a_tcp->read > 0) {
  1378.    
  1379.   /*
  1380.    已经读过的数据部再读，把没有读的数据放在rcv->data 中，
  1381.    继续循环，hlf->data 指向新数据
  1382.    rcv->count_new 为新数据的长度
  1383.    
  1384.   */
  1385.   memmove(rcv->data, rcv->data + a_tcp->read, rcv->count - rcv->offset - a_tcp->read);
  1386.        /*rcv->ofset 最终== rcv->count */
  1387.        rcv->offset += a_tcp->read;
  1388.      }
  1389.  }while (nids_params.one_loop_less && a_tcp->read>0 && rcv->count_new);
  1390. // we know that if one_loop_less!=0, we have only one callback to notify

  1392. /*
  1393. rcv->count_new 初始化为0
  1394. */
  1395.    rcv->count_new=0;
  1396.   }
  1397.   
  1398.  prune_listeners:
  1399.   prev_addr = &a_tcp->listeners;
  1400.   i = a_tcp->listeners;
  1401.   while (i)
  1402.     if (!i->whatto) {
  1403.       *prev_addr = i->next;
  1404.       free(i);
  1405.       i = *prev_addr;
  1406.     }
  1407.     else {
  1408.       prev_addr = &i->next;
  1409.       i = i->next;
  1410.     }

  1412. }
阅读(10960) | 评论(0) | 转发(2) |
0

上一篇：网段地址转换 —— NETSNAT NETDNAT target源码

下一篇：Linux中断研究

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

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

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

16024965号-6