libpcap紧张的浸染
捕获各种数据包，列如：网络流量统计。过滤网络数据包，列如：过滤掉本地上的一些数据，类似防火墙。剖析网络数据包，列如：剖析网络协议，数据的采集。存储网络数据包，列如：保存捕获的数据以为将来进行剖析。libpcap 的安装
libpcap 的抓包框架
利用 libpcap 函数库开拓运用程序的基本步骤：
打开网络设备设置过滤规则捕获数据关闭网络设备抓包详细步骤
首先要利用 libpcap，我们必须包含 pcap.h 头文件，可以在 /usr/local/include/pcap/pcap.h 找到，个中包含了每个类型定义的详细解释。
1、获取网络接口设备名
char pcap_lookupdev(char errbuf);
功能：
得到可用的网络设备名指针
参数：
errbuf：存放出错信息字符串，里面有个宏定义：PCAP_ERRBUF_SIZE，为缺点缓冲区大小
返回值：
成功返回设备名指针（第一个得当的网络接口的字符串指针）；
失落败返回 NULL，同时，errbuf 存放出错信息字符串。
实例如下：
char error_content[PCAP_ERRBUF_SIZE] = {0};// 出错信息char dev = pcap_lookupdev(error_content);if(NULL == dev){printf(error_content);exit(-1);}
2、获取网络号（ip 地址）和掩码
int pcap_lookupnet( char device, bpf_u_int32 netp,bpf_u_int32 maskp, char errbuf );
功能：
获取指定网卡的 ip 地址，子网掩码
参数：
device：网络设备名，为第一步获取的网络接口字符串（pcap_lookupdev() 的返回值 ），也可人为指定，如“eth0”。
netp：存放 ip 地址的指针，bpf_u_int32 为 32 位无符号整型
maskp：存放子网掩码的指针，bpf_u_int32 为 32 位无符号整型
errbuf：存放出错信息
返回值：
成功返回 0，失落败返回 -1
须要C/C++ Linux做事器架构师学习资料私信“资料”（资料包括C/C++，Linux，golang技能，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享
实例如下：
char error_content[PCAP_ERRBUF_SIZE] = {0};// 出错信息char dev = pcap_lookupdev(error_content);if(NULL == dev){printf(error_content);exit(-1);} bpf_u_int32 netp = 0, maskp = 0;pcap_t pcap_handle = NULL;int ret = 0; //得到网络号和掩码ret = pcap_lookupnet(dev, &netp, &maskp, error_content);if(ret == -1){printf(error_content);exit(-1);}
3、打开网络接口
pcap_t pcap_open_live( const char device,int snaplen,int promisc,int to_ms,char ebuf );
功能：
打开一个用于捕获数据的网络接口
参数：
device：网络接口的名字，为第一步获取的网络接口字符串（pcap_lookupdev() 的返回值 ），也可人为指定，如“eth0”。
snaplen：捕获数据包的长度，长度不能大于 65535 个字节。
promise：“1” 代表殽杂模式，其它非殽杂模式。什么为殽杂模式，请看《原始套接字编程》。
to_ms：指定须要等待的毫秒数，超过这个数值后，获取数据包的函数就会立即返回（这个函数不会壅塞，后面的抓包函数才会壅塞）。0 表示一贯等待直到有数据包到来。
ebuf：存储缺点信息。
返回值：
返回 pcap_t 类型指针，后面的所有操作都要利用这个指针。
实例如下：
char error_content[PCAP_ERRBUF_SIZE] = {0};// 出错信息char dev = pcap_lookupdev(error_content);// 获取网络接口if(NULL == dev){printf(error_content);exit(-1);} // 打开网络接口pcap_t pcap_handle = pcap_open_live(dev, 1024, 1, 0, error_content);if(NULL == pcap_handle){printf(error_content);exit(-1);}
4、获取数据包
a）
const u_char pcap_next(pcap_t p, struct pcap_pkthdr h);
功能：
捕获一个网络数据包，收到一个数据包立即返回
参数：
p：pcap_open_live()返回的 pcap_t 类型的指针
h：数据包头
pcap_pkthdr 类型的定义如下：
struct pcap_pkthdr{struct timeval ts; // 抓到包的韶光bpf_u_int32 caplen; // 表示抓到的数据长度bpf_u_int32 len; // 表示数据包的实际长度}
len 和 caplen的差异：
由于在某些情形下你不能担保捕获的包是完全的，例如一个包长 1480，但是你捕获到 1000 的时候，可能由于某些缘故原由就中止捕获了，以是 caplen 是记录实际捕获的包长，也便是 1000，而 len 便是 1480。
返回值：
成功返回捕获数据包的地址，失落败返回 NULL
实例如下：
const unsigned char p_packet_content = NULL; // 保存吸收到的数据包的起始地址pcap_t pcap_handle = NULL;struct pcap_pkthdr protocol_header; pcap_handle = pcap_open_live("eth0", 1024, 1, 0,NULL); p_packet_content = pcap_next(pcap_handle, &protocol_header); //p_packet_content 所捕获数据包的地址printf("Capture Time is :%s",ctime((const time_t )&protocol_header.ts.tv_sec)); // 韶光printf("Packet Lenght is :%d\n",protocol_header.len);// 数据包的实际长度 // 剖析以太网中的 源mac、目的macstruct ether_header ethernet_protocol = NULL;unsigned char p_mac_string = NULL;// 保存mac的地址，临时变量 ethernet_protocol = (struct ether_header )p_packet_content; //struct ether_header 以太网帧头部 p_mac_string = (unsigned char )ethernet_protocol->ether_shost;//获取源macprintf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(p_mac_string+0),(p_mac_string+1),(p_mac_string+2),(p_mac_string+3),(p_mac_string+4),(p_mac_string+5)); p_mac_string = (unsigned char )ethernet_protocol->ether_dhost;//获取目的macprintf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(p_mac_string+0),(p_mac_string+1),(p_mac_string+2),(p_mac_string+3),(p_mac_string+4),(p_mac_string+5));
b）
int pcap_loop( pcap_t p,
int cnt,
pcap_handler callback,
u_char user );
功能：
循环捕获网络数据包，直到碰着缺点或者知足退出条件。每次捕获一个数据包就会调用 callback 指定的回调函数，以是，可以在回调函数中进行数据包的处理操作。
参数：
p：pcap_open_live()返回的 pcap_t 类型的指针。
cnt：指定捕获数据包的个数，一旦抓到了 cnt 个数据包，pcap_loop 立即返回。如果是 -1，就会永无休止的捕获，直到涌现缺点。
callback：回调函数，名字任意，根据须要自行起名。
user：向回调函数中通报的参数。
callback 回调函数的定义：
void callback( u_char userarg,
const struct pcap_pkthdr pkthdr,
const u_char packet )
userarg：pcap_loop() 的末了一个参数，当收到足足数目标包后 pcap_loop 会调用callback 回调函数，同时将pcap_loop()的user参数通报给它
pkthdr：是收到数据包的 pcap_pkthdr 类型的指针，和 pcap_next() 第二个参数是一样的。
packet ：收到的数据包数据
返回值：
成功返回0，失落败返回负数
实例如下：
if( pcap_loop(pcap_handle, -1, ethernet_protocol_callback, NULL) < 0 ){perror("pcap_loop");} /回调函数/void ethernet_protocol_callback(unsigned char argument,const struct pcap_pkthdr packet_heaher,const unsigned char packet_content){unsigned char mac_string;//struct ether_header ethernet_protocol;unsigned short ethernet_type;//以太网类型printf("----------------------------------------------------\n");printf("%s\n", ctime((time_t )&(packet_heaher->ts.tv_sec))); //转换韶光ethernet_protocol = (struct ether_header )packet_content;mac_string = (unsigned char )ethernet_protocol->ether_shost;//获取源mac地址printf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(mac_string+0),(mac_string+1),(mac_string+2),(mac_string+3),(mac_string+4),(mac_string+5));mac_string = (unsigned char )ethernet_protocol->ether_dhost;//获取目的macprintf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(mac_string+0),(mac_string+1),(mac_string+2),(mac_string+3),(mac_string+4),(mac_string+5));ethernet_type = ntohs(ethernet_protocol->ether_type);//得到以太网的类型printf("Ethernet type is :%04x\n",ethernet_type);switch(ethernet_type){case 0x0800:printf("The network layer is IP protocol\n");break;//ipcase 0x0806:printf("The network layer is ARP protocol\n");break;//arpcase 0x0835:printf("The network layer is RARP protocol\n");break;//rarpdefault:break;}usleep(8001000);}
c）
int pcap_dispatch(pcap_t p, int cnt, pcap_handler callback, u_char user);
这个函数和 pcap_loop() 非常类似，只是在超过 to_ms 毫秒后就会返回( to_ms 是pcap_open_live() 的第4个参数 )
5、开释网络接口
void pcap_close(pcap_t p);
功能：
关闭 pcap_open_live() 打开的网络接口（即其返回值，pcap_t 类型指针），并开释干系资源。把稳，操作完网络接口，该当开释其资源。
参数：
p：须要关闭的网络接口，pcap_open_live() 的返回值（pcap_t 类型指针）
返回值：
无
实例如下：
// 打开网络接口pcap_t pcap_handle = pcap_open_live("eth0", 1024, 1, 0, error_content);if(NULL == pcap_handle){printf(error_content);exit(-1);} //// ……//// ……
pcap_close(pcap_handle); //开释网络接口
例子1（吸收一个数据包）：
#include <stdio.h>#include <pcap.h>#include <arpa/inet.h>#include <time.h>#include <stdlib.h>struct ether_header{unsigned char ether_dhost[6];//目的macunsigned char ether_shost[6];//源macunsigned short ether_type;//以太网类型};#define BUFSIZE 1514 int main(int argc,char argv[]){pcap_t pcap_handle = NULL;char error_content[100] = "";// 出错信息const unsigned char p_packet_content = NULL;// 保存吸收到的数据包的起始地址unsigned char p_mac_string = NULL;// 保存mac的地址，临时变量unsigned short ethernet_type = 0;// 以太网类型char p_net_interface_name = NULL;// 接口名字struct pcap_pkthdr protocol_header;struct ether_header ethernet_protocol; //得到接口名p_net_interface_name = pcap_lookupdev(error_content);if(NULL == p_net_interface_name){perror("pcap_lookupdev");exit(-1);}//打开网络接口pcap_handle = pcap_open_live(p_net_interface_name,BUFSIZE,1,0,error_content);p_packet_content = pcap_next(pcap_handle,&protocol_header);printf("------------------------------------------------------------------------\n");printf("capture a Packet from p_net_interface_name :%s\n",p_net_interface_name);printf("Capture Time is :%s",ctime((const time_t )&protocol_header.ts.tv_sec));printf("Packet Lenght is :%d\n",protocol_header.len);/剖析以太网中的 源mac、目的mac/ethernet_protocol = (struct ether_header )p_packet_content;p_mac_string = (unsigned char )ethernet_protocol->ether_shost;//获取源macprintf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(p_mac_string+0),(p_mac_string+1),(p_mac_string+2),(p_mac_string+3),(p_mac_string+4),(p_mac_string+5));p_mac_string = (unsigned char )ethernet_protocol->ether_dhost;//获取目的macprintf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(p_mac_string+0),(p_mac_string+1),(p_mac_string+2),(p_mac_string+3),(p_mac_string+4),(p_mac_string+5)); /得到以太网的数据包的地址，然后剖析出上层网络协议的类型/ethernet_type = ntohs(ethernet_protocol->ether_type);printf("Ethernet type is :%04x\t",ethernet_type);switch(ethernet_type){case 0x0800:printf("The network layer is IP protocol\n");break;//ipcase 0x0806:printf("The network layer is ARP protocol\n");break;//arpcase 0x0835:printf("The network layer is RARP protocol\n");break;//rarpdefault:printf("The network layer unknow!\n");break;}pcap_close(pcap_handle);return 0;}
把稳：gcc 编译时须要加上 -lpcap，运行时须要利用超级权限
例子2（吸收多个数据包）：
#include <stdio.h>#include <pcap.h>#include <arpa/inet.h>#include <time.h>#include <stdlib.h> #define BUFSIZE 1514 struct ether_header{unsigned char ether_dhost[6];//目的macunsigned char ether_shost[6];//源macunsigned short ether_type;//以太网类型}; /回调函数/void ethernet_protocol_callback(unsigned char argument,const struct pcap_pkthdr packet_heaher,const unsigned char packet_content){unsigned char mac_string;//struct ether_header ethernet_protocol;unsigned short ethernet_type;//以太网类型printf("----------------------------------------------------\n");printf("%s\n", ctime((time_t )&(packet_heaher->ts.tv_sec))); //转换韶光ethernet_protocol = (struct ether_header )packet_content;mac_string = (unsigned char )ethernet_protocol->ether_shost;//获取源mac地址printf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(mac_string+0),(mac_string+1),(mac_string+2),(mac_string+3),(mac_string+4),(mac_string+5));mac_string = (unsigned char )ethernet_protocol->ether_dhost;//获取目的macprintf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x\n",(mac_string+0),(mac_string+1),(mac_string+2),(mac_string+3),(mac_string+4),(mac_string+5));ethernet_type = ntohs(ethernet_protocol->ether_type);//得到以太网的类型printf("Ethernet type is :%04x\n",ethernet_type);switch(ethernet_type){case 0x0800:printf("The network layer is IP protocol\n");break;//ipcase 0x0806:printf("The network layer is ARP protocol\n");break;//arpcase 0x0835:printf("The network layer is RARP protocol\n");break;//rarpdefault:break;}usleep(8001000);} int main(int argc, char argv[]){char error_content[100];//出错信息pcap_t pcap_handle;unsigned char mac_string;unsigned short ethernet_type;//以太网类型char net_interface = NULL;//接口名字struct pcap_pkthdr protocol_header;struct ether_header ethernet_protocol;//获取网络接口net_interface = pcap_lookupdev(error_content);if(NULL == net_interface){perror("pcap_lookupdev");exit(-1);} pcap_handle = pcap_open_live(net_interface,BUFSIZE,1,0,error_content);//打开网络接口if(pcap_loop(pcap_handle,-1,ethernet_protocol_callback,NULL) < 0){perror("pcap_loop");}pcap_close(pcap_handle);return 0;}
运行情形如下：
过滤数据包
我们抓到的数据包每每很多，如何过滤掉我们不感兴趣的数据包呢?
险些所有的操作系统( BSD, AIX, Mac OS, Linux 等)都会在内核中供应过滤数据包的方法，紧张都是基于 BSD Packet Filter( BPF ) 构造的。libpcap 利用 BPF 来过滤数据包。
1）设置过滤条件
BPF 利用一种类似于汇编措辞的语法书写过滤表达式，不过 libpcap 和 tcpdump 都把它封装成更高等且更随意马虎的语法了，详细可以通过 man tcpdump查看：
以下是一些例子：
src host 192.168.1.177
只吸收源 ip 地址是 192.168.1.177 的数据包
dst port 80
只吸收 tcp/udp 的目的端口是 80 的数据包
not tcp
只吸收不该用 tcp 协议的数据包
tcp[13] == 0x02 and (dst port 22 or dst port 23)
只吸收 SYN 标志位置位且目标端口是 22 或 23 的数据包（ tcp 首部开始的第 13 个字节）
icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo
只吸收 icmp 的 ping 要乞降 ping 相应的数据包
ehter dst 00:e0:09:c1:0e:82
只吸收以太网 mac 地址是 00:e0:09:c1:0e:82 的数据包
ip[8] == 5
只吸收 ip 的 ttl=5 的数据包（ip首部开始的第8个字节）
2）编译 BPF 过滤规则
int pcap_compile( pcap_t p,
struct bpf_program fp,
char buf,
int optimize,
bpf_u_int32 mask );
功能：
编译 BPF 过滤规则
参数：
p：pcap_open_live() 返回的 pcap_t 类型的指针
fp：存放编译后的 bpf，运用过滤规则时须要用到这个指针
buf：过滤条件
optimize：是否须要优化过滤表达式
mask：指定本地网络的网络掩码，不须要时可写 0
返回值：
成功返回 0，失落败返回 -1
3）运用 BPF 过滤规则
int pcap_setfilter( pcap_t p, struct bpf_program fp );
功能：
运用 BPF 过滤规则，大略理解为让过滤生效
参数：
p：pcap_open_live() 返回的 pcap_t 类型的指针
fp：pcap_compile() 的第二个参数
返回值：
成功返回 0，失落败返回 -1
这个编译运用过程，有点类似于，我们写一个 C 程序，先编译，后运行的过程。
运用完过滤表达式之后我们便可以利用 pcap_loop() 或 pcap_next() 等抓包函数来抓包了。
下面的程序演示了如何过滤数据包，我们只吸收目的端口是 80 的数据包：
#include <pcap.h>#include <time.h>#include <stdlib.h>#include <stdio.h> void getPacket(u_char arg, const struct pcap_pkthdr pkthdr, const u_char packet){ int id = (int )arg; printf("id: %d\n", ++(id)); printf("Packet length: %d\n", pkthdr->len); printf("Number of bytes: %d\n", pkthdr->caplen); printf("Recieved time: %s", ctime((const time_t )&pkthdr->ts.tv_sec)); int i; for(i=0; i<pkthdr->len; ++i) { printf(" %02x", packet[i]); if( (i + 1) % 16 == 0 ) { printf("\n"); } } printf("\n\n");} int main(){ char errBuf[PCAP_ERRBUF_SIZE], devStr; / get a device / devStr = pcap_lookupdev(errBuf); if(devStr) { printf("success: device: %s\n", devStr); } else { printf("error: %s\n", errBuf); exit(1); } / open a device, wait until a packet arrives / pcap_t device = pcap_open_live(devStr, 65535, 1, 0, errBuf); if(!device) { printf("error: pcap_open_live(): %s\n", errBuf); exit(1); } / construct a filter / struct bpf_program filter; pcap_compile(device, &filter, "dst port 80", 1, 0); pcap_setfilter(device, &filter); / wait loop forever / int id = 0; pcap_loop(device, -1, getPacket, (u_char)&id); pcap_close(device); return 0;}
