Libpcap的介绍与简单使用

最新推荐文章于 2024-05-14 02:09:57 发布
最新推荐文章于 2024-05-14 02:09:57 发布
阅读量1.5k 收藏 16
点赞数 2
分类专栏： 网络编程 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43688708/article/details/123977829
版权

以下代码均运行在Linux环境，需要注意的是，在编译的时候需要链接pcap库

常见函数

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

2.打开网络接口

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表示一直等待直到有数据包到来。
//第五个参数是存放出错信息的数组。

3.释放网络接口

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

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) */
};

5.回调函数

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类型的指针
//第三个参数是收到的数据包数据

跳出回调函数：

void pcap_breakloop(pcap_t *);

6.过滤

构造过滤表达式

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

设置规则

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

例子

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

7.保存为文件

打开用于保存捕获数据包的文件，用于写入

pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname) 
//fname 参数为”-“时表示标准输出。出错时返回NULL。p参数为调用pcap_open_offline()或pcap_open_live()函数后返回的 pcap结构指针。fname参数指定打开的文件名。如果返回NULL，则可调用pcap_geterr()函数获取错误消息。

关闭文件

void pcap_dump_close(pcap_dumper_t *p);

刷新缓冲区，把捕获的数据包从缓冲区真正拷贝到文件

int  pcap_dump_flush(pcap_dumper_t *p)

将数据输入到文件

//输出数据到文件，与pcap_loop的第二个参数回调函数void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet) 形式完全相同，可以直接当pcap_loop的第二个参数；
void   pcap_dump(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)

例子

1.输出设备信息

#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;
    //获取IP地址和子网掩码信息
    int err=pcap_lookupnet(dev,&netp,&maskp,errbuf);
    if(err==-1){
        printf("couldn't detect the ip and maskp: %s\n",errbuf);
        return;
    }
	//ip转换为十进制
    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);
    }
    //返回第一个合适的网络接口字符串指针，errbuf存放出错信息字符串
    //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;
}

image-20220330193534159

2.输出详细信息

#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");
    if(id == 10)
        return;
}

void capture_packet2(pcap_t* device)
{
    struct pcap_pkthdr packet;
    int id = 0;
    //capture the packet

    int i = pcap_loop(device,-1,getPacket,(u_char*)&id);
    printf("i=%d",i);
}

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)
    /*
     * dev->网络接口字符串
     * 65535->对于每个数据包，从开头都抓取65535个字节
     * 1->混杂模式
     * 0->指定需要等待的毫秒数，超过这个数值，函数会立即返回。0表示一直等待数据包的到来。
     * errbuf->出错信息的数组
     */
    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;
}

输出详细包信息

image-20220330210507527

不输出详细包信息

image-20220330210550772

3.实现网络数据包嗅探器

#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;
}

image-20220330213551406

4.将捕获的数据包保存为.pcap文件

#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)
{
    pcap_dump(user, header, 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_dumper_t* out_pcap;            //创建文件指针
    out_pcap  = pcap_dump_open(phandle,"../pack.pcap");     //打开用于保存捕获数据包的文件，用于写入

    pcap_loop(phandle,3,pcap_handle,(u_char *)out_pcap);

    pcap_dump_flush(out_pcap);  //将缓冲区内容写到文件

    pcap_dump_close(out_pcap);
    pcap_close(phandle);
    return 0;
}

image-20220331151446547

image-20220331151455808

SouthAir_nx
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libpcap详解
kking_edc的博客
07-20 7334
libpcap（packet capture library），即数据包捕获函数库，是Unix/Linux平台下的网络数据包捕获函数库。它是一个独立于系统的用户层的包捕获API接口，为底层网络监测提供了一个可移植的框架。 一、工作原理 libpcap主要由两部分组成：网络分接头（network tap）和数据过滤器（packet filter）。网络分接头从网络设备驱动程序中收集数据进行拷贝，过滤器决定是否接收该数据包。libpcap利用BSD packet filter（BPF）算法对网卡接收到的链路层数
【计网 从头自己构建协议】一、libpcap 介绍 & 手撕以太网帧
XcantloadX的博客
04-24 1982
理论的学习总是枯燥的，想要加深对理论的理解，最好的方法就是自己实践一遍。想要亲手实现各种协议，就必须能够接触底层 API。可惜的是，底层的 API 要么是在驱动里，要么是在系统里，都不对外开放，一般只能接触到运输层的 TCP/UDP。我们必须借助第三方库才能实现对底层操控。libpcap就是这样一个库，它帮我们实现了底层驱动，并将控制权向上开放，提供了发送和监听数据包的功能。著名的网络分析工具 Wireshark 就是基于这个库实现的。
2024年10_libpcap以及libnet，校园物联网嵌入式开发面试题
最新发布
2401_85011876的博客
05-14 668
2、在62行将ErrorLog /root/arm-boa/log/error_log改成ErrorLog /home/edu/share/boa/log/error_log。2、在62行将ErrorLog /root/arm-boa/log/error_log改成ErrorLog /home/edu/share/boa/log/error_log。injection_type：构造的类型（LIBNET_LINK,LIBNET_RAW4,LIBNET_LINK_ADV,LIBNET_RAW4_ADV）
libpcap简明教程
大草的博客
01-19 1840
libpcap简明教程
pcap详解
10-01 7001
pcap格式及API详解
libpcap c语言,c语言指定网口转发数据包---使用libpcap包
weixin_42517987的博客
05-19 687
sendPkt.c#include #include int main(int argc, char **argv){system("clear");pcap_t *fp;char errbuf[PCAP_ERRBUF_SIZE];pcap_t *descr= pcap_open_offline("/home/IPS/test.pcap",errbuf);const u_char * packet...
gcc&libpcap.zip
08-11
在 "gcc&libpcap.zip" 压缩包中，可能包含了关于如何在特定环境中安装和使用 GCC 与 libpcap 的指南、示例代码或其他相关资源。解压后，按照文档指示进行操作，可以帮助你更好地理解和运用这两个工具。对于初学者，...
libpcap qt
02-16
本文将详细介绍如何利用Qt和libpcap编写简单的嗅探程序。 首先，libpcap是原始的Packet Capture库，由Berkeley Packet Filter (BPF) 提供支持，它允许开发者在操作系统内核级别捕获网络数据包。libpcap提供了丰富的...
python-libpcap
05-19
Python Libpcap介绍** `python-libpcap`是一个Python模块，它为Python程序提供了一个与`libpcap`接口，使得在Python中实现数据包捕获变得简单。这个模块不仅提供了基本的包捕获功能，还支持过滤、统计和实时分析等...
基于libpcap网卡抓包
07-03
在libpcap的简单应用中，开发者通常会先打开设备，设置筛选规则，然后开始捕获数据包。以下是一个基本的示例： ```c #include void packet_handler(u_char *user, const struct pcap_pkthdr* pkthdr, const u_...
libpcap 抓包 实现网址的显示 有注释
01-29
通过上述步骤，我们可以使用libpcap库构建一个简单的网络嗅探工具，不仅可以监控网络流量，还可以专门针对HTTP协议，提取出请求的网址。这在网络安全、性能调试、数据分析等方面都有广泛的应用。同时，libpcap库的...
libpcap库以及使用方法
08-19
pcap下c与java的库
libpcap（winpcap）捕获数据包与存储和读取
10-29
libpcap（winpcap）捕获数据包与存储和读取 环境 libpcap + Qt Creator
libpcap使用整理
qq_32038155的博客
09-07 3534
Libpcap是Packet Capture Libray的英文缩写，即数据包捕获函数库。该库提供的C函数接口用于捕捉经过指定网络接口的数据包，该接口应该是被设为混杂模式。这个在原始套接字中有提到。
Libpcap和Qt的安装及数据包抓包、过滤、保存
m0_62022097的博客
04-18 2991
是unix/linux平台下的网络数据包捕获函数包，大多数网络监控软件都以它为基础。Libpcap可以在绝大多数类unix平台下工作。Libpcap是一个网络数据包捕获函数库，功能非常强大，Linux下著名的tcpdump就是以它为基础的。
临近毕业了才搞明白pcap的一点用法
zhiying678的专栏
05-08 1747
首先，PCAP_OPENFLAG_MAX_RESPONSIVENESS 就是设置最小拷贝为0   有数据包，立即触发回调函数 pcap_dispatch行为受以下几个设置的影响： 若pcap_setnonblock(0)，表示阻塞模式，pcap_dispatch只有在mintocopy满，或者是timeout到时才返回，返回捕捉到的数据包数 pcap_setnonblock(1)，非
Winpcap抓包主要函数解析
zhang1806618的博客
03-20 2403
pcap.h函数功能及示例介绍： 1.pcap_findalldevs(&alldevs, errbuf)，检索本机设备接口列表，存储至alldevs； 2.pcap_freealldevs(alldevs)，释放接口列表； 3.adhandle=pcap_open_live(d->name, // name of the device 65536, // portion of the packe...
软件开发——SharpPcap抓包
RSZZZZZ
08-07 4658
用WPF实现抓包，抓取流经本机的ARP数据包并解析。 一、环境配置 将PacketDotNet.dll和SharpPcap.dll两个动态链接库拷贝至Debug目录下，并在新建的WPF工程中调用。 二、相关函数 1. 获取本机网卡 private void getAdapter()//获取网卡 { var devices = LibPcapLiveDeviceList.Instance; ...
如何使用libpcap
03-28
1. 安装libpcap库：可以通过包管理器安装，如在Ubuntu上可以使用命令sudo apt-get install libpcap-dev安装。 2. 编写程序：在程序中引入pcap.h头文件，使用pcap_open_live函数打开网络接口或者使用pcap_open_offline函数打开pcap文件，使用pcap_loop或者pcap_dispatch函数循环抓取网络数据包，使用pcap_compile和pcap_setfilter函数设置过滤器。 3. 编译程序：使用gcc或者其他编译器编译程序，需要链接libpcap库，如使用gcc编译可以使用命令gcc -o program program.c -lpcap。 4. 运行程序：可以在终端中运行程序，如./program或者使用其他方式运行程序。 以下是一个简单的抓取网络数据包并打印的程序： ``` #include <stdio.h> #include <pcap.h> void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data); int main() { char errbuf[PCAP_ERRBUF_SIZE]; pcap_t *handle; struct bpf_program fp; bpf_u_int32 net, mask; // 打开网络接口 handle = pcap_open_live("eth0", 65535, 1, 1000, errbuf); // 获取网络接口的网络地址和子网掩码 pcap_lookupnet("eth0", &net, &mask, errbuf); // 设置过滤器 pcap_compile(handle, &fp, "tcp", 0, net); pcap_setfilter(handle, &fp); // 循环抓取网络数据包 pcap_loop(handle, -1, packet_handler, NULL); return 0; } void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data) { printf("Packet length: %d\n", header->len); } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值