迎接ChinaUnix九周年庆技术实践之二----C/C++编程大赛！-结果公布！

冰点柔情521

where is the amazing,where is the creativity.look at here.

hq8318

回复 170# renxiao2003


    What?我只是问问怎么不延期。

fenzhy

阿门

fytzzh

无语， 有点不靠谱

Paranoia

为什么没人出来解释

renxiao2003

开奖啊。

zhangchuhu

做了下第二题。只是处理了ip数据帧，传输层。

1. 
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <netdb.h>
   
7. #include <sys/ioctl.h>
   
8. #include <sys/types.h>
   
9. #include <sys/socket.h>
   
10. #include <netinet/ip.h>
    
11. #include <netinet/in.h>
    
12. #include <netinet/tcp.h>
    
13. #include <netinet/udp.h>
    
14. #include <netpacket/packet.h>
    
15. #include <net/ethernet.h>
    
16. #include <net/if.h>
    
17. #include <arpa/inet.h>
    
18. #include <errno.h>
    
19. #include <vector>
    
20. using namespace std;
    
21. /* 接收缓冲区大小 */
    
22. #define RCV_BUF_SIZE     1024 * 5
    
23. 
    
24. /* 接收缓冲区 */
    
25. static int g_iRecvBufSize = RCV_BUF_SIZE;
    
26. static char g_acRecvBuf[RCV_BUF_SIZE] = {0};
    
27. 
    
28. /* 物理网卡接口,需要根据具体情况修改 */
    
29. static const char *g_szIfName = "eth0";
    
30. struct packetInfo
    
31. {
    
32.         char * sip;
    
33.         char * desip;
    
34.         short int sport;
    
35.         short int desport;
    
36.         char *protocol;
    
37.         int count;
    
38. };
    
39. 
    
40. /* 物理网卡混杂模式属性操作 */
    
41. static int ethdump_setPromisc(const char *pcIfName, int fd, int iFlags)
    
42. {
    
43.         int iRet = -1;
    
44.         struct ifreq stIfr;
    
45. 
    
46.         /* 获取接口属性标志位 */
    
47.         strcpy(stIfr.ifr_name, pcIfName);
    
48.         iRet = ioctl(fd, SIOCGIFFLAGS, &stIfr);
    
49.         if (0 > iRet)
    
50.         {
    
51.                 perror("[Error]Get Interface Flags");   
    
52.                 return -1;
    
53.         }
    
54. 
    
55.         if (0 == iFlags)
    
56.         {
    
57.                 /* 取消混杂模式 */
    
58.                 stIfr.ifr_flags &= ~IFF_PROMISC;
    
59.         }
    
60.         else
    
61.         {
    
62.                 /* 设置为混杂模式 */
    
63.                 stIfr.ifr_flags |= IFF_PROMISC;
    
64.         }
    
65. 
    
66.         iRet = ioctl(fd, SIOCSIFFLAGS, &stIfr);
    
67.         if (0 > iRet)
    
68.         {
    
69.                 perror("[Error]Set Interface Flags");
    
70.                 return -1;
    
71.         }
    
72. 
    
73.         return 0;
    
74. }
    
75. 
    
76. 
    
77. /* Init L2 Socket */
    
78. static int ethdump_initSocket()
    
79. {
    
80.         int iRet = -1;
    
81.         int fd = -1;
    
82.         struct ifreq stIf;
    
83.         struct sockaddr_ll stLocal = {0};
    
84. 
    
85.         /* 创建SOCKET */
    
86.         fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    
87.         if (0 > fd)
    
88.         {
    
89.                 perror("[Error]Initinate L2 raw socket");
    
90.                 return -1;
    
91.         }
    
92. 
    
93.         /* 网卡混杂模式设置 */
    
94.         ethdump_setPromisc(g_szIfName, fd, 1);
    
95. 
    
96.         /* 设置SOCKET选项 */
    
97.         iRet = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &g_iRecvBufSize,sizeof(int));
    
98.         if (0 > iRet)
    
99.         {
    
100.                 perror("[Error]Set socket option");
     
101.                 close(fd);
     
102.                 return -1;
     
103.         }
     
104. 
     
105.         /* 获取物理网卡接口索引 */
     
106.         strcpy(stIf.ifr_name, g_szIfName);
     
107.         iRet = ioctl(fd, SIOCGIFINDEX, &stIf);
     
108.         if (0 > iRet)
     
109.         {
     
110.                 perror("[Error]Ioctl operation");
     
111.                 close(fd);
     
112.                 return -1;
     
113.         }
     
114. 
     
115.         /* 绑定物理网卡 */
     
116.         stLocal.sll_family = PF_PACKET;
     
117.         stLocal.sll_ifindex = stIf.ifr_ifindex;
     
118.         stLocal.sll_protocol = htons(ETH_P_ALL);
     
119.         iRet = bind(fd, (struct sockaddr *)&stLocal, sizeof(stLocal));
     
120.         if (0 > iRet)
     
121.         {
     
122.                 perror("[Error]Bind the interface");
     
123.                 close(fd);
     
124.                 return -1;
     
125.         }
     
126. 
     
127.         return fd;   
     
128. }
     
129. 
     
130. /* 捕获网卡数据帧 */
     
131. static void ethdump_startCapture(const int fd)
     
132. {
     
133.         packetInfo DataPacketInfo;
     
134.         vector<packetInfo> v_PacketInfo;
     
135. 
     
136.         int iRet = -1;
     
137.         socklen_t stFromLen = 0;
     
138. 
     
139.         /* 循环监听 */
     
140.         while(1)
     
141.         {
     
142.                 struct protoent *pstIpProto = NULL;
     
143.                 /*Ethnet帧头结构体*/
     
144.                 struct ether_header *pstEthHead = NULL;
     
145.                 /*IP数据包包头结构体*/
     
146.                 struct ip *pstIpHead = NULL;
     
147.                 /* 清空接收缓冲区 */
     
148.                 memset(g_acRecvBuf, 0, RCV_BUF_SIZE);
     
149. 
     
150.                 /* 接收数据帧 */
     
151.                 iRet = recvfrom(fd, g_acRecvBuf, g_iRecvBufSize, 0, NULL, &stFromLen);
     
152.                 if (0 > iRet)
     
153.                 {
     
154.                         continue;
     
155.                 }
     
156.                 /*获得Ethnet帧分装的数据包协议类型*/
     
157.                 unsigned short usEthPktType;
     
158.                 pstEthHead=(ether_header*)g_acRecvBuf;
     
159.                 if (NULL == pstEthHead)
     
160.                 {
     
161.                         exit(-1);
     
162.                 }
     
163. 
     
164.                 /* 协议类型、源MAC、目的MAC */
     
165.                 usEthPktType = ntohs(pstEthHead->ether_type);
     
166.                 printf(">>> Eth-Pkt-Type:0x%04x ", usEthPktType);
     
167.                 if(usEthPktType==0x0800)
     
168.                         {
     
169.                 /*去除Ethnet帧头，获得IP数据包头的开始位置*/
     
170.                 pstIpHead=(ip*)(pstEthHead+1);
     
171.     DataPacketInfo.count=1;
     
172.                 if (NULL == pstIpHead)
     
173.                 {
     
174.                         exit(-1);
     
175.                 }
     
176. 
     
177. 
     
178.                 /* 传输层协议类型、源IP地址、目的IP地址 */
     
179.                 pstIpProto = getprotobynumber(pstIpHead->ip_p);
     
180.                 if(NULL != pstIpProto)
     
181.                 {
     
182.                         DataPacketInfo.protocol=pstIpProto->p_name;
     
183.                         printf(" IP-Pkt-Type:%d(%s) ", pstIpHead->ip_p, pstIpProto->p_name);
     
184.                 }
     
185.                 else
     
186.                 {
     
187.                         printf(" IP-Pkt-Type:%d(%s) ", pstIpHead->ip_p, "None");
     
188.                 }
     
189.                 DataPacketInfo.sip=inet_ntoa(pstIpHead->ip_src);
     
190.                 DataPacketInfo.desip=inet_ntoa(pstIpHead->ip_dst);
     
191.                 if(6==pstIpHead->ip_p)//如果传输层协议为TCP
     
192.                 {
     
193.                         struct tcphdr *ptcphdr=NULL;
     
194.                         ptcphdr=(tcphdr *)(pstIpHead+1);
     
195. 
     
196.                         if (NULL == ptcphdr)
     
197.                         {
     
198.                                 exit(-1);
     
199.                         }
     
200. 
     
201.                         printf("TCP SPort=[%d] ", ntohs(ptcphdr->source));
     
202.                         printf("TCP DPort=[%d]\n ",ntohs(ptcphdr->dest));
     
203.                         DataPacketInfo.sport= ntohs(ptcphdr->source);
     
204.                         DataPacketInfo.desport=ntohs(ptcphdr->dest);
     
205. 
     
206.                 }
     
207.                 else if(17==pstIpHead->ip_p)
     
208.                 {
     
209.                         struct udphdr* pudphdr=NULL;
     
210.                         pudphdr=(udphdr*)(pstIpHead+1);
     
211.                         if (NULL == pudphdr)
     
212.                         {
     
213.                                 exit(-1);
     
214.                         }
     
215. 
     
216.                         printf("UDP SPort=[%d] ", pudphdr->source);
     
217.                         printf("UDP DPort=[%d]\n ",pudphdr->dest);
     
218.                         DataPacketInfo.sport= ntohs(pudphdr->source);
     
219.                         DataPacketInfo.desport=ntohs(pudphdr->dest);
     
220.                 }
     
221.                 else
     
222.                 {
     
223.                         printf("UNKOWN PROTOCOL\n");
     
224.                 }
     
225.                 bool flag(0);
     
226.                 for(int i=0;i++;i<v_PacketInfo.size())
     
227.                 {
     
228.                         if (DataPacketInfo.sip==v_PacketInfo[i].sip&&DataPacketInfo.desip==v_PacketInfo[i].desip&&
     
229.                                 DataPacketInfo.sport==v_PacketInfo[i].sport&&DataPacketInfo.desport==v_PacketInfo[i].desport&&
     
230.                                 DataPacketInfo.protocol==v_PacketInfo[i].protocol)
     
231.                         {
     
232.                                 v_PacketInfo[i].count++;
     
233.                                 flag=1;
     
234.                                 break;
     
235.                         }
     
236.                        
     
237.                 }
     
238.                 if(!flag)
     
239.                 {
     
240.           v_PacketInfo.push_back(DataPacketInfo);
     
241.                 }
     
242.   }
     
243.     else
     
244.             {
     
245.                     printf("NOT IP PROTOCOL\n");
     
246.             }
     
247.         }
     
248. }   
     
249. 
     
250. /* Main */
     
251. int main(int argc, char *argv[])
     
252. {
     
253.         int iRet = -1;
     
254.         int fd   = -1;
     
255. 
     
256.         /* 初始化SOCKET */
     
257.         fd = ethdump_initSocket();
     
258.         if(0 > fd)
     
259.         {
     
260.                 return -1;
     
261.         }
     
262. 
     
263.         /* 捕获数据包 */
     
264.         ethdump_startCapture(fd);
     
265. 
     
266.         /* 关闭SOCKET */
     
267.         close(fd);
     
268. 
     
269.         return 0;
     
270. }
     

复制代码

yifangyou

哈，我已经提交了perl的比赛代码，什么时候也弄个java的比赛

hq8318

如果java的比赛，我也考虑参加。

whqingstar

看了好友压力啊，回去得好好学了