libpcap_libpcap抓包 - CSDN
精华内容
参与话题
  • libpcap详解

    千次阅读 2018-07-12 09:43:53
    libpcap(Packet Capture Library),即数据包捕获函数库,是Unix/Linux平台下的网络数据包捕获函数库。它是一个独立于系统的用户层包捕获的API接口,为底层网络监测提供了一个可移植的框架。检查网络设备libpcap ...
    展开全文
  • Libpcap的安装及使用

    万次阅读 2017-02-10 13:43:36
    1.Libpcap简介   Libpcap是Packet Capture Libray的英文缩写,即数据包捕获函数库。该库提供的C函数接口用于捕捉经过指定网络接口的数据包,该接口应该是被设为混杂模式。这个在原始套接子中有提到。  著名...

    http://www.cnblogs.com/coder2012/archive/2013/04/13/3012390.html

    1.Libpcap简介 

     Libpcap是Packet Capture Libray的英文缩写,即数据包捕获函数库。该库提供的C函数接口用于捕捉经过指定网络接口的数据包,该接口应该是被设为混杂模式。这个在原始套接子中有提到。

      著名的软件TCPDUMP就是在Libpcap的基础上开发而成的。Libpcap提供的接口函数实现和封装了与数据包截获有关的过程。

      Libpcap提供了用户级别的网络数据包捕获接口,并充分考虑到应用程序的可移植性。Libpcap可以在绝大多数Linux平台上运行。在Windows平台上,也有一款与其功能类似的开发库:Wincap。

      它的工作在上层应用程序与网络接口之间。

      主要功能:

    • 数据包捕获:捕获流经网卡的原始数据包
    • 自定义数据包发送:构造任何格式的原始数据包
    • 流量采集与统计:采集网络中的流量信息
    • 规则过滤:提供自带规则过滤功能,按需要选择过滤规则

      它的应用范围非常广泛,典型应用包括玩罗协议分析器,网络流量发生器,网络入侵检测系统,网络扫描器和其他安全工具。

    2.Libpcap的安装

    Libpcap的下载地址:点击

    切换到下载目录,解压压缩文件,配置,编译,安装

    cd ****
    tar zxvf ****
    ./configure
    make
    make install

    配置中如果出现错误,请查看你是否安装了所有的依赖包bison, m4, GNU, flex以及libpcap-dev(安装方法 sudo apt-get ****)

    注意运行时候,是需要root权限的 sudo ./***

    测试程序:

    复制代码
    #include <pcap.h>
    #include <stdio.h>
    
    int main()
    {
      char errBuf[PCAP_ERRBUF_SIZE], * device;
      
      device = pcap_lookupdev(errBuf);
      
      if(device)
      {
        printf("success: device: %s\n", device);
      }
      else
      {
        printf("error: %s\n", errBuf);
      }
      
      return 0;
    }
    复制代码

    makefile文件:

    test: test.c
        gcc -Wall -o test test.c -lpcap
    clean:
        rm -rf *.o test

    3.Libpcap的工作原理

      作为捕捉网络数据包的库,它是一个独立于系统的用户级的API接口,为底层网络检测提供了一个可移植的框架。

      一个包的捕捉分为三个主要部分,包括面向底层包捕获、面向中间层的数据包过滤和面向应用层的用户接口。这与Linux操作系统对数据包的处理流程是相同的(网卡->网卡驱动->数据链路层->IP层->传输层->应用程序)。包捕获机制是在数据链路层增加一个旁路处理(并不干扰系统自身的网络协议栈的处理),对发送和接收的数据包通过Linux内核做过滤和缓冲处理,最后直接传递给上层应用程序。

      

      下面介绍Libpcap的抓包流程:

    1. 查找网络设备:目的是发现可用的网卡,实现的函数为pcap_lookupdev(),如果当前有多个网卡,函数就会返回一个网络设备名的指针列表。
    2. 打开网络设备:利用上一步中的返回值,可以决定使用哪个网卡,通过函数pcap_open_live()打开网卡,返回用于捕捉网络数据包的秒数字。
    3. 获得网络参数:这里是利用函数pcap_lookupnet(),可以获得指定网络设备的IP地址和子网掩码。
    4. 编译过滤策略:Lipcap的主要功能就是提供数据包的过滤,函数pcap_compile()来实现。
    5. 设置过滤器:在上一步的基础上利用pcap_setfilter()函数来设置。
    6. 利用回调函数,捕获数据包:函数pcap_loop()和pcap_dispatch()来抓去数据包,也可以利用函数pcap_next()和pcap_next_ex()来完成同样的工作。
    7. 关闭网络设备:pcap_close()函数关系设备,释放资源。

    4.函数功能具体介绍与分析

    1.获取网络接口

    char * pcap_lookupdev(char * errbuf)
    //上面这个函数返回第一个合适的网络接口的字符串指针,如果出错,则errbuf存放出错信息字符串,errbuf至少应该是PCAP_ERRBUF_SIZE个字节长度的
    int pcap_lookupnet(const char * device, bpf_u_int32 * netp, bpf_u_int32 * maskp, char * errbuf)
    //可以获取指定设备的ip地址,子网掩码等信息
    //netp:传出参数,指定网络接口的ip地址
    //maskp:传出参数,指定网络接口的子网掩码
    //pcap_lookupnet()失败返回-1
    //net,mask的转换方式,inet_ntoa可以把他转换成10机制字符串 头文件 arpa/inet.h 
    addr.s_addr=netp;
    net=inet_ntoa(addr);
    
    addr.s_addr=maskp;
    mask=inet_ntoa(addr);

    举例:

    复制代码
    #include <stdio.h>
    #include <pcap.h>
    #include <time.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    void show_ip_mask(char* dev)
    {
        char errbuf[1024];
        struct in_addr addr;
        char *net,*mask;
        bpf_u_int32 netp,maskp;
        int err=pcap_lookupnet(dev,&netp,&maskp,errbuf);
        if(err==-1){
            printf("couldn't detect the ip and maskp: %s\n",errbuf);
            return;
        }
        
        addr.s_addr=netp;
        net=inet_ntoa(addr);
        if(net==NULL){
            printf("ip error\n");
            return;
        }
        printf("ip: %s\n",net);
        addr.s_addr=maskp;
        mask=inet_ntoa(addr);
        if(mask==NULL){
            printf("mask errorn");
            return;
        }
        printf("mask: %s\n",mask);
    }
    
    int main()
    {
        char *dev, errbuf[1024];
        char select='a';
        printf("select(dispaly the packet in detail)/n:( Y/N ?))");
        scanf("%c",&select);
        while(select!='Y'&&select!='y'&&select!='n'&&select!='N'){
            printf("input the error!\nplease input the Y/N/y/n:");
            scanf("%c",&select);
        }
        
        //look for the net device
        dev=pcap_lookupdev(errbuf);
        if(dev==NULL){
            printf("couldn't find default device: %s\n",errbuf);
            return 1;
        }
        else{
            printf("fidn success: device :%s\n",dev);
        }
        
        //ip mask display
        show_ip_mask(dev);
        return 0;
    }
    复制代码

     

    2.释放网络接口

    void pcap_close(pcap_t * p)
    //该函数用于关闭pcap_open_live()获取的pcap_t的网络接口对象并释放相关资源。

    3.打开网络接口

    复制代码
    pcap_t * pcap_open_live(const char * device, int snaplen, int promisc, int to_ms, char * errbuf)
    //上面这个函数会返回指定接口的pcap_t类型指针,后面的所有操作都要使用这个指针。
    //第一个参数是第一步获取的网络接口字符串,可以直接使用硬编码。
    //第二个参数是对于每个数据包,从开头要抓多少个字节,我们可以设置这个值来只抓每个数据包的头部,而不关心具体的内容。典型的以太网帧长度是1518字节,但其他的某些协议的数据包会更长一点,但任何一个协议的一个数据包长度都必然小于65535个字节。
    //第三个参数指定是否打开混杂模式(Promiscuous Mode),0表示非混杂模式,任何其他值表示混合模式。如果要打开混杂模式,那么网卡必须也要打开混杂模式,可以使用如下的命令打开eth0混杂模式:ifconfig eth0 promisc
    //第四个参数指定需要等待的毫秒数,超过这个数值后,第3步获取数据包的这几个函数就会立即返回。0表示一直等待直到有数据包到来。
    //第五个参数是存放出错信息的数组。
    复制代码

    4.获取数据包

    u_char * pcap_next(pcap_t * p, struct pcap_pkthdr * h)
    //如果返回值为NULL,表示没有抓到包
    //第一个参数是第2步返回的pcap_t类型的指针
    //第二个参数是保存收到的第一个数据包的pcap_pkthdr类型的指针

      pcap_pkthdr类型的定义如下:

    struct pcap_pkthdr
    {
      struct timeval ts;    /* time stamp */
      bpf_u_int32 caplen;   /* length of portion present */
      bpf_u_int32 len;      /* length this packet (off wire) */
    };
    复制代码
    int pcap_loop(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
    //第一个参数是第2步返回的pcap_t类型的指针
    //第二个参数是需要抓的数据包的个数,一旦抓到了cnt个数据包,pcap_loop立即返回。负数的cnt表示pcap_loop永远循环抓包,直到出现错误。
    //第三个参数是一个回调函数指针,它必须是如下的形式:
    void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
    //第一个参数是pcap_loop的最后一个参数,当收到足够数量的包后pcap_loop会调用callback回调函数,同时将pcap_loop()的user参数传递给它
    //第二个参数是收到的数据包的pcap_pkthdr类型的指针
    //第三个参数是收到的数据包数据
    复制代码
    int pcap_dispatch(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
    //这个函数和pcap_loop()非常类似,只是在超过to_ms毫秒后就会返回(to_ms是pcap_open_live()的第4个参数)

       

      来试试这几个函数,一个简单的例子:

    复制代码
    #include <stdio.h>
    #include <pcap.h>
    #include <time.h>
    
    void capture_packet1(pcap_t* device)
    {
        struct pcap_pkthdr packet;
        char errbuf[1024];
        //capture the packet        
        const u_char* pkt=pcap_next(device,&packet);
        if(!pkt){
            printf("couldn't capture packet: %s\n",errbuf);
            return;
        }
    
        //output the pacaket length byte and time
        printf("Packet length: %d\n", packet.len);  
        printf("Number of bytes: %d\n", packet.caplen);  
        printf("Recieved time: %s\n", ctime((const time_t*)&packet.ts.tv_sec)); 
    }
    
    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\n", ctime((const time_t *)&pkthdr->ts.tv_sec));   
        //print packet 
        int i;  
        for(i=0; i<pkthdr->len; ++i)  {  
            printf(" %02x", packet[i]);  
            if( (i + 1) % 16 == 0 )   
                printf("\n");  
        }  
        printf("\n\n");
    }
    
    void capture_packet2(pcap_t* device)
    {
        struct pcap_pkthdr packet;
        int id = 0;
        //capture the packet
        pcap_loop(device,-1,getPacket,(u_char*)&id);
    }
    
    int main()
    {
        char *dev, errbuf[1024];
        char select='a';
        printf("select(dispaly the packet in detail)/n:( Y/N ?))");
        scanf("%c",&select);
        while(select!='Y'&&select!='y'&&select!='n'&&select!='N'){
            printf("input the error!\nplease input the Y/N/y/n:");
            scanf("%c",&select);
        }
        
        //look for the net device
        dev=pcap_lookupdev(errbuf);
        if(dev==NULL){
            printf("couldn't find default device: %s\n",errbuf);
            return 1;
        }
        else{
            printf("fidn success: device :%s\n",dev);
        }
        
        //open the finded device(must set :ifconfig eth0 promisc)
        pcap_t* device=pcap_open_live(dev,65535,1,0,errbuf);
        if(!device){
            printf("couldn't open the net device: %s\n",errbuf);
            return 1;
        }
        if(select=='Y')
            capture_packet2(device);
        else
            while(1)//由于pcap_next()函数只返回下一个数据包的指针
                capture_packet1(device); 
        return 0;
    }
    复制代码

    5.分析数据包

      根据不同的网络协议,来设计不同的数据包分析方法,具体参考相关协议的说明。

    6.过滤数据包(这部分是非常重要的)

      libpcap利用BPF来过滤数据包。
      过滤数据包需要完成3件事:
      a) 构造一个过滤表达式
      b) 编译这个表达式
      c) 应用这个过滤器

      a)Lipcap已经把BPF语言封装成为了更高级更容易的语法了。

      举例:

    复制代码
    src host 127.0.0.1
    //选择只接受某个IP地址的数据包
    
    dst port 8000
    //选择只接受TCP/UDP的目的端口是80的数据包
    
    not tcp
    //不接受TCP数据包
    
    tcp[13]==0x02 and (dst port ** or dst port **)
    //只接受SYN标志位置(TCP首部开始的第13个字节)且目标端口号是22或23的数据包
    
    icmp[icmptype]==icmp-echoreply or icmp[icmptype]==icmp-echo
    //只接受icmp的ping请求和ping响应的数据包
    
    ehter dst 00:00:00:00:00:00
    //只接受以太网MAC地址为00:00:00:00:00:00的数据包
    
    ip[8]==5
    //只接受ip的ttl=5的数据包(ip首位第八的字节为ttl)
    复制代码

     

      b)构造完过滤表达式后,就可以使用pcap_compile()函数来编译。

    int pcap_compile(pcap_t * p, struct bpf_program * fp, char * str, int optimize, bpf_u_int32 netmask)
    //fp:这是一个传出参数,存放编译后的bpf
    //str:过滤表达式
    //optimize:是否需要优化过滤表达式
    //metmask:简单设置为0即可

      c)最后通过函数pcap_setfilter()来设置这个规则

    int pcap_setfilter(pcap_t * p,  struct bpf_program * fp)
    //参数fp就是pcap_compile()的第二个参数,存放编译后的bpf

    举例:

    可以在抓包前,也就是pcap_next()或pcap_loop之前,加入下面的代码:

       //design filter  
        struct bpf_program filter;  
        pcap_compile(device, &filter, "dst port 80", 1, 0);  //只接受80端口的TCP/UDP数据包
        pcap_setfilter(device, &filter); 

     5.基于Libpcap实现一个网络数据包嗅探器

      基本功能就是来捕获所有流经本网卡的数据包。

      实现流程:

    1. 查找网络设备
    2. 打开网络设备
    3. 查找设备信息
    4. 输入过滤规则
    5. 编译输入规则
    6. 设置输入规则
    7. 开始捕获数据包
    8. 调用数据包分析模块
    9. 输出MAC,IP,协议以及数据帧
    10. 结束 

    具体实现代码:

    复制代码
    #include <stdio.h>
    #include <pcap.h>
    #include <time.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <errno.h>
    #include <string.h>
    
    //链路层数据包格式
    typedef struct {
        u_char DestMac[6];
        u_char SrcMac[6];
        u_char Etype[2];
    }ETHHEADER;
    //IP层数据包格式
    typedef struct {
        int header_len:4;
        int version:4;
        u_char tos:8;
        int total_len:16;
        int ident:16;
        int flags:16;
        u_char ttl:8;
        u_char proto:8;
        int checksum:16;
        u_char sourceIP[4];
        u_char destIP[4];
    }IPHEADER;
    //协议映射表
    char *Proto[]={
        "Reserved","ICMP","IGMP","GGP","IP","ST","TCP"
    };
    //回调函数
    void pcap_handle(u_char* user,const struct pcap_pkthdr* header,const u_char* pkt_data)
    {
        ETHHEADER *eth_header=(ETHHEADER*)pkt_data;
        printf("---------------Begin Analysis-----------------\n");
        printf("----------------------------------------------\n");
        printf("Packet length: %d \n",header->len);
        //解析数据包IP头部
        if(header->len>=14){
            IPHEADER *ip_header=(IPHEADER*)(pkt_data+14);
            //解析协议类型
            char strType[100];
            if(ip_header->proto>7)
                strcpy(strType,"IP/UNKNWN");
            else
                strcpy(strType,Proto[ip_header->proto]);
            
            printf("Source MAC : %02X-%02X-%02X-%02X-%02X-%02X==>",eth_header->SrcMac[0],eth_header->SrcMac[1],eth_header->SrcMac[2],eth_header->SrcMac[3],eth_header->SrcMac[4],eth_header->SrcMac[5]);
            printf("Dest   MAC : %02X-%02X-%02X-%02X-%02X-%02X\n",eth_header->DestMac[0],eth_header->DestMac[1],eth_header->DestMac[2],eth_header->DestMac[3],eth_header->DestMac[4],eth_header->DestMac[5]);
            
            printf("Source IP : %d.%d.%d.%d==>",ip_header->sourceIP[0],ip_header->sourceIP[1],ip_header->sourceIP[2],ip_header->sourceIP[3]);
            printf("Dest   IP : %d.%d.%d.%d\n",ip_header->destIP[0],ip_header->destIP[1],ip_header->destIP[2],ip_header->destIP[3]);
            
            printf("Protocol : %s\n",strType);
            
            //显示数据帧内容
            int i;  
            for(i=0; i<(int)header->len; ++i)  {  
                printf(" %02x", pkt_data[i]);  
                if( (i + 1) % 16 == 0 )   
                    printf("\n");  
            }  
            printf("\n\n");
        }
    }
    
    int main(int argc, char **argv)
    {
        char *device="eth0";
        char errbuf[1024];
        pcap_t *phandle;
        
        bpf_u_int32 ipaddress,ipmask;
        struct bpf_program fcode;
        int datalink;
        
        if((device=pcap_lookupdev(errbuf))==NULL){
            perror(errbuf);
            return 1;
        }
        else
            printf("device: %s\n",device);
        
        phandle=pcap_open_live(device,200,0,500,errbuf);
        if(phandle==NULL){
            perror(errbuf);
            return 1;
        }
        
        if(pcap_lookupnet(device,&ipaddress,&ipmask,errbuf)==-1){
            perror(errbuf);
            return 1;
        }
        else{
            char ip[INET_ADDRSTRLEN],mask[INET_ADDRSTRLEN];
            if(inet_ntop(AF_INET,&ipaddress,ip,sizeof(ip))==NULL)
                perror("inet_ntop error");
            else if(inet_ntop(AF_INET,&ipmask,mask,sizeof(mask))==NULL)
                perror("inet_ntop error");
            printf("IP address: %s, Network Mask: %s\n",ip,mask);
        }
        
        int flag=1;
        while(flag){
            //input the design filter
            printf("Input packet Filter: ");
            char filterString[1024];
            scanf("%s",filterString);
            
            if(pcap_compile(phandle,&fcode,filterString,0,ipmask)==-1)
                fprintf(stderr,"pcap_compile: %s,please input again....\n",pcap_geterr(phandle));
            else
                flag=0;
        }
        
        if(pcap_setfilter(phandle,&fcode)==-1){
            fprintf(stderr,"pcap_setfilter: %s\n",pcap_geterr(phandle));
            return 1;
        }
        
        if((datalink=pcap_datalink(phandle))==-1){
            fprintf(stderr,"pcap_datalink: %s\n",pcap_geterr(phandle));
            return 1;
        }
        
        printf("datalink= %d\n",datalink);
    
        pcap_loop(phandle,-1,pcap_handle,NULL);
        
        return 0;
    }
    复制代码
    展开全文
  • libpcap安装 先安装flex,bison yum -y install flex yum -y install bison 下载libpcap源码并解压,再输入如下命令 ./configure make make install libpcap常用函数 int pcap_findalldevs(pcap_if_t **alldevsp, ...

    libpcap安装

    先安装flex,bison

    yum -y install flex
    yum -y install bison
    

    下载libpcap源码并解压,再输入如下命令

    ./configure
    make
    make install
    

    libpcap常用函数

    int pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf);
    

    查找所有可用的网络设备,若没有找到则返回-1

    pcap_t * pcap_open_live(const char * device, int snaplen, int promisc, int to_ms, char * errbuf)
    

    打开某个特定网络接口
    第一个参数是第一步获取的网络接口字符串,可以直接使用硬编码。
    第二个参数对于每个数据包,从开头要抓多少个字节,我们可以设置这个值来只抓每个数据包的头部,而不关心具体的内容。典型的以太网帧长度是1518字节,但其他的某些协议的数据包会更长一点,但任何一个协议的一个数据包长度都必然小于65535个字节。
    第三个参数指定是否打开混杂模式(Promiscuous Mode),0表示非混杂模式,任何其他值表示混合模式。
    第四个参数指定需要等待的毫秒数,超过这个数值后,第3步获取数据包的这几个函数就会立即返回。0表示一直等待直到有数据包到来。
    第五个参数是存放出错信息的数组。

    int pcap_loop(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
    

    获取数据包
    第一个参数是之前打开网络接口时返回的pcap_t类型的指针
    第二个参数是需要抓的数据包的个数,一旦抓到了cnt个数据包,pcap_loop立即返回。负数的cnt表示pcap_loop永远循环抓包,直到出现错误。
    第三个参数是一个回调函数指针,它必须是如下的形式:

    void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
    

    第一个参数是pcap_loop的最后一个参数,当收到足够数量的包后pcap_loop会调用callback回调函数,同时将pcap_loop()的user参数传递给它
    第二个参数是收到的数据包的pcap_pkthdr类型的指针
    第三个参数是收到的数据包数据

    int pcap_compile(pcap_t * p, struct bpf_program * fp, char * str, int optimize, bpf_u_int32 netmask)
    int pcap_setfilter(pcap_t * p,  struct bpf_program * fp)
    

    设置过滤条件
    fp:这是一个传出参数,存放编译后的bpf
    str:过滤表达式
    optimize:是否需要优化过滤表达式
    netmask:可通过pcap_lookupnet函数获得

    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:存放出错信息

    void pcap_close(pcap_t *p);
    

    关闭 pcap_open_live() 打开的网络接口(即其返回值,pcap_t 类型指针),并释放相关资源。注意,操作完网络接口,应该释放其资源。

    展开全文
  • Linux 网络编程—— libpcap 详解

    万次阅读 多人点赞 2018-02-16 08:14:50
    概述libpcap 是一个网络数据包捕获函数库,功能非常强大,Linux 下著名的 tcpdump 就是以它为基础的。libpcap主要的作用1)捕获各种数据包,列如:网络流量统计。2)过滤网络数据包,列如:过滤掉本地上的一些数据,...

    概述

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


    libpcap主要的作用

    1)捕获各种数据包,列如:网络流量统计。

    2)过滤网络数据包,列如:过滤掉本地上的一些数据,类似防火墙。

    3)分析网络数据包,列如:分析网络协议,数据的采集。

    4)存储网络数据包,列如:保存捕获的数据以为将来进行分析。


    libpcap 的安装



    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);

    功能:

    捕获一个网络数据包,收到一个数据包立即返回

    参数:

    ppcap_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、目的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\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;//获取目的mac
    printf("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 指定的回调函数,所以,可以在回调函数中进行数据包的处理操作。

    参数:

    ppcap_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;//获取目的mac
    	printf("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;//ip
    		case 0x0806:printf("The network layer is ARP protocol\n");break;//arp
    		case 0x0835:printf("The network layer is RARP protocol\n");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 <stdio.h>
    #include <pcap.h>
    #include <arpa/inet.h>
    #include <time.h>
    #include <stdlib.h>
    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 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;//获取源mac
    	printf("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;//获取目的mac
    	printf("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;//ip
    		case 0x0806:printf("The network layer is ARP protocol\n");break;//arp
    		case 0x0835:printf("The network layer is RARP protocol\n");break;//rarp
    		default: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];	//目的mac
    	unsigned char ether_shost[6];	//源mac
    	unsigned 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;//获取目的mac
    	printf("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;//ip
    		case 0x0806:printf("The network layer is ARP protocol\n");break;//arp
    		case 0x0835:printf("The network layer is RARP protocol\n");break;//rarp
    		default:break;
    	}
    	usleep(800*1000);
    }
    
    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;
    }


    源代码下载请点此处。


    展开全文
  • 在LINUX系统下使用libpcap,一些流程

    千次阅读 2016-08-14 13:33:16
    libpcap使用 libpcap是一个网络数据包捕获函数库,功能非常强大,Linux下著名的tcpdump就是以它为基础的。今天我们利用它来完成一个我们自己的网络嗅探器(sniffer) 首先先介绍一下本次实验的环境: Ubuntu ...
  • libpcap简介

    2013-05-08 23:24:03
     libpcap是unix/linux平台下的网络数据包捕获函数包,大多数网络监控软件都以它为基础。Libpcap可以在绝大多数类unix平台下工作. 2、功能 (1)数据包捕获  捕获流经本网卡的所有原始数据包,甚至对交换...
  • libpcap原理及使用

    万次阅读 2017-12-07 17:06:26
    2.9 libpcap 本文最初整理在我的github上SDN-Learning-notes libpcap(Packet Capture Library)即数据包捕获函数库,是Unix/Linux平台下的网络数据包捕获函数库。它是一个独立于系统的用户层包捕获的API接口,为...
  • Libpcap简介

    2018-12-07 13:40:42
    1.Libpcap简介   Libpcap是Packet Capture Libray的英文缩写,即数据包捕获函数库。该库提供的C函数接口用于捕捉经过指定网络接口的数据包,该接口应该是被设为混杂模式。这个在原始套接子中有提到。  著名的...
  • Linux下libpcap的安装与使用

    万次阅读 2013-05-21 14:25:05
    1, 环境: Ubuntu10.04 + libpcap-1.4.0.tar.gz 2,Libpcap下载: 官方地址-http://www.tcpdump.org/#latest-release 即可下载最新版本的libpcap。 3,解压libpcap-1.4.0.tar.gz: tar -zxvf libpcap-1.4.0.tar....
  • centos使用yum安装libpcap

    万次阅读 2014-06-10 11:44:52
    最简单的方法是使用yum,但默认的是无法安装libpcaplibpcap-dev
  • linux下安装libpcap步骤

    千次阅读 2012-03-12 18:41:36
    1.从 ftp://ftp.gnu.org/gnu/下载最新版本flex、bison、GNU M4、libpcap安装包。链接如下: ftp://ftp.gnu.org/gnu/bison/ ftp://ftp.gnu.org/gnu/m4/ http://sourceforge.net/projects/flex/files/ ...
  • libpcap的安装方法详解

    万次阅读 2017-01-06 20:40:02
    一、 安装过程参照以下步骤(以下所安装的版本为旧版本蓝色标出,可以自行选择新版本):  ...libpcap-1.0.0.tar.gz 解压文件,并将其放入自定义的安装目录。 2、打开网址:github.com/com/westes/fle
  • centos 安装libpcap

    千次阅读 2013-05-02 20:12:40
    centos 安装libpcap: 其实这个很简单的事情,网上下载源码,自己编译也可以。root用户模式下: ./configure ./make ./make install 或者直接(如果连了网络的话): yum install libpcap 就这样安装好了...
  • 获取libpcap版本号

    千次阅读 2010-11-29 17:32:00
    来自tcpdump代码,libpcap中导出pcap_version变量,代表了libpcap的版本号。#if defined(WIN32) || defined(HAVE_PCAP_VERSION) extern char pcap_version[]; #else static char pcap_version[] = "unknown"; ...
  • yum 安装libpcap

    千次阅读 2019-03-01 12:49:45
    最近编写库文件的时候。出现了很多警告和错误,几乎都是关于没有安装libpcap库的原因。 针对于centos系统安装libpcap库命令: yum install libpcap yum install libpcap-devel ...
  • CentOS安装libpcap

    万次阅读 2012-01-12 14:51:27
    1.安装GCC:  yum -y install gcc-c++ ... 没有flex,直接安装libpcap会提示"Your operating system's lex is insufficient to compile libpcap"错误; 3.安装bison  yum -y install bison
  • github中fork项目更新方式

    千次阅读 2018-01-17 10:07:55
    在github上看到好的开源项目可以fork成为自己的项目。但是如果fork的项目更新了自己的项目要怎样保持更新呢? 经过一番搜索后找到方法,下面记录下流程。 方法一:登录你的github帐号,选择fork的项目,点击左上角...
  • libpcap安装

    千次阅读 2013-11-14 15:42:01
    1,下载libpcap。 http://www.tcpdump.org/release/libpcap-1.2.1.tar.gz 2,解压libpcap-1.2.1.tar.gz tar -zxvf libpcap-1.2.1.tar.gz 3,进入解压后的libpcap目录 cd libpcap 4,生成makefile ./configure 5,...
  • Linux 下libpcap和Windows下winpcap 捕获网络数据包的异同
  • 这两天公司里要我了解一下pcap,但是还不知道它是干什么的。首先,我从网上查到了,pcap实际上是抓包库。这个抓包库给抓包系统提供了一个高层次的接口。所有网络上的数据包,甚至是那些发送给其他主机的,...
1 2 3 4 5 ... 20
收藏数 13,566
精华内容 5,426
关键字:

libpcap