libpcap报文解析: ipv4、ipv6 @ 2014.7.2

  1 #include <string.h>
  2 #include <stdlib.h>
  3 #include <pcap.h>
  4 #include <stdio.h>
  5 #include <sys/time.h>
  6 #include <unistd.h>
  7 #include <netinet/in.h>
  8 #include <pthread.h>
  9 #include "packet_header.h"
 10 #include <iostream>
 11 #include <string>
 12 using namespace std;
 13 
 14 #define MAXBYTE2CAPTURE 2048
 15 
 16 pthread_t g_thread[2];
 17 pthread_mutex_t g_mutex;
 18 
 19 int isprint(char c)
 20 {
 21     return 0;
 22 }
 23 
 24 void print_buf(u_char* pBuf, u_int32 len)
 25 {
 26     if (!pBuf)
 27     {
 28         return;
 29     }
 30 
 31     for(int i=0; i<len; i++)
 32     {
 33         printf("%02x ",  (u_char*)pBuf[i]);
 34 
 35         if ((i%16 == 0 && i!=0) || i == len-1)
 36         {
 37             printf("\r\n");
 38         }
 39     }
 40 }
 41 
 42 void parse_ethII(u_char* pData, u_int32 len)
 43 {
 44     if (!pData || len <14)
 45     {
 46         return;
 47     }
 48 
 49     printf("eth II frame: \r\n");
 50     print_buf(pData, 14);
 51 
 52     /* parse src mac and dst mac */
 53     EthHeader_t* pEth = (EthHeader_t*)pData;
 54     printf("destination: %02x:%02x:%02x:%02x:%02x:%02x ",
 55         pEth->dest_hwaddr[0],
 56         pEth->dest_hwaddr[1],
 57         pEth->dest_hwaddr[2],
 58         pEth->dest_hwaddr[3],
 59         pEth->dest_hwaddr[4],
 60         pEth->dest_hwaddr[5]);
 61 
 62     printf("source : %02x:%02x:%02x:%02x:%02x:%02x",
 63         pEth->source_hwaddr[0],
 64         pEth->source_hwaddr[1],
 65         pEth->source_hwaddr[2],
 66         pEth->source_hwaddr[3],
 67         pEth->source_hwaddr[4],
 68         pEth->source_hwaddr[5]);
 69 
 70     /* parse frame type */
 71     printf("\r\nframe type: 0x%x\r\n", ntohs(pEth->frame_type));
 72 }
 73 
 74 
 75 void parse_ipheader(u_char* pData, u_int32 len)
 76 {
 77     if (!pData || len <14)
 78     {
 79         return;
 80     }
 81 
 82     printf("ip header: \r\n");
 83     print_buf(pData, 20);
 84 
 85     /* parse ip header */
 86     IPHeader_t* pIpHeader = (IPHeader_t*)pData;
 87     printf("\tversion     : %02x\r\n"
 88            "\ttos         : %02x\r\n"
 89            "\ttotal length: %d(0x%02x)\r\n"
 90            "\tid          : %d(0x%02x)\r\n"
 91            "\tsegment flag: %d(0x%02x)\r\n"
 92            "\tttl         : %02x\r\n"
 93            "\tprotocol    : %02x\r\n"
 94            "\tchecksum    : %d(0x%02x)\r\n"
 95            "\tsrc ip      : %d.%d.%d.%d\r\n"
 96            "\tdst ip      : %d.%d.%d.%d\r\n",
 97         pIpHeader->Ver_HLen,
 98         pIpHeader->TOS,
 99         ntohs(pIpHeader->TotalLen), ntohs(pIpHeader->TotalLen),
100         ntohs(pIpHeader->ID), ntohs(pIpHeader->ID),
101         ntohs(pIpHeader->Flag_Segment), ntohs(pIpHeader->Flag_Segment),
102         pIpHeader->TTL,
103         pIpHeader->Protocol,
104         ntohs(pIpHeader->Checksum), ntohs(pIpHeader->Checksum),
105         pIpHeader->SrcIP[0],pIpHeader->SrcIP[1],pIpHeader->SrcIP[2],pIpHeader->SrcIP[3],
106         pIpHeader->DstIP[0],pIpHeader->DstIP[1],pIpHeader->DstIP[2],pIpHeader->DstIP[3]);
107 }
108 
109 void parse_ip6header(u_char* pData, u_int32 len)
110 {
111     if (!pData || len <14)
112     {
113         return;
114     }
115 
116     printf("ipv6 header: \r\n");
117     print_buf(pData, 40);
118 
119     /* parse ipv6 header */
120     IPv6Header_t* pIpv6Header = (IPv6Header_t*)pData;
121     printf("\tversion           : %x\r\n"
122            "\ttraffic class     : %x\r\n"
123            "\tflow label        : %x\r\n"
124            "\tpayload length    : %x\r\n"
125            "\tnext header       : %x\r\n"
126            "\thop limit         : %x\r\n"
127            "\tsource            : %x\r\n"
128            "\tdestination       : %x\r\n",
129            pIpv6Header->ip6_ctlun.ip6_un2_vfc,
130            pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_flow,
131            pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_flow,
132            pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_plen,
133            pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_nxt,
134            pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_hlim,
135            pIpv6Header->ip6_src,
136            pIpv6Header->ip6_dst);
137 }
138 
139 
140 void parse_packet(const u_char* packet, u_int32 len)
141 {
142     u_short ftype = 0;
143 
144     if (!packet)
145     {
146         return ;
147     }
148 
149     u_char* pMbuf = (u_char*)packet;
150     parse_ethII(pMbuf, len);
151 
152     ftype = ntohs(((EthHeader_t*)pMbuf)->frame_type);
153     switch(ftype)
154     {
155         case 0x0800:  /* ipv4 */
156             pMbuf = (u_char*)packet + 14;
157             parse_ipheader(pMbuf, len-14);
158             break;
159         case 0x86dd: /* ipv6 */
160             pMbuf = (u_char*)packet + 14;
161             parse_ip6header(pMbuf, len-14);
162             break;
163         default:
164             printf("frame type : 0x%x\r\n", ftype);
165             break;
166     }
167 
168     printf("\r\n");
169 }
170 
171 void processPacket(u_char *arg, const struct pcap_pkthdr *pkthdr, const u_char *packet)
172 {
173     int i = 0, *counter = (int *)arg;
174 
175     printf("--------------------------------------------\r\n");
176     printf("Packet Count: %d\n", ++(*counter));
177     printf("Received Packet Size: %d\n", pkthdr->len);
178     printf("Payload:\n");
179 
180 #if 1
181     for (i = 0; i < pkthdr->len; i++)
182     {
183         if (isprint(packet[i]))
184         {
185             printf("%02d ", packet[i]);
186         }
187         else
188         {
189             printf("%02x ", packet[i]);
190         }
191 
192         if ((i % 16 == 0 && i != 0) || i == pkthdr->len-1)
193         {
194             printf("\n");
195         }
196 
197     }
198 #endif
199 
200     parse_packet(packet, pkthdr->len);
201 
202     return;
203 }
204 
205 
206 void* thread_recv_pkt(void *)
207 {
208     while(1)
209     {
210         cout << "recv pkt: " << endl;
211         sleep(1);
212     }
213 }
214 
215 void* thread_send_pkt(void *)
216 {
217     while (1)
218     {
219         cout << "send pkt: " << endl;
220         sleep(1);
221     }
222 }
223 
224 int create_pkt_process_task()
225 {
226     int ret = 0;
227 
228     memset(&g_thread, 0, sizeof(g_thread));
229 
230     ret = pthread_create(&g_thread[0], NULL, thread_send_pkt, NULL);
231     if (0 == ret)
232     {
233         cout << "packet send thread create successfully." << endl;
234     }
235     else
236     {
237         cout << "packet send thread create failed." << endl;
238     }
239 
240     ret = pthread_create(&g_thread[1], NULL, thread_recv_pkt, NULL);
241     if (0 == ret)
242     {
243         cout << "packet send thread create successfully." << endl;
244     }
245     else
246     {
247         cout << "packet send thread create failed." << endl;
248     }
249 
250     return 0;
251 }
252 
253 void pkt_process_task_wait()
254 {
255     if(g_thread[0] !=0)
256     {                   //comment4
257        pthread_join(g_thread[0],NULL);
258        printf("线程1 已经结束\n");
259     }
260 
261     if(g_thread[1] !=0)
262     {                //comment5
263         pthread_join(g_thread[1],NULL);
264         printf("线程2 已经结束\n");
265     }
266 }
267 
268 int main()
269 {
270 
271     int i = 0, count = 0;
272     pcap_t *descr = NULL;
273     char errbuf[PCAP_ERRBUF_SIZE], *device = NULL;
274 
275     memset(errbuf, 0, PCAP_ERRBUF_SIZE);
276 
277     create_pkt_process_task();
278     pkt_process_task_wait();
279 
280     /* Get the name of the first device suitable for capture */
281     device = pcap_lookupdev(errbuf);
282     if (!device)
283     {
284         printf("Open device failed.");
285         return -1;
286     }
287 
288     printf("Opening device %s\n", device);
289 
290     /* Open device in promiscuous mode */
291     descr = pcap_open_live(device, MAXBYTE2CAPTURE, 1, 512, errbuf);
292 
293     /* Loop forever & call processPacket() for every received packet */
294     pcap_loop(descr, -1, processPacket, (u_char *)&count);
295 
296     return 0;
297 }