Winpcap网络编程九之Winpcap实战,ARP协议获得MAC表及主机通信

大家好，本次我们需要完成的任务是：

 完成两台主机之间的数据通信（数据链路层）

• 仿真ARP协议获得网段内主机的MAC表
• 使用帧完成两台主机的通信（Hello! I’m …)        

声明：本文章的目的是为大家的Winpcap编程带来一定的借鉴，希望对大家的课程设计有一定的帮助。总之，我相信，大家看了前几篇 Winpcap 编程基础知识，再加上这篇文章的讲解，一步一步做下来，相信你能成功的。

P.S. 对Winpcap编程的基础知识有一定了解的就不用再去费工夫学习咯。我也是一点一点学习的，在此提供给大家一个学习文档，Winpcap中文文档

P.P.S. 另外....CSDN略坑爹....我的代码它可能自动转码...我都为此改了好多次了...代码有显示问题与我联系...邮箱 1016903103@qq.com ...以后转自己个人空间...

好了话不多说，我们步入正题...

首先我们要理解ARP是干嘛的，ARP主要作用就是通过IP地址来获取MAC地址。那么怎样获取呢？本机向局域网内主机发送ARP包，ARP包内包含了目的IP，源IP，目的MAC，源MAC，其中目的MAC地址为广播地址,FF-FF-FF-FF-FF-FF,即向局域网内所有主机发送一个ARP请求，那么其他主机收到这个请求之后则会向请求来源返回一个数据包。在这个返回的数据包中包含了自身的MAC地址。那么本机收到这些返回的数据包进行解析之后便会得到局域网内所有主机的MAC地址了..

编程开始：

新建一个C++项目，配好环境，引入Winpcap相关的库，这些不再赘述。

头文件引入

[cpp]  view plain  copy

1. #define HAVE_REMOTE  
2. #define WPCAP  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5. #include <pcap.h>  

在main函数中首先声明一系列变量如下

[cpp]  view plain  copy

1. char *ip_addr;                                    //IP地址  
2. char *ip_netmask;                             //子网掩码  
3. unsigned char *ip_mac;          //本机MAC地址  

为这三个变量分配地址空间

[cpp]  view plain  copy

1. ip_addr = (char *) malloc(sizeof(char) * 16); //申请内存存放IP地址  
2.     if (ip_addr == NULL)  
3.     {  
4.         printf("申请内存存放IP地址失败!\n");  
5.         return -1;  
6.     }  
7.     ip_netmask = (char *) malloc(sizeof(char) * 16); //申请内存存放NETMASK地址  
8.     if (ip_netmask == NULL)  
9.     {  
10.         printf("申请内存存放NETMASK地址失败!\n");  
11.         return -1;  
12.     }  
13.     ip_mac = (unsigned char *) malloc(sizeof(unsigned char) * 6); //申请内存存放MAC地址  
14.     if (ip_mac == NULL)  
15.     {  
16.         printf("申请内存存放MAC地址失败!\n");  
17.         return -1;  
18.     }  

接下来就是烂大街的程序,获取适配器列表并选中相应的适配器,注释已经在代码中了,如果还有不明白的请参照前几次的讲解。

[cpp]  view plain  copy

1. //获取本地适配器列表  
2.     if(pcap_findalldevs_ex(PCAP_SRC_IF_STRING,NULL,&alldevs,errbuf) == -1){  
3.         //结果为-1代表出现获取适配器列表失败  
4.         fprintf(stderr,"Error in pcap_findalldevs_ex:\n",errbuf);  
5.         //exit(0)代表正常退出,exit(other)为非正常退出,这个值会传给操作系统  
6.         exit(1);  
7.     }  
8.       
9.   
10.     for(d = alldevs;d !=NULL;d = d->next){  
11.         printf("-----------------------------------------------------------------\nnumber:%d\nname:%s\n",++i,d->name);  
12.         if(d->description){  
13.             //打印适配器的描述信息  
14.             printf("description:%s\n",d->description);  
15.         }else{  
16.             //适配器不存在描述信息  
17.             printf("description:%s","no description\n");  
18.         }  
19.         //打印本地环回地址  
20.          printf("\tLoopback: %s\n",(d->flags & PCAP_IF_LOOPBACK)?"yes":"no");  
21.          /** 
22.          pcap_addr *  next     指向下一个地址的指针 
23.          sockaddr *  addr       IP地址 
24.          sockaddr *  netmask  子网掩码 
25.          sockaddr *  broadaddr   广播地址 
26.          sockaddr *  dstaddr        目的地址 
27.          */  
28.          pcap_addr_t *a;       //网络适配器的地址用来存储变量  
29.          for(a = d->addresses;a;a = a->next){  
30.              //sa_family代表了地址的类型,是IPV4地址类型还是IPV6地址类型  
31.              switch (a->addr->sa_family)  
32.              {  
33.                  case AF_INET:  //代表IPV4类型地址  
34.                      printf("Address Family Name:AF_INET\n");  
35.                      if(a->addr){  
36.                          //->的优先级等同于括号,高于强制类型转换,因为addr为sockaddr类型，对其进行操作须转换为sockaddr_in类型  
37.                          printf("Address:%s\n",iptos(((struct sockaddr_in *)a->addr)->sin_addr.s_addr));  
38.                      }  
39.                     if (a->netmask){  
40.                          printf("\tNetmask: %s\n",iptos(((struct sockaddr_in *)a->netmask)->sin_addr.s_addr));  
41.                     }  
42.                     if (a->broadaddr){  
43.                            printf("\tBroadcast Address: %s\n",iptos(((struct sockaddr_in *)a->broadaddr)->sin_addr.s_addr));  
44.                      }  
45.                      if (a->dstaddr){  
46.                            printf("\tDestination Address: %s\n",iptos(((struct sockaddr_in *)a->dstaddr)->sin_addr.s_addr));  
47.                      }  
48.                      break;  
49.                  case AF_INET6: //代表IPV6类型地址  
50.                      printf("Address Family Name:AF_INET6\n");  
51.                      printf("this is an IPV6 address\n");  
52.                      break;  
53.                  default:  
54.                      break;  
55.              }  
56.          }  
57.     }  
58.     //i为0代表上述循环未进入,即没有找到适配器,可能的原因为Winpcap没有安装导致未扫描到  
59.     if(i == 0){  
60.         printf("interface not found,please check winpcap installation");  
61.     }  
62.   
63.     int num;  
64.     printf("Enter the interface number(1-%d):",i);  
65.     //让用户选择选择哪个适配器进行抓包  
66.     scanf_s("%d",&num);  
67.     printf("\n");  
68.   
69.     //用户输入的数字超出合理范围  
70.     if(num<1||num>i){  
71.         printf("number out of range\n");  
72.         pcap_freealldevs(alldevs);  
73.         return -1;  
74.     }  
75.     //跳转到选中的适配器  
76.     for(d=alldevs, i=0; i< num-1 ; d=d->next, i++);  
77.   
78.     //运行到此处说明用户的输入是合法的  
79.     if((adhandle = pcap_open(d->name,        //设备名称  
80.                                                         65535,       //存放数据包的内容长度  
81.                                                         PCAP_OPENFLAG_PROMISCUOUS,  //混杂模式  
82.                                                         1000,           //超时时间  
83.                                                         NULL,          //远程验证  
84.                                                         errbuf         //错误缓冲  
85.                                                         )) == NULL){  
86.         //打开适配器失败,打印错误并释放适配器列表  
87.         fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);  
88.         // 释放设备列表   
89.         pcap_freealldevs(alldevs);  
90.         return -1;  
91.     }  

上述代码中需要另外声明的有：

[cpp]  view plain  copy

1. pcap_if_t  * alldevs;       //所有网络适配器  
2. pcap_if_t  *d;                  //选中的网络适配器  
3. char errbuf[PCAP_ERRBUF_SIZE];   //错误缓冲区,大小为256  
4. pcap_t *adhandle;           //捕捉实例,是pcap_open返回的对象  
5. int i = 0;                            //适配器计数变量  

[cpp]  view plain  copy

1. char *iptos(u_long in);       //u_long即为 unsigned long  

[cpp]  view plain  copy

1. /* 将数字类型的IP地址转换成字符串类型的 */  
2. #define IPTOSBUFFERS    12  
3. char *iptos(u_long in)  
4. {  
5.     static char output[IPTOSBUFFERS][3*4+3+1];  
6.     static short which;  
7.     u_char *p;  
8.   
9.     p = (u_char *)&in;  
10.     which = (which + 1 == IPTOSBUFFERS ? 0 : which + 1);  
11.     sprintf_s(output[which], "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);  
12.     return output[which];  
13. }  

到此程序应该会编译通过，可以试着编译一下运行。

Go ON...

接下来我们首先要用ifget方法获取自身的IP和子网掩码

函数声明：

[cpp]  view plain  copy

1. void ifget(pcap_if_t *d, char *ip_addr, char *ip_netmask);     

[cpp]  view plain  copy

1. //获取IP和子网掩码赋值为ip_addr和ip_netmask  
2. void ifget(pcap_if_t *d, char *ip_addr, char *ip_netmask) {  
3.     pcap_addr_t *a;  
4.     //遍历所有的地址,a代表一个pcap_addr  
5.     for (a = d->addresses; a; a = a->next) {  
6.         switch (a->addr->sa_family) {  
7.         case AF_INET:  //sa_family ：是2字节的地址家族，一般都是“AF_xxx”的形式。通常用的都是AF_INET。代表IPV4  
8.             if (a->addr) {  
9.                 char *ipstr;  
10.                 //将地址转化为字符串  
11.                 ipstr = iptos(((struct sockaddr_in *) a->addr)->sin_addr.s_addr); //*ip_addr  
12.                 printf("ipstr:%s\n",ipstr);  
13.                 memcpy(ip_addr, ipstr, 16);  
14.             }  
15.             if (a->netmask) {  
16.                 char *netmaskstr;  
17.                 netmaskstr = iptos(((struct sockaddr_in *) a->netmask)->sin_addr.s_addr);  
18.                 printf("netmask:%s\n",netmaskstr);  
19.                 memcpy(ip_netmask, netmaskstr, 16);  
20.             }  
21.         case AF_INET6:  
22.             break;  
23.         }  
24.     }  
25. }  

main函数继续写，如下调用，之前声明的ip_addr和ip_netmask就已经被赋值了

[cpp]  view plain  copy

1. ifget(d, ip_addr, ip_netmask); //获取所选网卡的基本信息--掩码--IP地址  

到现在我们已经获取到了本机的IP和子网掩码，下一步发送一个ARP请求来获取自身的MAC地址

这个ARP请求的源IP地址就随便指定了，就相当于你构造了一个外来的ARP请求，本机捕获到了请求，然后发送回应给对方的数据包也被本机捕获到了并解析出来了。解析了自己发出去的数据包而已。

那么我们就声明一个函数并实现：

[cpp]  view plain  copy

1. int GetSelfMac(pcap_t *adhandle, const char *ip_addr, unsigned char *ip_mac);  

[cpp]  view plain  copy

1. // 获取自己主机的MAC地址  
2. int GetSelfMac(pcap_t *adhandle, const char *ip_addr, unsigned char *ip_mac) {  
3.     unsigned char sendbuf[42]; //arp包结构大小  
4.     int i = -1;  
5.     int res;  
6.     EthernetHeader eh; //以太网帧头  
7.     Arpheader ah;  //ARP帧头  
8.     struct pcap_pkthdr * pkt_header;  
9.     const u_char * pkt_data;  
10.     //将已开辟内存空间 eh.dest_mac_add 的首 6个字节的值设为值 0xff。  
11.     memset(eh.DestMAC, 0xff, 6); //目的地址为全为广播地址  
12.     memset(eh.SourMAC, 0x0f, 6);  
13.     memset(ah.DestMacAdd, 0x0f, 6);  
14.     memset(ah.SourceMacAdd, 0x00, 6);  
15.     //htons将一个无符号短整型的主机数值转换为网络字节顺序  
16.     eh.EthType = htons(ETH_ARP);  
17.     ah.HardwareType= htons(ARP_HARDWARE);  
18.     ah.ProtocolType = htons(ETH_IP);  
19.     ah.HardwareAddLen = 6;  
20.     ah.ProtocolAddLen = 4;  
21.     ah.SourceIpAdd = inet_addr("100.100.100.100"); //随便设的请求方ip  
22.     ah.OperationField = htons(ARP_REQUEST);  
23.     ah.DestIpAdd = inet_addr(ip_addr);  
24.     memset(sendbuf, 0, sizeof(sendbuf));  
25.     memcpy(sendbuf, &eh, sizeof(eh));  
26.     memcpy(sendbuf + sizeof(eh), &ah, sizeof(ah));  
27.     printf("%s",sendbuf);  
28.     if (pcap_sendpacket(adhandle, sendbuf, 42) == 0) {  
29.         printf("\nPacketSend succeed\n");  
30.     } else {  
31.         printf("PacketSendPacket in getmine Error: %d\n", GetLastError());  
32.         return 0;  
33.     }  
34.     //从interface或离线记录文件获取一个报文  
35.     //pcap_next_ex(pcap_t* p,struct pcap_pkthdr** pkt_header,const u_char** pkt_data)  
36.     while ((res = pcap_next_ex(adhandle, &pkt_header, &pkt_data)) >= 0) {  
37.         if (*(unsigned short *) (pkt_data + 12) == htons(ETH_ARP)  
38.                 && *(unsigned short*) (pkt_data + 20) == htons(ARP_REPLY)  
39.                 && *(unsigned long*) (pkt_data + 38)  
40.                         == inet_addr("100.100.100.100")) {  
41.             for (i = 0; i < 6; i++) {  
42.                 ip_mac[i] = *(unsigned char *) (pkt_data + 22 + i);  
43.             }  
44.             printf("获取自己主机的MAC地址成功!\n");  
45.             break;  
46.         }  
47.     }  
48.     if (i == 6) {  
49.         return 1;  
50.     } else {  
51.         return 0;  
52.     }  
53. }  

其中我们需要定义一下常量如下

[cpp]  view plain  copy

1. #define ETH_ARP         0x0806  //以太网帧类型表示后面数据的类型，对于ARP请求或应答来说，该字段的值为x0806  
2. #define ARP_HARDWARE    1  //硬件类型字段值为表示以太网地址  
3. #define ETH_IP          0x0800  //协议类型字段表示要映射的协议地址类型值为x0800表示IP地址  
4. #define ARP_REQUEST     1   //ARP请求  
5. #define ARP_REPLY       2      //ARP应答  
6. #define HOSTNUM         255   //主机数量  

另外发送ARP请求少不了帧头和ARP头的结构，我们需要声明出来，另外我们构建发送包需要再声明两个结构体sparam和gparam

[cpp]  view plain  copy

1. //帧头部结构体，共14字节  
2. struct EthernetHeader  
3. {  
4.     u_char DestMAC[6];    //目的MAC地址 6字节  
5.     u_char SourMAC[6];   //源MAC地址 6字节  
6.     u_short EthType;         //上一层协议类型，如0x0800代表上一层是IP协议，0x0806为arp  2字节  
7. };  
8.   
9. //28字节ARP帧结构  
10. struct Arpheader {  
11.     unsigned short HardwareType; //硬件类型  
12.     unsigned short ProtocolType; //协议类型  
13.     unsigned char HardwareAddLen; //硬件地址长度  
14.     unsigned char ProtocolAddLen; //协议地址长度  
15.     unsigned short OperationField; //操作字段  
16.     unsigned char SourceMacAdd[6]; //源mac地址  
17.     unsigned long SourceIpAdd; //源ip地址  
18.     unsigned char DestMacAdd[6]; //目的mac地址  
19.     unsigned long DestIpAdd; //目的ip地址  
20. };  
21.   
22. //arp包结构  
23. struct ArpPacket {  
24.     EthernetHeader ed;  
25.     Arpheader ah;  
26. };  
27.   
28. struct sparam {  
29.     pcap_t *adhandle;  
30.     char *ip;  
31.     unsigned char *mac;  
32.     char *netmask;  
33. };  
34. struct gparam {  
35.     pcap_t *adhandle;  
36. };  
37.   
38. struct sparam sp;  
39. struct gparam gp;  

到现在代码也是完整可以运行的，如果有问题请检查上述代码完整性和位置。

可能出现的BUG：

只显示ARP发送成功，没有接受到并解析打印。可能的原因是帧构造有问题，字节没有对齐，有偏差，像#define一样

写入如下代码：

[cpp]  view plain  copy

1. #pragma pack(1)  //按一个字节内存对齐  

go ON..

获取到了自身的MAC地址之后，就可以在本机上构建ARP广播请求，向局域网内的所有主机发送ARP请求，得到回应之后解析回应的数据包并进行解析，得到对方的MAC地址。在这里我们需要开启两个线程，一个用来发送一个用来接收。好，我们继续..

先声明两个线程

[cpp]  view plain  copy

1. HANDLE sendthread;      //发送ARP包线程  
2. HANDLE recvthread;       //接受ARP包线程  

在main方法中继续写，对sp和gp两个ARP请求所需要的结构体进行赋值。赋值什么？就是你之前用ifget获取来的IP地址和子网掩码以及用getSelfMac获取来的MAC地址。

[cpp]  view plain  copy

1. sp.adhandle = adhandle;  
2.     sp.ip = ip_addr;  
3.     sp.mac = ip_mac;  
4.     sp.netmask = ip_netmask;  
5.     gp.adhandle = adhandle;  

接下来直接创建两个线程，一个是发送一个接受，分别调用两个方法。

[cpp]  view plain  copy

1. sendthread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SendArpPacket,  
2.             &sp, 0, NULL);  
3.     recvthread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) GetLivePC, &gp,  
4.             0, NULL);  
5.     printf("\nlistening on 网卡%d ...\n", i);  

那么发送数据包的方法和接收解析数据包的方法怎样实现呢？

发送数据包，发送数据包先对结构体数据进行赋值，就像getSelfMac方法一样，然后声明了一个buffer用来存储每一个字节内容。

利用memset方法对buffer进行赋值。再利用一个for循环对255个主机进行发送，指定他们的IP地址。另外定义了一个flag,当发送成功之后将flag设置为1

[cpp]  view plain  copy

1. /* 向局域网内所有可能的IP地址发送ARP请求包线程 */  
2. DWORD WINAPI SendArpPacket(LPVOID lpParameter) //(pcap_t *adhandle,char *ip,unsigned char *mac,char *netmask)  
3. {  
4.     sparam *spara = (sparam *) lpParameter;  
5.     pcap_t *adhandle = spara->adhandle;  
6.     char *ip = spara->ip;  
7.     unsigned char *mac = spara->mac;  
8.     char *netmask = spara->netmask;  
9.     printf("ip_mac:%02x-%02x-%02x-%02x-%02x-%02x\n", mac[0], mac[1], mac[2],  
10.             mac[3], mac[4], mac[5]);  
11.     printf("自身的IP地址为:%s\n", ip);  
12.     printf("地址掩码NETMASK为:%s\n", netmask);  
13.     printf("\n");  
14.     unsigned char sendbuf[42]; //arp包结构大小  
15.     EthernetHeader eh;  
16.     Arpheader ah;  
17.     //赋值MAC地址  
18.     memset(eh.DestMAC, 0xff, 6);       //目的地址为全为广播地址  
19.     memcpy(eh.SourMAC, mac, 6);  
20.     memcpy(ah.SourceMacAdd, mac, 6);  
21.     memset(ah.DestMacAdd, 0x00, 6);  
22.     eh.EthType = htons(ETH_ARP);  
23.     ah.HardwareType = htons(ARP_HARDWARE);  
24.     ah.ProtocolType = htons(ETH_IP);  
25.     ah.HardwareAddLen = 6;  
26.     ah.ProtocolAddLen = 4;  
27.     ah.SourceIpAdd = inet_addr(ip); //请求方的IP地址为自身的IP地址  
28.     ah.OperationField = htons(ARP_REQUEST);  
29.     //向局域网内广播发送arp包  
30.     unsigned long myip = inet_addr(ip);  
31.     unsigned long mynetmask = inet_addr(netmask);  
32.     unsigned long hisip = htonl((myip & mynetmask));  
33.     //向255个主机发送  
34.     for (int i = 0; i < HOSTNUM; i++) {  
35.         ah.DestIpAdd = htonl(hisip + i);  
36.         //构造一个ARP请求  
37.         memset(sendbuf, 0, sizeof(sendbuf));  
38.         memcpy(sendbuf, &eh, sizeof(eh));  
39.         memcpy(sendbuf + sizeof(eh), &ah, sizeof(ah));  
40.         //如果发送成功  
41.         if (pcap_sendpacket(adhandle, sendbuf, 42) == 0) {  
42.             //printf("\nPacketSend succeed\n");  
43.         } else {  
44.             printf("PacketSendPacket in getmine Error: %d\n", GetLastError());  
45.         }  
46.         Sleep(50);  
47.     }  
48.     Sleep(1000);  
49.     flag = TRUE;  
50.     return 0;  
51. }  

注: 此函数和flag变量在前面别忘了声明一下...

然后是接收数据包并打印MAC地址:

[cpp]  view plain  copy

1. /* 分析截留的数据包获取活动的主机IP地址 */  
2. DWORD WINAPI GetLivePC(LPVOID lpParameter) //(pcap_t *adhandle)  
3. {  
4.     gparam *gpara = (gparam *) lpParameter;  
5.     pcap_t *adhandle = gpara->adhandle;  
6.     int res;  
7.     unsigned char Mac[6];  
8.     struct pcap_pkthdr * pkt_header;  
9.     const u_char * pkt_data;  
10.     while (true) {  
11.         if (flag) {  
12.             printf("获取MAC地址完毕,请输入你要发送对方的IP地址:\n");  
13.             break;  
14.         }  
15.         if ((res = pcap_next_ex(adhandle, &pkt_header, &pkt_data)) >= 0) {  
16.             if (*(unsigned short *) (pkt_data + 12) == htons(ETH_ARP)) {  
17.                 ArpPacket *recv = (ArpPacket *) pkt_data;  
18.                 if (*(unsigned short *) (pkt_data + 20) == htons(ARP_REPLY)) {  
19.                     printf("-------------------------------------------\n");  
20.                     printf("IP地址:%d.%d.%d.%d   MAC地址:",  
21.                              recv->ah.SourceIpAdd & 255,  
22.                              recv->ah.SourceIpAdd >> 8 & 255,  
23.                              recv->ah.SourceIpAdd >> 16 & 255,  
24.                              recv->ah.SourceIpAdd >> 24 & 255);  
25.                     for (int i = 0; i < 6; i++) {  
26.                         Mac[i] = *(unsigned char *) (pkt_data + 22 + i);  
27.                         printf("%02x", Mac[i]);  
28.                     }  
29.                     printf("\n");  
30.                 }  
31.             }  
32.         }  
33.         Sleep(10);  
34.     }  
35.     return 0;  
36. }  

以上暂告一段落，通过整合以上代码，我们可以得到如下运行结果：

[plain]  view plain  copy

1. --------------------------------------------------  
2. number:1  
3. name:rpcap://\Device\NPF_{5AC72F8D-019C-4003-B51B-  
4. description:Network adapter 'Microsoft' on local h  
5.         Loopback: no  
6. Address Family Name:AF_INET6  
7. this is an IPV6 address  
8. Address Family Name:AF_INET6  
9. this is an IPV6 address  
10. --------------------------------------------------  
11. number:2  
12. name:rpcap://\Device\NPF_{C17EB3F6-1E86-40E5-8790-  
13. description:Network adapter 'Microsoft' on local h  
14.         Loopback: no  
15. Address Family Name:AF_INET6  
16. this is an IPV6 address  
17. Address Family Name:AF_INET  
18. Address:192.168.95.1  
19.         Netmask: 255.255.255.0  
20.         Broadcast Address: 255.255.255.255  
21. --------------------------------------------------  
22. number:3  
23. name:rpcap://\Device\NPF_{33E23A2F-F791-409B-8452-  
24. description:Network adapter 'Qualcomm Atheros Ar81  
25. oller' on local host  
26.         Loopback: no  
27. Address Family Name:AF_INET6  
28. this is an IPV6 address  
29. Address Family Name:AF_INET6  
30. this is an IPV6 address  
31. Address Family Name:AF_INET6  
32. this is an IPV6 address  
33. Address Family Name:AF_INET  
34. Address:121.250.216.237  
35.         Netmask: 255.255.255.0  
36.         Broadcast Address: 255.255.255.255  
37. --------------------------------------------------  
38. number:4  
39. name:rpcap://\Device\NPF_{DCCF036F-A9A8-4225-B980-  
40. description:Network adapter 'Microsoft' on local h  
41.         Loopback: no  
42. Address Family Name:AF_INET6  
43. this is an IPV6 address  
44. Address Family Name:AF_INET6  
45. this is an IPV6 address  
46. --------------------------------------------------  
47. number:5  
48. name:rpcap://\Device\NPF_{D62A0060-F424-46FC-83A5-  
49. description:Network adapter 'Microsoft' on local h  
50.         Loopback: no  
51. Address Family Name:AF_INET6  
52. this is an IPV6 address  
53. Address Family Name:AF_INET  
54. Address:192.168.191.1  
55.         Netmask: 255.255.255.0  
56.         Broadcast Address: 255.255.255.255  
57. --------------------------------------------------  
58. number:6  
59. name:rpcap://\Device\NPF_{B5224A53-8450-4537-AB3B-  
60. description:Network adapter 'Microsoft' on local h  
61.         Loopback: no  
62. Address Family Name:AF_INET6  
63. this is an IPV6 address  
64. Address Family Name:AF_INET  
65. Address:192.168.191.2  
66.         Netmask: 255.255.255.0  
67.         Broadcast Address: 255.255.255.255  
68. Enter the interface number(1-6):3  
69.   
70. ipstr:121.250.216.237  
71. netmask:255.255.255.0  
72.   
73. PacketSend succeed  
74. 获取自己主机的MAC地址成功!  
75.   
76. listening on 网卡2 ...  
77. ip_mac:dc-0e-a1-ec-53-c3  
78. 自身的IP地址为:121.250.216.237  
79. 地址掩码NETMASK为:255.255.255.0  
80.   
81. 请按任意键继续. . . ------------------------------  
82. IP地址:121.250.216.1   MAC地址:000fe28e6100  
83. -------------------------------------------  
84. IP地址:121.250.216.3   MAC地址:089e012d20d5  
85. -------------------------------------------  
86. IP地址:121.250.216.5   MAC地址:5404a6af5f2d  
87. -------------------------------------------  
88. IP地址:121.250.216.6   MAC地址:28d244248d81  
89. -------------------------------------------  
90. IP地址:121.250.216.7   MAC地址:80fa5b0283f3  
91. -------------------------------------------  
92. IP地址:121.250.216.8   MAC地址:14dae9005b9e  
93. -------------------------------------------  
94. IP地址:121.250.216.9   MAC地址:b82a72bf8bce  
95. -------------------------------------------  
96. IP地址:121.250.216.12   MAC地址:84c9b2fefeed  
97. -------------------------------------------  
98. IP地址:121.250.216.15   MAC地址:28d2440b4b1b  
99. -------------------------------------------  
100. IP地址:121.250.216.16   MAC地址:bcee7b969beb  
101. -------------------------------------------  
102. ........此处省略一万字....  

接下来我们让用户输入要发送的IP地址和要发送的数据

[cpp]  view plain  copy

1. u_int ip1,ip2,ip3,ip4;  
2.         scanf_s("%d.%d.%d.%d",&ip1,&ip2,&ip3,&ip4);  
3.         printf("请输入你要发送的内容:\n");  
4.         getchar();  
5.         gets_s(TcpData);  
6.         printf("要发送的内容:%s\n",TcpData);  

声明一下TcpData

[cpp]  view plain  copy

1. char TcpData[20];   //发送内容  

接下来就是重头戏了，需要声明各种结构体，我们发送的是TCP数据，这样，TCP的TcpData 就作为真正的内容，然后在前面加上TCP头，IP头，帧头，还有校验和要正确。

最后构成一个完整的帧，那么另外声明的结构体如下，前面代码声明过的帧头部结构体就去掉了。

[cpp]  view plain  copy

1. //IP地址格式  
2. struct IpAddress  
3. {  
4.     u_char byte1;  
5.     u_char byte2;  
6.     u_char byte3;  
7.     u_char byte4;  
8. };  
9.   
10. //帧头部结构体，共14字节  
11. struct EthernetHeader  
12. {  
13.     u_char DestMAC[6];    //目的MAC地址 6字节  
14.     u_char SourMAC[6];   //源MAC地址 6字节  
15.     u_short EthType;         //上一层协议类型，如0x0800代表上一层是IP协议，0x0806为arp  2字节  
16. };  
17.   
18. //IP头部结构体，共20字节  
19. struct IpHeader  
20. {  
21.     unsigned char Version_HLen;   //版本信息4位 ，头长度4位 1字节  
22.     unsigned char TOS;                    //服务类型    1字节  
23.     short Length;                              //数据包长度 2字节  
24.     short Ident;                                 //数据包标识  2字节  
25.     short Flags_Offset;                    //标志3位，片偏移13位  2字节  
26.     unsigned char TTL;                   //存活时间  1字节  
27.     unsigned char Protocol;          //协议类型  1字节  
28.     short Checksum;                       //首部校验和 2字节  
29.     IpAddress SourceAddr;       //源IP地址   4字节  
30.     IpAddress DestinationAddr; //目的IP地址  4字节  
31. };  
32.   
33. //TCP头部结构体，共20字节  
34. struct TcpHeader  
35. {  
36.     unsigned short SrcPort;                        //源端口号  2字节  
37.     unsigned short DstPort;                        //目的端口号 2字节  
38.     unsigned int SequenceNum;               //序号  4字节  
39.     unsigned int Acknowledgment;         //确认号  4字节  
40.     unsigned char HdrLen;                         //首部长度4位，保留位6位 共10位  
41.     unsigned char Flags;                              //标志位6位  
42.     unsigned short AdvertisedWindow;  //窗口大小16位 2字节  
43.     unsigned short Checksum;                  //校验和16位   2字节  
44.     unsigned short UrgPtr;                        //紧急指针16位   2字节  
45. };  
46.   
47. //TCP伪首部结构体 12字节  
48. struct PsdTcpHeader  
49. {  
50.     IpAddress SourceAddr;                     //源IP地址  4字节  
51.     IpAddress DestinationAddr;             //目的IP地址 4字节  
52.     char Zero;                                                    //填充位  1字节  
53.     char Protcol;                                               //协议号  1字节  
54.     unsigned short TcpLen;                           //TCP包长度 2字节  
55. };  

继续main函数中对各种结构体的数据进行初始化赋值，并计算校验和。

[cpp]  view plain  copy

1. //结构体初始化为0序列  
2.         memset(&ethernet, 0, sizeof(ethernet));  
3.         BYTE destmac[8];  
4.         //目的MAC地址,此处没有对帧的MAC地址进行赋值，因为网卡设置的混杂模式，可以接受经过该网卡的所有帧。当然最好的方法是赋值为ARP刚才获取到的MAC地址，当然不赋值也可以捕捉到并解析，在此处仅做下说明。  
5.         destmac[0] = 0x00;  
6.         destmac[1] = 0x11;  
7.         destmac[2] = 0x22;  
8.         destmac[3] = 0x33;  
9.         destmac[4] = 0x44;  
10.         destmac[5] = 0x55;  
11.         //赋值目的MAC地址  
12.         memcpy(ethernet.DestMAC, destmac, 6);  
13.         BYTE hostmac[8];  
14.         //源MAC地址  
15.         hostmac[0] = 0x00;  
16.         hostmac[1] = 0x1a;  
17.         hostmac[2] = 0x4d;  
18.         hostmac[3] = 0x70;  
19.         hostmac[4] = 0xa3;  
20.         hostmac[5] = 0x89;  
21.         //赋值源MAC地址  
22.         memcpy(ethernet.SourMAC, hostmac, 6);  
23.         //上层协议类型,0x0800代表IP协议  
24.         ethernet.EthType = htons(0x0800);  
25.         //赋值SendBuffer  
26.         memcpy(&SendBuffer, ðernet, sizeof(struct EthernetHeader));  
27.         //赋值IP头部信息  
28.         ip.Version_HLen = 0x45;  
29.         ip.TOS = 0;  
30.         ip.Length = htons(sizeof(struct IpHeader) + sizeof(struct TcpHeader) + strlen(TcpData));  
31.         ip.Ident = htons(1);  
32.         ip.Flags_Offset = 0;  
33.         ip.TTL = 128;  
34.         ip.Protocol = 6;  
35.         ip.Checksum = 0;  
36.         //源IP地址  
37.         ip.SourceAddr.byte1 = 127;  
38.         ip.SourceAddr.byte2 = 0;  
39.         ip.SourceAddr.byte3 = 0;  
40.         ip.SourceAddr.byte4 = 1;  
41.         //目的IP地址  
42.         ip.DestinationAddr.byte1 = ip1;  
43.         ip.DestinationAddr.byte2 = ip2;  
44.         ip.DestinationAddr.byte3 = ip3;  
45.         ip.DestinationAddr.byte4 = ip4;  
46.         //赋值SendBuffer  
47.         memcpy(&SendBuffer[sizeof(struct EthernetHeader)], &ip, 20);  
48.         //赋值TCP头部内容  
49.         tcp.DstPort = htons(102);  
50.         tcp.SrcPort = htons(1000);  
51.         tcp.SequenceNum = htonl(11);  
52.         tcp.Acknowledgment = 0;  
53.         tcp.HdrLen = 0x50;  
54.         tcp.Flags = 0x18;  
55.         tcp.AdvertisedWindow = htons(512);  
56.         tcp.UrgPtr = 0;  
57.         tcp.Checksum = 0;  
58.         //赋值SendBuffer  
59.         memcpy(&SendBuffer[sizeof(struct EthernetHeader) + 20], &tcp, 20);  
60.         //赋值伪首部  
61.         ptcp.SourceAddr = ip.SourceAddr;  
62.         ptcp.DestinationAddr = ip.DestinationAddr;  
63.         ptcp.Zero = 0;  
64.         ptcp.Protcol = 6;  
65.         ptcp.TcpLen = htons(sizeof(struct TcpHeader) + strlen(TcpData));  
66.         //声明临时存储变量，用来计算校验和  
67.         char TempBuffer[65535];  
68.         memcpy(TempBuffer, &ptcp, sizeof(struct PsdTcpHeader));  
69.         memcpy(TempBuffer + sizeof(struct PsdTcpHeader), &tcp, sizeof(struct TcpHeader));  
70.         memcpy(TempBuffer + sizeof(struct PsdTcpHeader) + sizeof(struct TcpHeader), TcpData, strlen(TcpData));  
71.         //计算TCP的校验和  
72.         tcp.Checksum = checksum((USHORT*)(TempBuffer), sizeof(struct PsdTcpHeader) + sizeof(struct TcpHeader) + strlen(TcpData));  
73.         //重新把SendBuffer赋值，因为此时校验和已经改变，赋值新的  
74.         memcpy(SendBuffer + sizeof(struct EthernetHeader) + sizeof(struct IpHeader), &tcp, sizeof(struct TcpHeader));  
75.         memcpy(SendBuffer + sizeof(struct EthernetHeader) + sizeof(struct IpHeader) + sizeof(struct TcpHeader), TcpData, strlen(TcpData));  
76.         //初始化TempBuffer为0序列，存储变量来计算IP校验和  
77.         memset(TempBuffer, 0, sizeof(TempBuffer));  
78.         memcpy(TempBuffer, &ip, sizeof(struct IpHeader));  
79.         //计算IP校验和  
80.         ip.Checksum = checksum((USHORT*)(TempBuffer), sizeof(struct IpHeader));  
81.         //重新把SendBuffer赋值，IP校验和已经改变  
82.         memcpy(SendBuffer + sizeof(struct EthernetHeader), &ip, sizeof(struct IpHeader));  
83.         //发送序列的长度  
84.         int size = sizeof(struct EthernetHeader) + sizeof(struct IpHeader) + sizeof(struct TcpHeader) + strlen(TcpData);  
85.         int result = pcap_sendpacket(adhandle, SendBuffer,size);  
86.         if (result != 0)  
87.         {  
88.             printf("Send Error!\n");  
89.         }   
90.         else  
91.         {  
92.             printf("Send TCP Packet.\n");  
93.             printf("Dstination Port:%d\n", ntohs(tcp.DstPort));  
94.             printf("Source Port:%d\n", ntohs(tcp.SrcPort));  
95.             printf("Sequence:%d\n", ntohl(tcp.SequenceNum));  
96.             printf("Acknowledgment:%d\n", ntohl(tcp.Acknowledgment));  
97.             printf("Header Length:%d*4\n", tcp.HdrLen >> 4);  
98.             printf("Flags:0x%0x\n", tcp.Flags);  
99.             printf("AdvertiseWindow:%d\n", ntohs(tcp.AdvertisedWindow));  
100.             printf("UrgPtr:%d\n", ntohs(tcp.UrgPtr));  
101.             printf("Checksum:%u\n", ntohs(tcp.Checksum));  
102.             printf("Send Successfully!\n");  
103.         }  

校验和方法如下：

[cpp]  view plain  copy

1. //获得校验和的方法  
2. unsigned short checksum(unsigned short *data, int length)  
3. {  
4.     unsigned long temp = 0;  
5.     while (length > 1)  
6.     {  
7.         temp +=  *data++;  
8.         length -= sizeof(unsigned short);  
9.     }  
10.     if (length)  
11.     {  
12.         temp += *(unsigned short*)data;  
13.     }  
14.     temp = (temp >> 16) + (temp &0xffff);  
15.     temp += (temp >> 16);  
16.     return (unsigned short)(~temp);  
17. }  

记得在声明一下这个方法。如果放在main函数前当然就不用声明啦。

另外需要声明的变量有

[cpp]  view plain  copy

1. struct EthernetHeader ethernet;    //以太网帧头  
2.  struct IpHeader ip;                            //IP头  
3.  struct TcpHeader tcp;                      //TCP头  
4.  struct PsdTcpHeader ptcp;             //TCP伪首部  

[plain]  view plain  copy

1. unsigned char SendBuffer[200];       //发送队列  

接下来的运行结果：

[plain]  view plain  copy

1. 获取MAC地址完毕,请输  
2. 121.250.216.112  
3. 请输入你要发送的内容  
4. what is tcp  
5. 要发送的内容:what i  
6. Send TCP Packet.  
7. Dstination Port:102  
8. Source Port:1000  
9. Sequence:11  
10. Acknowledgment:0  
11. Header Length:5*4  
12. Flags:0x18  
13. AdvertiseWindow:512  
14. UrgPtr:0  
15. Checksum:17149  
16. Send Successfully!  

截图如下：

好啦，发送帧到此就告一段落啦！如果有疑问请留言。

帧的接收很简单，直接贴源码如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <pcap.h>  
4.   
5.   
6. char *iptos(u_long in);       //u_long即为 unsigned long  
7. void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);  
8. //struct tm *ltime;                 //和时间处理有关的变量  
9.   
10. struct IpAddress  
11. {  
12.     u_char byte1;  
13.     u_char byte2;  
14.     u_char byte3;  
15.     u_char byte4;  
16. };  
17.   
18. //帧头部结构体，共14字节  
19. struct EthernetHeader  
20. {  
21.     u_char DestMAC[6];    //目的MAC地址 6字节  
22.     u_char SourMAC[6];   //源MAC地址 6字节  
23.     u_short EthType;         //上一层协议类型，如0x0800代表上一层是IP协议，0x0806为arp  2字节  
24. };  
25.   
26. //IP头部结构体，共20字节  
27. struct IpHeader  
28. {  
29.     unsigned char Version_HLen;   //版本信息4位 ，头长度4位 1字节  
30.     unsigned char TOS;                    //服务类型    1字节  
31.     short Length;                              //数据包长度 2字节  
32.     short Ident;                                 //数据包标识  2字节  
33.     short Flags_Offset;                    //标志3位，片偏移13位  2字节  
34.     unsigned char TTL;                    //存活时间  1字节  
35.     unsigned char Protocol;           //协议类型  1字节  
36.     short Checksum;                        //首部校验和 2字节  
37.     IpAddress SourceAddr;           //源IP地址   4字节  
38.     IpAddress DestinationAddr;   //目的IP地址  4字节  
39. };  
40.   
41. //TCP头部结构体，共20字节  
42. struct TcpHeader  
43. {  
44.     unsigned short SrcPort;                        //源端口号  2字节  
45.     unsigned short DstPort;                        //目的端口号 2字节  
46.     unsigned int SequenceNum;               //序号  4字节  
47.     unsigned int Acknowledgment;         //确认号  4字节  
48.     unsigned char HdrLen;                         //首部长度4位，保留位6位 共10位  
49.     unsigned char Flags;                              //标志位6位  
50.     unsigned short AdvertisedWindow;  //窗口大小16位 2字节  
51.     unsigned short Checksum;                  //校验和16位   2字节  
52.     unsigned short UrgPtr;                        //紧急指针16位   2字节  
53. };  
54.   
55. //TCP伪首部结构体 12字节  
56. struct PsdTcpHeader  
57. {  
58.     unsigned long SourceAddr;                     //源IP地址  4字节  
59.     unsigned long DestinationAddr;             //目的IP地址 4字节  
60.     char Zero;                                                    //填充位  1字节  
61.     char Protcol;                                               //协议号  1字节  
62.     unsigned short TcpLen;                           //TCP包长度 2字节  
63. };  
64.   
65.   
66. int main(){  
67.   
68.     EthernetHeader *ethernet;    //以太网帧头  
69.     IpHeader *ip;                            //IP头  
70.     TcpHeader *tcp;                      //TCP头  
71.     PsdTcpHeader *ptcp;             //TCP伪首部  
72.   
73.     pcap_if_t  * alldevs;       //所有网络适配器  
74.     pcap_if_t  *d;                  //选中的网络适配器  
75.     char errbuf[PCAP_ERRBUF_SIZE];   //错误缓冲区,大小为256  
76.     char source[PCAP_ERRBUF_SIZE];  
77.     pcap_t *adhandle;           //捕捉实例,是pcap_open返回的对象  
78.     int i = 0;                            //适配器计数变量  
79.     struct pcap_pkthdr *header;    //接收到的数据包的头部  
80.     const u_char *pkt_data;           //接收到的数据包的内容  
81.     int res;                                    //表示是否接收到了数据包  
82.     u_int netmask;                       //过滤时用的子网掩码  
83.     char packet_filter[] = "tcp";        //过滤字符  
84.     struct bpf_program fcode;                     //pcap_compile所调用的结构体  
85.   
86.     u_int ip_len;                                       //ip地址有效长度  
87.     u_short sport,dport;                        //主机字节序列  
88.     u_char packet[100];                       //发送数据包目的地址  
89.     pcap_dumper_t *dumpfile;         //堆文件  
90.   
91.     //time_t local_tv_sec;              //和时间处理有关的变量  
92.     //char timestr[16];                 //和时间处理有关的变量  
93.   
94.       
95.     //获取本地适配器列表  
96.     if(pcap_findalldevs_ex(PCAP_SRC_IF_STRING,NULL,&alldevs,errbuf) == -1){  
97.         //结果为-1代表出现获取适配器列表失败  
98.         fprintf(stderr,"Error in pcap_findalldevs_ex:\n",errbuf);  
99.         //exit(0)代表正常退出,exit(other)为非正常退出,这个值会传给操作系统  
100.         exit(1);  
101.     }  
102.     //打印设备列表信息  
103.     for(d = alldevs;d !=NULL;d = d->next){  
104.         printf("-----------------------------------------------------------------\nnumber:%d\nname:%s\n",++i,d->name);  
105.         if(d->description){  
106.             //打印适配器的描述信息  
107.             printf("description:%s\n",d->description);  
108.         }else{  
109.             //适配器不存在描述信息  
110.             printf("description:%s","no description\n");  
111.         }  
112.         //打印本地环回地址  
113.         printf("\tLoopback: %s\n",(d->flags & PCAP_IF_LOOPBACK)?"yes":"no");  
114.           
115.          pcap_addr_t *a;       //网络适配器的地址用来存储变量  
116.          for(a = d->addresses;a;a = a->next){  
117.              //sa_family代表了地址的类型,是IPV4地址类型还是IPV6地址类型  
118.              switch (a->addr->sa_family)  
119.              {  
120.                  case AF_INET:  //代表IPV4类型地址  
121.                      printf("Address Family Name:AF_INET\n");  
122.                      if(a->addr){  
123.                          //->的优先级等同于括号,高于强制类型转换,因为addr为sockaddr类型，对其进行操作须转换为sockaddr_in类型  
124.                          printf("Address:%s\n",iptos(((struct sockaddr_in *)a->addr)->sin_addr.s_addr));  
125.                      }  
126.                     if (a->netmask){  
127.                          printf("\tNetmask: %s\n",iptos(((struct sockaddr_in *)a->netmask)->sin_addr.s_addr));  
128.                     }  
129.                     if (a->broadaddr){  
130.                            printf("\tBroadcast Address: %s\n",iptos(((struct sockaddr_in *)a->broadaddr)->sin_addr.s_addr));  
131.                      }  
132.                      if (a->dstaddr){  
133.                            printf("\tDestination Address: %s\n",iptos(((struct sockaddr_in *)a->dstaddr)->sin_addr.s_addr));  
134.                      }  
135.                      break;  
136.                  case AF_INET6: //代表IPV6类型地址  
137.                      printf("Address Family Name:AF_INET6\n");  
138.                      printf("this is an IPV6 address\n");  
139.                      break;  
140.                  default:  
141.                      break;  
142.              }  
143.          }  
144.     }  
145.     //i为0代表上述循环未进入,即没有找到适配器,可能的原因为Winpcap没有安装导致未扫描到  
146.     if(i == 0){  
147.         printf("interface not found,please check winpcap installation");  
148.     }  
149.   
150.     int num;  
151.     printf("Enter the interface number(1-%d):",i);  
152.     //让用户选择选择哪个适配器进行抓包  
153.     scanf_s("%d",&num);  
154.     printf("\n");  
155.   
156.     //用户输入的数字超出合理范围  
157.     if(num<1||num>i){  
158.         printf("number out of range\n");  
159.         pcap_freealldevs(alldevs);  
160.         return -1;  
161.     }  
162.     //跳转到选中的适配器  
163.     for(d=alldevs, i=0; i< num-1 ; d=d->next, i++);  
164.   
165.     //运行到此处说明用户的输入是合法的  
166.     if((adhandle = pcap_open(d->name,        //设备名称  
167.                                                         65535,       //存放数据包的内容长度  
168.                                                         PCAP_OPENFLAG_PROMISCUOUS,  //混杂模式  
169.                                                         1000,           //超时时间  
170.                                                         NULL,          //远程验证  
171.                                                         errbuf         //错误缓冲  
172.                                                         )) == NULL){  
173.         //打开适配器失败,打印错误并释放适配器列表  
174.         fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);  
175.         // 释放设备列表   
176.         pcap_freealldevs(alldevs);  
177.         return -1;  
178.     }  
179.       
180.   
181.     //打印输出,正在监听中  
182.     printf("\nlistening on %s...\n", d->description);  
183.   
184.     //所在网络不是以太网,此处只取这种情况  
185.     if(pcap_datalink(adhandle) != DLT_EN10MB)  
186.     {  
187.         fprintf(stderr,"\nThis program works only on Ethernet networks.\n");  
188.         //释放列表  
189.         pcap_freealldevs(alldevs);  
190.         return -1;  
191.     }  
192.   
193.     //先获得地址的子网掩码  
194.     if(d->addresses != NULL)  
195.         //获得接口第一个地址的掩码   
196.         netmask=((struct sockaddr_in *)(d->addresses->netmask))->sin_addr.S_un.S_addr;  
197.     else  
198.         // 如果接口没有地址，那么我们假设一个C类的掩码  
199.         netmask=0xffffff;  
200.   
201.     //pcap_compile()的原理是将高层的布尔过滤表  
202.     //达式编译成能够被过滤引擎所解释的低层的字节码  
203.     if(pcap_compile(adhandle,   //适配器处理对象  
204.                                         &fcode,  
205.                                         packet_filter,   //过滤ip和UDP  
206.                                         1,                       //优化标志  
207.                                         netmask           //子网掩码  
208.                                         )<0)  
209.     {  
210.         //过滤出现问题  
211.         fprintf(stderr,"\nUnable to compile the packet filter. Check the syntax.\n");  
212.         // 释放设备列表  
213.         pcap_freealldevs(alldevs);  
214.         return -1;  
215.     }  
216.   
217.     //设置过滤器  
218.     if (pcap_setfilter(adhandle, &fcode)<0)  
219.     {  
220.         fprintf(stderr,"\nError setting the filter.\n");  
221.         //释放设备列表  
222.         pcap_freealldevs(alldevs);  
223.         return -1;  
224.     }  
225.   
226.   
227.     //利用pcap_next_ex来接受数据包  
228.     while((res = pcap_next_ex(adhandle,&header,&pkt_data))>=0)  
229.     {  
230.         if(res ==0){  
231.             //返回值为0代表接受数据包超时，重新循环继续接收  
232.             continue;  
233.         }else{  
234.             //运行到此处代表接受到正常从数据包  
235.             //header为帧的头部  
236.             printf("%.6ld len:%d ", header->ts.tv_usec, header->len);  
237.             // 获得IP数据包头部的位置  
238.             ip = (IpHeader *) (pkt_data +14);    //14为以太网帧头部长度  
239.             //获得TCP头部的位置  
240.             ip_len = (ip->Version_HLen & 0xf) *4;  
241.             printf("ip_length:%d ",ip_len);  
242.             tcp = (TcpHeader *)((u_char *)ip+ip_len);  
243.             char * data;  
244.              data = (char *)((u_char *)tcp+20);  
245.              //将网络字节序列转换成主机字节序列  
246.             sport = ntohs( tcp->SrcPort );  
247.             dport = ntohs( tcp->DstPort );  
248.             printf("srcport:%d desport:%d\n",sport,dport);  
249.             printf("%d.%d.%d.%d.%d -> %d.%d.%d.%d.%d\n",  
250.                     ip->SourceAddr.byte1,  
251.                     ip->SourceAddr.byte2,  
252.                     ip->SourceAddr.byte3,  
253.                     ip->SourceAddr.byte4,  
254.                     sport,  
255.                     ip->DestinationAddr.byte1,  
256.                     ip->DestinationAddr.byte2,  
257.                     ip->DestinationAddr.byte3,  
258.                     ip->DestinationAddr.byte4,  
259.                     dport);  
260.             printf("%s\n",data);  
261.         }  
262.   
263.     }  
264.   
265.       
266.     //释放网络适配器列表  
267.     pcap_freealldevs(alldevs);  
268.   
269.     /** 
270.     int pcap_loop  ( pcap_t *  p,   
271.                                   int  cnt,   
272.                                   pcap_handler  callback,   
273.                                   u_char *  user    
274.                                  ); 
275.      typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *, 
276.                  const u_char *); 
277.     */  
278.     //开始捕获信息,当捕获到数据包时,会自动调用这个函数  
279.     //pcap_loop(adhandle,0,packet_handler,NULL);  
280.   
281.     int inum;  
282.     scanf_s("%d", &inum);  
283.   
284.     return 0;  
285.   
286. }  
287.   
288. /* 每次捕获到数据包时，libpcap都会自动调用这个回调函数 */  
289. /** 
290. pcap_loop()函数是基于回调的原理来进行数据捕获的，如技术文档所说，这是一种精妙的方法，并且在某些场合下， 
291. 它是一种很好的选择。但是在处理回调有时候会并不实用，它会增加程序的复杂度，特别是在多线程的C++程序中 
292. */  
293. /* 
294. void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data) 
295. { 
296.     struct tm *ltime = NULL; 
297.     char timestr[16]; 
298.     time_t local_tv_sec; 
299.  
300.     // 将时间戳转换成可识别的格式 
301.     local_tv_sec = header->ts.tv_sec; 
302.     localtime_s(ltime,&local_tv_sec); 
303.     strftime( timestr, sizeof timestr, "%H:%M:%S", ltime); 
304.  
305.     printf("%s,%.6ld len:%d\n", timestr, header->ts.tv_usec, header->len); 
306.  
307. } 
308. */  
309. /* 将数字类型的IP地址转换成字符串类型的 */  
310. #define IPTOSBUFFERS    12  
311. char *iptos(u_long in)  
312. {  
313.     static char output[IPTOSBUFFERS][3*4+3+1];  
314.     static short which;  
315.     u_char *p;  
316.   
317.     p = (u_char *)&in;  
318.     which = (which + 1 == IPTOSBUFFERS ? 0 : which + 1);  
319.     sprintf_s(output[which], "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);  
320.     return output[which];  
321. }  

运行截图如下

Thank You

如有问题，欢迎留言~