libnids 中tcp流重组代码

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 
    
24. 
    
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 
    
34. 
    
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.     /* 
    
49. 
    
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 
    
66. 
    
67. #endif 
    
68.   
    
69. /*查找添加流*/ 
    
70.   
    
71. /* 
    
72. 
    
73.     ************* 三次握手的第一次握手***************************************** 
    
74. 
    
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. /********************************************************************** 
     
104. 
     
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.   //初始化客户端和服务器的时间截 
     
133. 
     
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. //初始化窗口大小 
     
142. 
     
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.                 (如果有数据存在或者修列号不等于确认号的)并且 
     
165. 
     
166.         序列号在窗口之外 
     
167.         已经确认过的序号 
     
168. 
     
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.                         第三次握手包 
     
213. 
     
214.     ********************************************************************** 
     
215. */ 
     
216.   
     
217.   /* 
     
218.     
     
219. 
     
220.   从client --> server的包 
     
221. 
     
222.    是从三次握手的第三个包分析开始的，进行一部分数据分析，和初始化 
     
223.    连接状态 
     
224. 
     
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.         /* 
     
254. 
     
255.             如果在相应端口出现 
     
256. 
     
257.         client.collect ++ ; 
     
258. 
     
259.         测审计次数据 
     
260.         对应用来说tcp 连接已经建立 
     
261. 
     
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; 
     
311. 
     
312.     } 
     
313.   } 
     
314.   
     
315.   
     
316.   
     
317. /* 
     
318. ************************************************************ 
     
319. 
     
320.                 挥手过程 
     
321. 
     
322. ************************************************************* 
     
323. 
     
324. */ 
     
325.   
     
326. /*数据结束的包的判断*/ 
     
327.   
     
328.   if ((this_tcphdr->th_flags & TH_ACK)) { 
     
329.        
     
330.   
     
331.    /* 从数据传输过程不断更新服务器客户端的ack_seq 
     
332.     一直到接收到fin 包，数据传输结束 
     
333. 
     
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.  /* 
     
352. 
     
353. ************************************************************* 
     
354.                         数据处理过程 
     
355. ************************************************************* 
     
356. 
     
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 -----接收包 
     
370. 
     
371.     (char *) (this_tcphdr) + 4 * this_tcphdr->th_off -----数据包内容 
     
372.     datalen---------数据包长度 
     
373.       
     
374. 
     
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
     
413. 
     
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
     
422. 
     
423. 
     
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;
     
437. 
     
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;
     
444. 
     
445.   }
     
446.   
     
447. #if 0
     
448.   check_flags(this_iphdr, this_tcphdr);
     
449. //ECN
     
450. 
     
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.   }
     
468. 
     
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.   }
     
477. 
     
478. /**********************************************************************
     
479.     三次握手的第二次握手
     
480. 
     
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;
     
487. 
     
488. /*第二次回应包的ACK 值为第一个包的序列号+1,在初始化的时候已经加一*/ 
     
489.     if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack))
     
490.       return;
     
491. 
     
492. 
     
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);
     
500. 
     
501.   /*对于tcp 选项的赋值*/ 
     
502.   //初始化客户端和服务器的时间截
     
503. 
     
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; 
     
509. 
     
510. //初始化窗口大小 
     
511. 
     
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.  /*第二次握手完毕，返回*/
     
524. 
     
525.     return;
     
526.   }
     
527.   
     
528. 
     
529. 
     
530.    /*
     
531.                 (如果有数据存在或者修列号不等于确认号的)并且
     
532.   序列号在窗口之外
     
533.    已经确认过的序号
     
534.    */
     
535. 
     
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.   }
     
558. 
     
559. 
     
560.   /* PAWS check */
     
561.   if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) && 
     
562.    before(tmp_ts, snd->curr_ts))
     
563.   return; 
     
564. 
     
565. 
     
566. 
     
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;
     
655. 
     
656.     }
     
657.   }
     
658. 
     
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));
     
671. 
     
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.   }
     
683. 
     
684.  /*
     
685. ************************************************************* 
     
686.       数据处理过程
     
687. *************************************************************
     
688.  */
     
689. 
     
690. 
     
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---------数据包长度
     
701. 
     
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);
     
716. 
     
717. }
     
718. 
     
719. view plaincopy to clipboardprint?
     
720. //判断 该TCP 数据包是添加到数据区还是添加到list双向链表中 
     
721. 
     
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.   /* 
     
741. 
     
742.   EXP_SEQ 期望到达的数据 
     
743.   this_seq 实际到达的数据 
     
744. 
     
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.     /*有重叠数据存在(重叠数据怎么处理呢) 
     
753. 
     
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.      /* 
     
777. 
     
778.         期望的序列号小于该包的序列号则直接返回 
     
779. 
     
780.      */ 
     
781.     if (after(pakiet->seq, EXP_SEQ)) 
     
782.       break; 
     
783.        
     
784.     /* 
     
785. 
     
786.     对失序队列数据包的处理 
     
787. 
     
788.        如果包序列号加上长度还小于期望序列号 
     
789.        则把该包添加到数据区，并在失序队列中删除该包 
     
790. 
     
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双向链表中 
     
823. 
     
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.       /* 
     
862. 
     
863.          硬件接收一个tcp 终止的链接， 
     
864.          即使包在一个结束包的时候丢失，并且不再重传， 
     
865.          处理这种方法就是引入时间机制处理 
     
866. 
     
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 赋值 
     
878. 
     
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双向链表中
     
919. 
     
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;
     
929. 
     
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*/
     
942. 
     
943.     /*有重叠数据存在(重叠数据怎么处理呢)
     
944.         也可能没有重叠数据
     
945.      */
     
946. 
     
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.  */
     
960. 
     
961.      /*从头节点释放节点*/
     
962.       pakiet = rcv->list;
     
963.       while (pakiet) {
     
964.   /*
     
965.   期望的序列号小于该包的序列号则直接返回 
     
966.   */ 
     
967.  if (after(pakiet->seq, EXP_SEQ))
     
968.    break;
     
969. 
     
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;
     
981. 
     
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双向链表中
      
1004. 
      
1005. 
      
1006.   /*链表加入节点 */
      
1007.   else {
      
1008.     /*初始化*/ 
      
1009.     struct skbuff *p = rcv->listtail;
      
1010.        /*
      
1011.  pakiet 加入rcv->listtal 链表中 
      
1012.        */
      
1013.        /*
      
1014.  pakiet 节点的初始化
      
1015. 
      
1016.  */
      
1017. 
      
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.     }
      
1049. 
      
1050.      /*
      
1051. 
      
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);
      
1058. 
      
1059.     for (;;) {
      
1060.   
      
1061.       if (!p || !after(p->seq, this_seq))
      
1062.  break;
      
1063.       p = p->prev;
      
1064. }
      
1065. 
      
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.     }
      
1087. 
      
1088.   }
      
1089.   
      
1090. }
      
1091. 
      
1092. view plaincopy to clipboardprint?
      
1093. /* 
      
1094. 
      
1095. 分配空间，数据保存rcv->data 中 
      
1096. 长度为:rcv->count 
      
1097. 新数据为date 
      
1098. 长度为datalen 
      
1099. 
      
1100. 
      
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
      
1152. 
      
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.   }
      
1187. 
      
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. /* 
      
1196. 
      
1197. 通知服务器或者客户端接受数据 
      
1198. 
      
1199. */ 
      
1200.   
      
1201. static void 
      
1202. notify(struct tcp_stream * a_tcp, struct half_stream * rcv) 
      
1203. { 
      
1204.   
      
1205. /* 
      
1206. 
      
1207. 监听节点 
      
1208. 
      
1209. */ 
      
1210.   struct lurker_node *i, **prev_addr; 
      
1211.   char mask; 
      
1212.   
      
1213. /* 
      
1214. 
      
1215. 紧急数据 
      
1216. 
      
1217. 
      
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. /* 
      
1233. 
      
1234. 常规数据 
      
1235. 
      
1236. */ 
      
1237.   
      
1238.   if (rcv->collect) { 
      
1239.     if (rcv == &a_tcp->client) 
      
1240.       mask = COLLECT_cc; 
      
1241.     else 
      
1242.       mask = COLLECT_sc; 
      
1243.   
      
1244.   /* 
      
1245. 
      
1246.   不断读取数据，一直到 
      
1247. 
      
1248. 
      
1249.   读取到数据结束 
      
1250. 
      
1251.   */ 
      
1252.        
      
1253.    do { 
      
1254.             int total; 
      
1255.   
      
1256.         /* 
      
1257. 
      
1258.             a_tcp 为为收到的datalen 
      
1259. 
      
1260.             total = dalalen; 
      
1261. 
      
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 指向新数据 
      
1281. 
      
1282.             rcv->count_new 为新数据的长度 
      
1283.               
      
1284. 
      
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 
      
1293. 
      
1294.   
      
1295. /* 
      
1296. 
      
1297. rcv->count_new 初始化为0 
      
1298. 
      
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. 紧急数据
      
1332. 
      
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;
      
1341. 
      
1342.     ride_lurkers(a_tcp, mask);
      
1343.     goto prune_listeners;
      
1344.   }
      
1345. 
      
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.   不断读取数据，一直到
      
1356. 
      
1357.   读取到数据结束
      
1358.   */
      
1359. 
      
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);
      
1371. 
      
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
      
1391. 
      
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.     }
      
1411. 
      
1412. }