libnids 中tcp流重组代码

最新推荐文章于 2015-01-07 16:07:55 发布
转载 最新推荐文章于 2015-01-07 16:07:55 发布 · 3.3k 阅读 · 9
文章标签：

#linux #tcpip #network

  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. }
libnids分析（5）——TCP重组
网络审计
06-19 6408
无限循环的抓包函数的回调函数调用了gen_ip_proc()函数，该函数通过判断类型进入到对应的重组阶段。下面开始分析TCP重组部分。 函数名：process_tcp(data, skblen) 代码很长，如下： void process_tcp(u_char * data, int skblen)//传入数据与其长度 { struct ip *this_iphdr = (str
利用libnids和ibcap进行tcp会话的重组
08-18
3. **数据流重组**：当数据包到达时，libnids会尝试将其放入正确的TCP流中，即使这些数据包是非顺序到达的。 4. **事件回调**：libnids提供了一系列的回调函数，当特定的TCP事件发生时（如连接建立、关闭或数据传输...
libnids中TCP/IP栈实现细节分析（上）——TCP会话重组
网络审计
06-15 1611
libnids是网络安全方面的一个库，可以用来检测网络上的攻击行为。其中最有价值的部分是，它模拟了linux内核中3层和4层的协议栈。可以供我们进一步研究linux内核中的TCP/IP协议栈做一些有价值的参考。这里简单谈谈这个库中模拟3、4层协议的实现细节（在继续读下去之前，有必要复习一下TCP/IP协议相关理论，主要是滑动窗口协议）。这里送上一张网上到处都有的TCP状态转化图，算是开胃小菜：
libnids中TCP/IP栈实现细节分析（下）——IP分片重组
网络审计
06-15 1547
好了，有时间了，来看看libnids中IP分片重组的方法吧。 在此之前，如果不懂IP分片技术的话，请参照这里。IP分片技术比较简单暴力，没有TCP那样复杂复杂的窗口协议。基本上只是暴力的拆分和重组，代码基本在ip_defragment.c中。 先从总体上说说。首先，每个IP（主机）都会有IP分片包（注意是IP，不是IP对）。所以，每个IP都有一个如下的结构体来维护上面的所以IP分片：
libnids-TCP流重组
lotus302的专栏
01-07 4561
1.  Void process_tcp(u_char * data, int skblen)  2.  {  3.     4.    struct ip *this_iphdr = (struct ip *)data;  5.    /*tcphdr 的头*/  6.    struct tcphdr *this_tcphdr = (struct tcphdr *)(data +
基于libnids的TCP数据流的还原(多线程实现)
edison0716的专栏
01-03 3366
 我们知道，libnids本身可以实现TCP数据流的重组，但是如果一个TCP流数据量比较大的时候，就会分成好多个TCP报文段，这些报文段在网络中的传播可能是乱序的，利用libnids可以帮助我们按顺序接收到这些报文段，即实现TCP报文段的重组。    但是我们如何把这些顺序的报文段重新还原成一个完整的数据文件，也是要考虑的一个问题，因为在很多时候，单个的报文段对我们的意义不大，我们需要一个完整
libnids-tcp-code
04-24
在提供的"libnids tcp 重组代码注释"中，你可以找到关于如何使用libnids进行TCP重组的具体实现细节。这些注释可能涵盖了关键函数的解释、数据结构的定义、事件处理流程等。通过深入研究这些代码，开发者可以更好地...
libnids源码解析：TCP重组流程详解
通过梳理libnids.zip中的内容，我们了解到了网络入侵检测系统的核心工作流程、TCP重组技术以及代码实现的关键点。libnids作为一个开源库，不仅对学习IDS开发者有重大意义，也对网络安全爱好者深入理解网络协议和...
TCP数据重组核心代码分析与实践
压缩包子文件的文件名称列表“libnids tcp 重组代码注释”暗示了文件内容可能包含对libnids进行TCP重组操作的具体代码段，并且附有详细的注释。代码注释对于理解代码逻辑、维护以及未来可能的开发至关重要。注释可以...
libnids tcp 重组代码注释
wenwen_2008的专栏
06-01 1070
[c-sharp] view plaincopy void   process_tcp(u_char * data, int skblen)   {        struct ip *this_iphdr = (struct ip *)data;     /*tcphdr 的头*/     struct tcphdr *this_tcphdr = (st
C语言 tcp数据包重组
03-16
数据包的重组，在e盘下建一个asd文件夹，运行程序结束后，会发现asd文件夹里有很多子文件夹，每个子文件里面都有一个total，这里面就是数据包重组的内容。
ip分片重组及tcp分段重组具体实现
01-31
tcp/ip协议中ip分片重组以及tcp分段重组具体实现原理
DPDK抓包，libnids包还原（分片，重组）
05-02
DPDK抓包，libnids包还原（分片，重组，协议分析）
入侵防御系统中TCP数据流重组的设计与实现.pdf
08-17
入侵防御系统，可以在并行电脑数据行上发布
nids防火墙.源代码
05-26
这是一个用vc++语言编写的防火墙程序，功能齐全，是一款不错的防火墙源代码。
TCP数据包重组实现分析
wfqxx的专栏
06-06 4967
转自：http://blog.sina.com.cn/s/blog_48eef8410100b1gw.html TCP重组数据包分析参照TCP/IP详解第二卷24~29章，详细论述了TCP协议的实现，大概总结一下TCP如何向应用层保证数据包的正确性、可靠性，即TCP如何实现对数据报文的重组。首先要设计两个报文队列，一个存放正常
libnids中TCP重组中的主要函数process_tcp()分析
anduobiao0736的博客
04-02 386
重点:这篇为转载,作者在这块分析的很好,虽然现在libnids已经更新到了1.24,但函数的大体流程还是未变,正文 1 void process_tcp(u_char * data, int skblen)//传入数据与其长度 2 { 3 struct ip *this_iphdr = (struct ip *)data;//ip与tcp结构体见后面说明 4 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值