Linux 网络编程—— libpcap 详解

摘要：主要的作用捕获各种数据包，列如网络流量统计。分析网络数据包，列如分析网络协议，数据的采集。函数获得指定网络设备的网络号和掩码。函数用于关闭网络设备，释放资源。回调函数，名字任意，根据需要自行起名。

概述
libpcap 是一个网络数据包捕获函数库，功能非常强大，Linux 下著名的 tcpdump 就是以它为基础的。

libpcap主要的作用

• 1）捕获各种数据包，列如：网络流量统计。
• 2）过滤网络数据包，列如：过滤掉本地上的一些数据，类似防火墙。
• 3）分析网络数据包，列如：分析网络协议，数据的采集。
• 4）存储网络数据包，列如：保存捕获的数据以为将来进行分析。

libpcap 的抓包框架

• pcap_lookupdev()：函数用于查找网络设备，返回可被 pcap_open_live() 函数调用的网络设备名指针。
• pcap_lookupnet()：函数获得指定网络设备的网络号和掩码。
• pcap_open_live()： 函数用于打开网络设备，并且返回用于捕获网络数据包的数据包捕获描述字。对于此网络设备的操作都要基于此网络设备描述字。
• pcap_compile()： 函数用于将用户制定的过滤策略编译到过滤程序中。
• pcap_setfilter()：函数用于设置过滤器。
• pcap_loop()：函数 pcap_dispatch() 函数用于捕获数据包，捕获后还可以进行处理，此外 pcap_next() 和 pcap_next_ex() 两个函数也可以用来捕获数据包。
• pcap_close()：函数用于关闭网络设备，释放资源。

利用 libpcap 函数库开发应用程序的基本步骤：

• 1、打开网络设备
• 2、设置过滤规则
• 3、捕获数据
• 4、关闭网络设备

抓包详细步骤
首先要使用 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

实例如下：

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 0NULL);
 
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
"protocol_header.len);    // 数据包的实际长度
 
// 分析以太网中的 源mac、目的mac
struct 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;//获取源mac
printf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x
"*(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;//获取目的mac
printf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x
"*(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：向回调函数中传递的参数。
• userarg：pcap_loop() 的最后一个参数，当收到足够数量的包后 pcap_loop 会调用callback 回调函数，同时将pcap_loop()的user参数传递给它
• pkthdr：是收到数据包的 pcap_pkthdr 类型的指针，和 pcap_next() 第二个参数是一样的。
• acket ：收到的数据包数据
• 返回值：成功返回0，失败返回负数

实例如下：

if( pcap_loop(pcap_handle -1 ethernet_protocol_callback NULL) < 0 )
{
    perror("pcap_loop");
}
 
/*******************************回调函数************************************/
void ethernet_protocol_callback(unsigned char *argumentconst struct pcap_pkthdr *packet_heaherconst unsigned char *packet_content)
{
    unsigned char *mac_string;                //
    struct ether_header *ethernet_protocol;
    unsigned short ethernet_type;            //以太网类型
    printf("----------------------------------------------------
");
    printf("%s
" 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
"*(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;//获取目的mac
    printf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x
"*(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
"ethernet_type);
    switch(ethernet_type)
    {
        case 0x0800:printf("The network layer is IP protocol
");break;//ip
        case 0x0806:printf("The network layer is ARP protocol
");break;//arp
        case 0x0835:printf("The network layer is RARP protocol
");break;//rarp
        default:break;
    }
    usleep(800*1000);
}


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 
#include 
#include 
#include 
#include 
struct ether_header
{
    unsigned char ether_dhost[6];    //目的mac
    unsigned char ether_shost[6];    //源mac
    unsigned short ether_type;        //以太网类型
};
#define BUFSIZE 1514
 
int main(int argcchar *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_nameBUFSIZE10error_content);
    p_packet_content = pcap_next(pcap_handle&protocol_header);
    
    printf("------------------------------------------------------------------------
");
    printf("capture a Packet from p_net_interface_name :%s
"p_net_interface_name);
    printf("Capture Time is :%s"ctime((const time_t *)&protocol_header.ts.tv_sec));
    printf("Packet Lenght is :%d
"protocol_header.len);
    
    /*
    *分析以太网中的 源mac、目的mac
    */
    ethernet_protocol = (struct ether_header *)p_packet_content;
    p_mac_string = (unsigned char *)ethernet_protocol->ether_shost;//获取源mac
    printf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x
"*(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;//获取目的mac
    printf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x
"*(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	"ethernet_type);
    switch(ethernet_type)
    {
        case 0x0800:printf("The network layer is IP protocol
");break;//ip
        case 0x0806:printf("The network layer is ARP protocol
");break;//arp
        case 0x0835:printf("The network layer is RARP protocol
");break;//rarp
        default:printf("The network layer unknow!
");break;
    }
    
    pcap_close(pcap_handle);
    return 0;
}

注意：gcc 编译时需要加上 -lpcap，运行时需要使用超级权限