队列 实现 抓包

主要原理很简单，就是用一个队列（Queue）对高峰流量做一下缓冲，先存下来再慢慢分析。计算机专业的人应该就容易了，数据结构有讲。

整个程序代码比较长就不贴了，把队列代码贴在下面吧，放在网上的比硬盘的还是方便一点，随时可以查阅，以备不时之需。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <malloc.h>
4. #include <string.h>
6. typedef struct _Node
7. {
8. int data_len; // 存储在节点中的数据长度
9. char *data; // 存储在节点中的数据
10. struct _Node *next; // 队列中的下一个节点地址
11. }NODE;
13. typedef struct _Queue
14. {
15. NODE *head; // 队列的头部
16. NODE *end; // 队列的尾部
17. int count; // 队列长度
18. }QUEUE;
20. bool InitQueue ( QUEUE *queue )
21. {
22. if ( NULL == queue )
23. {
24. return false;
25. }
27. queue->head = NULL;
28. queue->end = NULL;
29. queue->count = 0;
31. return true;
32. }
34. // 在队列中插入节点
35. bool Enqueue ( QUEUE *queue, char *queue_data, int data_len )
36. {
37. if ( NULL == queue || NULL == queue_data )
38. {
39. return false;
40. }
42. // 开辟新节点
43. NODE *new_node = (NODE * ) malloc ( sizeof (NODE ) );
44. if ( NULL == new_node )
45. {
46. return false;
47. }
49. // 开辟空间存储数据
50. new_node->data = ( char * ) malloc ( data_len );
51. if ( NULL == new_node->data )
52. {
53. return false;
54. }
56. memcpy ( new_node->data, queue_data, data_len );
57. new_node->next = NULL;
58. new_node->data_len = data_len;
60. // 如果队列为空，则新节点即是头部，也是尾部
61. if ( queue->head == NULL )
62. {
63. queue->head = new_node;
64. queue->end = new_node;
65. }
66. else
67. {
68. // 如果队列不为空，将此节点连接到队列的尾部
69. queue->end->next = new_node;
71. // 队列新尾部指向此节点
72. queue->end = new_node;
73. }
75. queue->count ++;
76. return true;
77. }
79. // 从队列中读出一个节点
80. NODE *Dequeue ( QUEUE *queue )
81. {
82. if ( NULL == queue )
83. {
84. return NULL;
85. }
87. // 如果队列为空，则无数据可从数列读出，直接返回
88. if ( NULL == queue->head )
89. {
90. return NULL;
91. }
93. // 保存队列首节点
94. NODE *node_tmp = queue->head;
96. // 将首节点的下一个节点（第二个节点）设置为首节点，即删除了首节点
97. queue->head = node_tmp->next;
99. // 如果新首节点为空，则队列为空
100. if ( NULL == queue->head )
101. {
102. queue->end = NULL;
103. }
105. queue->count --;
106. return node_tmp;
107. }
109. // 释放队列所有内存
110. void FreeQueue ( QUEUE *queue )
111. {
112. if ( !queue )
113. {
114. return;
115. }
117. NODE *tmp_node1 = queue->head;
118. while ( tmp_node1 )
119. {
120. NODE *tmp_node2 = tmp_node1;
122. free ( tmp_node1->data );
123. free ( tmp_node1 );
125. tmp_node1->data = NULL;
126. tmp_node1 = NULL;
128. tmp_node1 = tmp_node2->next;
129. }
130. }

这样没抓到一个包，就压入到队列里面。流量较大的尖峰时刻时候队列会比较长，但是流量较小的时候队列就比较短了。服务器流量不会一直保持在顶峰，所以可以把部分过高的流量缓冲到流量较小的时候做分析，测试的时候发现确实稳定了很多。首先需要注意的是设置一个队列最大长度，必要的时候丢掉一些数据免得内存耗尽。另外一个是分析的时候可以多线程读取队列进行分析，这样速度会更快，只是做好线程的同步就好了，CreateMutex是最简单易行的了。我用5线程来分析数据包，基本足够了。