LIbpcap2

合集下载

基于libcap、winpcap的网络编程

基于libcap、winpcap的网络编程

第五章基于libpcap的网络编程技术5. 1常见的包捕获机制简介包捕获就是利用以太网的介质共享的特性,通过将网络适配器设置为混杂模式的方法,接收到所有网络上的以太网帧。

包捕获的机制大致可以分为两类:一类是由操作系统内核提供的捕获机制。

另一类是由应用软件或系统开发包捕获驱动程序提供的捕获机制。

常见的包捕获机制如表5-1所示。

其中最主要的是下列4种:BPF ( Berkeley Packet Filter )DLPI ( Data Link Provider In terface )NIT ( Network In terface Tap ) SOCK-PACKET 类型套接口。

BPF由基于BSD的Unix系统内核所实现。

DLPI是Solaris (和其他System V UNIX ) 系统的内嵌子系统。

NIT是SUN OS4 系统的一部分,但在Solaris /SUN OS5 中被DLPI 所取代。

Linux核心则实现了SOCK-PACKET 的包捕获机制。

从性能上看,BPF比DLPI 和NIT 好得多,SOCK-PACKET 最弱。

表5-1常用的包捕获机制由于现在很多局域网为NT网,其网络传输方式大多采用以太网标准,所以涉及的编程也是在Windows 环境下实现的。

Windows 操作系统没有提供包捕获机制,只提供了数量很少并且功能有限的API调用。

在Windows 环境下由于其自身的封装性,很难对其底层进行编程。

本章将对BSD系列的libpcap进行深入地介绍。

5.2 Libpcap 与 BPF(1) libpcap 概述libpcap(Packet Capturelibrary),即数据包捕获函数库。

该库提供的 C 函数接口可用于捕获经过网络接口 (只要经过该接口,目标地址不一定为本机)的数据包。

它是由洛仑兹 伯克利试验室的研究人员 Steven McCanne 和Van Jacobson 于1993 年在Usenix'93 会议上正式提出的一种用于 Unix 内核数据包过滤体制。

libpcap主要函数及过程详解

libpcap主要函数及过程详解

libpcap主要函数及过程详解/uid-21556133-id-120228.htmllibpcap(Packet Capture Library),即数据包捕获函数库,是Unix/Linux平台下的⽹络数据包捕获函数库。

它是⼀个独⽴于系统的⽤户层包捕获的API接⼝,为底层⽹络监测提供了⼀个可移植的框架。

⼀、libpcap⼯作原理libpcap主要由两部份组成:⽹络分接头(Network Tap)和数据过滤器(Packet Filter)。

⽹络分接头从⽹络设备驱动程序中收集数据拷贝,过滤器决定是否接收该数据包。

Libpcap利⽤BSD Packet Filter(BPF)算法对⽹卡接收到的链路层数据包进⾏过滤。

BPF算法的基本思想是在有BPF监听的⽹络中,⽹卡驱动将接收到的数据包复制⼀份交给BPF过滤器,过滤器根据⽤户定义的规则决定是否接收此数据包以及需要拷贝该数据包的那些内容,然后将过滤后的数据给与过滤器相关联的上层应⽤程序。

libpcap的包捕获机制就是在数据链路层加⼀个旁路处理。

当⼀个数据包到达⽹络接⼝时,libpcap⾸先利⽤已经创建的Socket从链路层驱动程序中获得该数据包的拷贝,再通过Tap函数将数据包发给BPF过滤器。

BPF过滤器根据⽤户已经定义好的过滤规则对数据包进⾏逐⼀匹配,匹配成功则放⼊内核缓冲区,并传递给⽤户缓冲区,匹配失败则直接丢弃。

如果没有设置过滤规则,所有数据包都将放⼊内核缓冲区,并传递给⽤户层缓冲区。

⼆、libpcap的抓包框架pcap_lookupdev()函数⽤于查找⽹络设备,返回可被pcap_open_live()函数调⽤的⽹络设备名指针。

pcap_open_live()函数⽤于打开⽹络设备,并且返回⽤于捕获⽹络数据包的数据包捕获描述字。

对于此⽹络设备的操作都要基于此⽹络设备描述字。

pcap_lookupnet()函数获得指定⽹络设备的⽹络号和掩码。

pcap_compile()函数⽤于将⽤户制定的过滤策略编译到过滤程序中。

Tcpdump格式文件分析

Tcpdump格式文件分析

Tcpdump格式文件分析一、前言Tcpdump是Linux系统上最有名的抓包工具,它所保存的dmp格式文件能被许多抓包分析工具读取(EtherPeek、Ethereal、WinPcap等)。

由于想通过读取Tcpdump格式文件的方式,分析抓取到的数据包。

查阅过许多关于TCP/IP协议的书,都是关于IP数据包这层的分析。

没有关于Tcpdump格式文件的介绍。

后来看过Tcpdump主页()上下载的源码后发现,其对Tcpdump格式文件的处理是通过libpcap这个库实现的。

你也可以调用这个库实现对Tcpdump格式文件的读取,但美中不足的是它只提供C语言调用库,不提供Java语言调用库。

最后在其网站的/release/地址看到了libpcap库的源代码,以下所有结论都是通过分析这个源代码得出的,并且只对Tcpdump格式文件主版本号大于等于2的有效(在之后的Tcpdump格式文件头中会对主版本号加以说明)。

二、总体介绍Tcpdump格式文件是标准的二进制文件,可以使用UltraEdit等工具打开。

分析后发现其文件分为三部分:1.Tcpdump格式文件头;2.Packet头;3.IP数据报包。

其中Tcpdump格式文件头长度为24个字节,Packet头部分长度为16个字节,并且在所有的抓包分析工具(EtherPeek、Ethereal、WinPcap等)中都不能显示出来。

下图就是各部分内容的示意图,其中标记了一个Tcpdump格式文件头和两对Packet头+ IP数据报包。

三、背景知识Tcpdump在处理Tcpdump格式文件头和Packet头部分数据时将所有数据颠倒后再进行保存的,所以当从Tcpdump格式文件中读出这两部分数据后还需要再颠倒回来。

以下内容摘自libpcap源代码的savefile.c文件中:共提供两个方法:1、SWAPLONG函数将长整形的前后颠倒,例如:将AABBCCDD颠倒为DDCCBBAA;2、SWAPSHORT函数将短整形的前后颠倒,例如:将AABB颠倒为BBAA。

libpcap 过滤规则

libpcap 过滤规则

libpcap 过滤规则`libpcap` 是一个用于捕获网络数据包的库,它提供了一个通用的接口,可以在不同的平台上使用。

过滤规则是在捕获数据包时指定的条件,用于过滤出符合特定条件的数据包。

这些过滤规则基于一种叫做BPF(Berkley Packet Filter)的语言。

以下是一些常见的`libpcap` 过滤规则的例子:1. 过滤特定主机的流量:```host 192.168.1.1```2. 过滤特定网络的流量:n```net 192.168.1.0/24```3. 过滤特定端口的流量:```port 80```4. 过滤源或目标端口是特定端口的流量:```src port 1024dst port 80```5. 过滤特定协议的流量:```tcpudp```6. 组合条件,过滤特定源IP和目标端口的TCP流量:```src host 192.168.1.2 and tcp dst port 22```7. 过滤非常量字符串的流量:```udp and not port 53```8. 过滤特定协议的流量并限制数据包大小:```icmp and less 100```这些规则是基于BPF 语法的,因此你可以根据需要组合不同的条件。

在使用这些规则时,可以通过调用`pcap_compile` 来编译规则,然后将生成的过滤器传递给`pcap_setfilter` 函数。

这样就可以在捕获数据包时应用特定的过滤规则。

请注意,BPF 过滤规则的语法可能因`libpcap` 版本而异,因此最好参考相应版本的文档以获取详细信息。

网络嗅探器Sniffer软件源代码浅析3采用Libpcap库的通用设计

网络嗅探器Sniffer软件源代码浅析3采用Libpcap库的通用设计
【Key words]BSD packet filte吖BPF);Libpcap;Sniffer
l概述 I,ibpcap实质上是一个系统独立的API函数接121,用于用
户层次的数据包截获工作。它为底层网络监控编程提供了一 个易于移植的应用框架,这些底层网络应用包括网络数据收 集、安全监控和网络调试等。洛仓兹伯克利国家实验室 (Lawrence Berkeley National Laboratow)编写这些API函数库 的最初目的就是为了统一不同系统上所提供的用于数据包截 获的不同类型接口,井使得类似的高层应用程序的编写和移 植工作变得简单有效,不再需要对每一个应用都使用不同的 依赖于具体系统的数据包截获模块。同时,该API函数接口 在保持基本稳定的基础上,还在不断地进行更新和升级。
/+ptr to fonc that processes
packet for j dcvice’/
14.ant main()
lS{
16.11_char‘userdata; 17.userdata=NULL:
——64——
18.ent=一1: 19.P Open the pcap device for snifring。, 20.open—pcap0; 21.dev—prcsr=(pcap func t)dump ethcruet: 22.p Read all packeis on the device.Contiulie until cnt packets read+, 23.ir(pcap_loop(pd-cut,dev—presr.userdata)‘01
42.void dump_ethernet(u_char+u set,coust struet pcap pkthdr+h,ii_char+P)

pcap文件的python解析实例

pcap文件的python解析实例

文章标题:深度解析——pcap文件的python解析实例1. 引言在网络安全和数据分析领域,pcap文件是一种常见的数据格式,用于存储网络数据包。

通过解析pcap文件,我们可以深入分析网络通信的细节,从而识别潜在的安全威胁或者进行网络性能优化。

在本文中,将通过一个具体的python解析实例,深入探讨pcap文件的结构和解析方法,帮助我们更好地理解网络数据交互过程。

2. pcap文件的定义和结构2.1 pcap文件是一种网络数据包文件格式,用于记录在计算机网络上收发的数据包,可以被网络数据包捕获软件(如Wireshark、Tcpdump)所生成。

2.2 pcap文件包括全局文件头和数据包头部分。

全局文件头描述了整个pcap文件的基本信息,如魔数、版本号、时间戳精度等;数据包头则描述了每个数据包的详细信息,如时间戳、捕获长度、实际长度等。

3. python解析pcap文件的工具3.1 Scapy是一款功能强大的python网络数据包操作库,支持解析和创建各种类型的网络数据包,包括pcap文件。

3.2 通过Scapy库中的rdpcap函数,我们可以轻松读取pcap文件并将其转换为数据包列表,方便后续的解析和分析。

4. pcap文件解析实例4.1 使用Scapy库中的rdpcap函数读取指定的pcap文件,并将其存储为数据包列表。

4.2 针对数据包列表,可以逐个遍历数据包,并通过Scapy提供的方法获取数据包的详细信息,如源IP位置区域、目标IP位置区域、协议类型、数据长度等。

4.3 可以进一步对数据包进行过滤和筛选,以便针对特定的网络通信进行深入分析。

5. 总结与展望5.1 通过以上实例,我们深入了解了pcap文件的结构和python解析方法,为进一步的网络数据包分析打下了基础。

5.2 随着网络安全和数据分析领域的不断发展,pcap文件的解析和利用将变得更加重要,我们可以进一步探索基于pcap文件的网络行为分析、异常检测等应用。

libpcap编程实例

libpcap编程实例

libpcap编程实例1 #include <stdio.h>2 #include <stdlib.h>3 #include <pcap.h>4 #include <errno.h>5 #include <sys/socket.h>6 #include <netinet/in.h>7 #include <arpa/inet.h>89int main(int argc, char **argv)10 {11char *dev;12char *net;13char *mask;14int ret;15char errbuf[PCAP_ERRBUF_SIZE];16 bpf_u_int32 netp;17 bpf_u_int32 maskp;18struct in_addr addr;192021 dev = pcap_lookupdev(errbuf);222324if(dev == NULL)25 {26 printf("%s\n",errbuf);27 exit(1);28 }293031 printf("DEV: %s\n",dev);323334 ret = pcap_lookupnet(dev,&netp,&maskp,errbuf);3536if(ret == -1)37 {38 printf("%s\n",errbuf);39 exit(1);40 }414243 addr.s_addr = netp;44 net = inet_ntoa(addr);4546if(net == NULL)47 {48 perror("inet_ntoa");49 exit(1);50 }5152 printf("NET: %s\n",net);535455 addr.s_addr = maskp;56 mask = inet_ntoa(addr);5758if(mask == NULL)59 {60 perror("inet_ntoa");61 exit(1);62 }6364 printf("MASK: %s\n",mask);6566return0;67 }68然后gcc -o pcap_1 pcap_1.c -lpcap(⼀定要-lpcap参数)69编译ok~,执⾏./pcap_1,可以看到:70 DEV: eth071 NET: 192.168.12.072 MASK: 255.255.255.073好了,第⼀个pcap程序出炉了。

Libcap的简介及安装

Libcap的简介及安装

Libcap的简介及安装Libpcap 简介https:///zhangdaicong/p/7709998.html https:///a_ran/article/details/45285575libpcap 是unix/linux 平台下的网络数据包捕获函数包,大多数网络监控软件都以它为基础。

Libpcap 可以在绝大多数类unix 平台下工作.Libpcap 应用程序框架Libpcap 提供了系统独立的用户级别网络数据包捕获接口,并充分考虑到应用程序的可移植性。

Libpcap可以在绝大多数类unix 平台下工作,在windows 平台下,一个与libpcap 很类似的函数包 winpcap 提供捕获功能,其官方网站是/ 。

Libpcap 软件包可从 / 下载,然后依此执行下列三条命令即可安装,但如果希望libpcap 能在linux 上正常工作,则必须使内核支持"packet" 协议,也即在编译内核时打开配置选项CONFIG_PACKET( 选项缺省为打开) 。

./configure --host=arm-linux-gnueabihf --prefix=/home/xiaopf/tools/libpcap-1.10.1/output-arm ./make./make installlibpcap 源代码由20 多个C 文件构成,但在 Linux 系统下并不是所有文件都用到。

可以通过查看命令make 的输出了解实际所用的文件。

本文所针对的libpcap 版本号为1.1.1 ,网络类型为常规以太网。

Libpcap应用程序从形式上看很简单.Libpcap 安装以下命令适用于 ubuntu 等 deb 包管理式 linux 系统,如果是 Fedora 或 RedHat 以及 SUSE 等基於 RPM 包管理的 linux 系统可用 yum install 代替 apt-get install1. 安装 gcc g++ 编译器命令: sudo apt-get install build-essentialC 语言经典的入门例子是 *Hello World ,下面是一示例代码:#include <stdio.h>int main(void){printf("Hello, world!/n");return 0;}我们假定该代码存为文件'hello.c’。

基于Libpcap的业务分类路由技术及实现

基于Libpcap的业务分类路由技术及实现
21 0 1年 第 8期

个 包就 调 用另 一个 已经 定义 好 的 函数 ( 为 回调 称
客户 端机 写 入的不 同分类信 息 , 如各 分类 数据 流量 、 所 占总 流量 比例 等数 据信 息 。
实 验室 环境 下 , 务 识别 机 的 e 0网 口连接 服 业 t h
函数 ) 这个 函数 可 以做我 们想 要 的任何 工作 。具体 , 的描 述 详见 Lb cp实 现部 分 。 ip a
客户端 1
eh t2 e hl t
客户端 2
eh t2 eh t0
数 据 库
ehl t
睾Il l l ) 而
3 7
21 0 1年 第 8期
网帧 , 个 以太 网 帧包 含 了 目的地址 、 一 源地 址 、 据 数 类型、 数据字 段及 帧检 验序 列几 个部 分 。 类型用 以 帧 判 断 所携 带 的是 哪 种数 据 包 ,常 用 的有 0 0 8 ( x 00 I P
_

(e l U SL , 1r u ;ec_ t2 p a _ p n l e dv , F I O -,r 0d sre = c p o e i B eb h v
客尸端2
图 1 分 类 业 务路 由 系统 网络 环 境
其中, 标示 “ 业务 识 别 ” 主机 主 要 用来 识 别 来 的 自网络 的原 始数据 流 .将识 别 出来 的业 务按 类 型分 类并 在 数 据 包 的 T OS字 段 作 上 相应 标 记 后 发 给 服 务器 进行 后续 处理 。 文 的主要 工作 在 于服 务器 端 , 本 服务 器端 接 收到识 别 后 的数据 流后 按 照前 已标记 的
25 . 525 . 525 . 50 25 .5525 0 52 . 5. 25 . 5 2 50 525 . 5 . 25 .552 5. 52 .5 0 2 5 2 5 2 5. 5 .5 .5 0 2 52 52 50 5 .5 .5 .

libpcap常用的几个函数简介

libpcap常用的几个函数简介

libpcap是数据包捕获函数库。

该库提供的C函数接口可用于需要捕获经过网络接口数据包的系统开发上。

著名的TCPDUMP就是在libpcap的基础上开发而成的。

libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。

这个库为不同的平台提供了一致的编程接口,在安装了libpcap的平台上,以libpcap为接口写的程序,能够自由的跨平台使用。

利用libpcap函数库开发应用程序的基本步骤以及几个关键的函数使用方法简介如下:1. char *pcap_lookupdev(char *errbuf)该函数用于返回可被pcap_open_live()或pcap_lookupnet()函数调用的网络设备名(一个字符串指针)。

如果函数出错,则返回NULL,同时errbuf中存放相关的错误消息。

2. int pcap_lookupnet(char *device, bpf_u_int32 *netp,bpf_u_int32 *maskp, char *errbuf)获得指定网络设备的网络号和掩码。

netp参数和maskp参数都是bpf_u_int32指针。

如果函数出错,则返回-1,同时errbuf中存放相关的错误消息。

Bpf_u_int32:32位无符号数Struct in_addr{unsigned long s_addr;}inet_ntoa();以a.b.c.d的形式显示地址。

3.打开网络设备pcap_t *pcap_open_live(char *device, int snaplen,int promisc,int to_ms,char *ebuf)获得用于捕获网络数据包的数据包捕获描述字。

device参数为指定打开的网络设备名。

snaplen参数定义捕获数据的最大字节数,65535是最大值。

promisc指定是否将网络接口置于混杂模式,设置为1表示混杂模式。

to_ms参数指定超时时间(毫秒),设置为0表示超时时间无限大。

黑马程序员:网络编程高级应用—— libpcap 详解

黑马程序员:网络编程高级应用—— libpcap 详解

[C/C++]网络编程高级应用——libpcap 详解概述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() 和pc 包。

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 存放出错信息字符串。

tcpdump原理之利用libpcap实现抓包

tcpdump原理之利用libpcap实现抓包

tcpdump原理之利⽤libpcap实现抓包tcpdump原理之利⽤libpcap实现(转载请标明出处,请勿⽤于商业⽤途)/linux_embedded/article/details/8826429Linux下赫赫有名的抓吧⼯具tcpdump,想必使⽤过的⼈都⼗分的清楚。

但是,其实现的原理却很少⼈提及过,今天就tcpdump的实现原理做简单的介绍。

tcpdump ⾸先利⽤libpcap⼯具,将linux⽹络栈中的数据包抓取上来,然后,tcpdump在按照⽤户的需求完成数据包的分析⼯作。

下⾯就如何通过libpcap实现数据包的抓取做简单的介绍。

开始:libpcap的使⽤⽅式⾸先,我们需要了解⼀下pcap 嗅探器使⽤的⼀般布局,下⾯分为⼏个部分简单介绍。

1. ⾸先我们需要定义我们需要使⽤的⽹络接⼝。

在linux下,我们⼀般会定义eth0或ethx。

在BSD下,可能是xl1。

我们可以把⽹络接⼝定义为字符串,或者可以通过pcap获得可⽤的⽹络接⼝的名字。

2. 初始化pcap。

现在,我们可以将我们将要监听的⽹络设备告诉pcap。

如果有需要的话,我们可以使pcap同时监听多个⽹络接⼝。

我们可以通过“⽂件句柄”来区分不同的⽹络接⼝,就像我们打开⽂件进⾏⽂件的读取、写⼊⼀样,我们必须定义区分我们的监听“回话”,否则我们没有办法区分不同的监听对象(⽹络设备)。

3. 如果我们仅仅想监听特殊的⽹络数据(例如,我们想监听TCP业务,或者我们只想监听端⼝号为23的业务)。

我们可以⾃⼰定义⼀个监听规则的集合,“编译”它,然后在应⽤它。

上⾯三个步骤,连接的⼗分紧密,那⼀个步骤都不能丢掉。

规则其实就是定义好的字符串,我们需要将其转化为pcap可以是别的格式(所以我们需要编译)。

“编译器”仅仅通过内置的函数就可以实现上述的格式转换。

然后我们可以告诉pcap执⾏规则完成数据包的过滤。

4. 之后,我们会告诉pcap进⼊主要的循环执⾏状态。

libpcap原理及优化

libpcap原理及优化
libpcap根据帧大小按顺序读 取缓存区.如果当前帧的数据有 效位被设置,则将该数据包提交 给应用程序处理,在处理完毕以 后,libpcap清除当前帧的有效 位,允许内核再次使用该帧;否 则,libpcap使用poll函数等待数 据包的到达。
相比libpcap1.0之前版本,共享内存缓存队列减少了一次数据包拷贝和调 用recvmsg、退出内核态的系统开销,因此有较大的性能提升
Libpcap原理及优化
Mail : Author : panda-bob
Linux数据包处理流程
具体的Linux数据包处理流程如图 1所示。数据包从网卡经过内核最终 到达用户空间的应用程序,其中经过 三次处理:中断服务、软中断和应用 程序。使用三个缓存:DMA、包队列 和插口。在网卡驱动中存在运行时内 存分配,从内核到用户态时存在一次 内存拷贝。
限制系统数据包的捕获处理能力可能原 因
① 处理流程单一:整个处理流程串行化,其处理能力受限于整个流程的 任何一处“短板”。在多核架构系统中这样的处理方式无法发挥并行 优势,存在极大的资源浪费。
② 高中断服务负荷:由于采用每接收一个数据包就产生一次中断的方式, 当数据包以很高的速率到达时,即使最快的处理器也会被持续的中断 服务请求占用而无法处理数据包,从而导致数据包丢失。
PACKET套接字的两大核心模块
1、BPF(berkeley packet filter)过滤器 BPF根据用户设置的过滤规则计算应该接收的数据包长度值,如果该值比数
据包的长度小,那么数据包将会被截短.特别地,如果该值为0,数据包会被 PACKET套接字丢弃而直接返回协议栈进行网络层的处理.BPF在Linux中,BPF被 用于内核进行数据包过滤,以减小提交给应用程序的数据包的包数和字节数,提 高系统性能。 2、缓存队列(BufferQ)

libpcap报文解析:ipv4、ipv6@2014.7.2

libpcap报文解析:ipv4、ipv6@2014.7.2

libpcap报⽂解析:ipv4、ipv6@2014.7.21 #include <string.h>2 #include <stdlib.h>3 #include <pcap.h>4 #include <stdio.h>5 #include <sys/time.h>6 #include <unistd.h>7 #include <netinet/in.h>8 #include <pthread.h>9 #include "packet_header.h"10 #include <iostream>11 #include <string>12using namespace std;1314#define MAXBYTE2CAPTURE 20481516 pthread_t g_thread[2];17 pthread_mutex_t g_mutex;1819int isprint(char c)20 {21return0;22 }2324void print_buf(u_char* pBuf, u_int32 len)25 {26if (!pBuf)27 {28return;29 }3031for(int i=0; i<len; i++)32 {33 printf("%02x ", (u_char*)pBuf[i]);3435if ((i%16 == 0 && i!=0) || i == len-1)36 {37 printf("\r\n");38 }39 }40 }4142void parse_ethII(u_char* pData, u_int32 len)43 {44if (!pData || len <14)45 {46return;47 }4849 printf("eth II frame: \r\n");50 print_buf(pData, 14);5152/* parse src mac and dst mac */53 EthHeader_t* pEth = (EthHeader_t*)pData;54 printf("destination: %02x:%02x:%02x:%02x:%02x:%02x ",55 pEth->dest_hwaddr[0],56 pEth->dest_hwaddr[1],57 pEth->dest_hwaddr[2],58 pEth->dest_hwaddr[3],59 pEth->dest_hwaddr[4],60 pEth->dest_hwaddr[5]);6162 printf("source : %02x:%02x:%02x:%02x:%02x:%02x",63 pEth->source_hwaddr[0],64 pEth->source_hwaddr[1],65 pEth->source_hwaddr[2],66 pEth->source_hwaddr[3],67 pEth->source_hwaddr[4],68 pEth->source_hwaddr[5]);6970/* parse frame type */71 printf("\r\nframe type: 0x%x\r\n", ntohs(pEth->frame_type));72 }737475void parse_ipheader(u_char* pData, u_int32 len)76 {77if (!pData || len <14)78 {79return;80 }8182 printf("ip header: \r\n");83 print_buf(pData, 20);8485/* parse ip header */86 IPHeader_t* pIpHeader = (IPHeader_t*)pData;87 printf("\tversion : %02x\r\n"88"\ttos : %02x\r\n"89"\ttotal length: %d(0x%02x)\r\n"90"\tid : %d(0x%02x)\r\n"91"\tsegment flag: %d(0x%02x)\r\n"92"\tttl : %02x\r\n"93"\tprotocol : %02x\r\n"94"\tchecksum : %d(0x%02x)\r\n"95"\tsrc ip : %d.%d.%d.%d\r\n"96"\tdst ip : %d.%d.%d.%d\r\n",97 pIpHeader->Ver_HLen,98 pIpHeader->TOS,99 ntohs(pIpHeader->TotalLen), ntohs(pIpHeader->TotalLen),100 ntohs(pIpHeader->ID), ntohs(pIpHeader->ID),101 ntohs(pIpHeader->Flag_Segment), ntohs(pIpHeader->Flag_Segment),102 pIpHeader->TTL,103 pIpHeader->Protocol,104 ntohs(pIpHeader->Checksum), ntohs(pIpHeader->Checksum),105 pIpHeader->SrcIP[0],pIpHeader->SrcIP[1],pIpHeader->SrcIP[2],pIpHeader->SrcIP[3], 106 pIpHeader->DstIP[0],pIpHeader->DstIP[1],pIpHeader->DstIP[2],pIpHeader->DstIP[3]); 107 }108109void parse_ip6header(u_char* pData, u_int32 len)110 {111if (!pData || len <14)112 {113return;114 }115116 printf("ipv6 header: \r\n");117 print_buf(pData, 40);118119/* parse ipv6 header */120 IPv6Header_t* pIpv6Header = (IPv6Header_t*)pData;121 printf("\tversion : %x\r\n"122"\ttraffic class : %x\r\n"123"\tflow label : %x\r\n"124"\tpayload length : %x\r\n"125"\tnext header : %x\r\n"126"\thop limit : %x\r\n"127"\tsource : %x\r\n"128"\tdestination : %x\r\n",129 pIpv6Header->ip6_ctlun.ip6_un2_vfc,130 pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_flow,131 pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_flow,132 pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_plen,133 pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_nxt,134 pIpv6Header->ip6_ctlun.ip6_unl.ip6_unl_hlim,135 pIpv6Header->ip6_src,136 pIpv6Header->ip6_dst);137 }138139140void parse_packet(const u_char* packet, u_int32 len)141 {142 u_short ftype = 0;143144if (!packet)145 {146return ;147 }148149 u_char* pMbuf = (u_char*)packet;150 parse_ethII(pMbuf, len);151152 ftype = ntohs(((EthHeader_t*)pMbuf)->frame_type);153switch(ftype)154 {155case0x0800: /* ipv4 */156 pMbuf = (u_char*)packet + 14;157 parse_ipheader(pMbuf, len-14);158break;159case0x86dd: /* ipv6 */160 pMbuf = (u_char*)packet + 14;161 parse_ip6header(pMbuf, len-14);162break;163default:164 printf("frame type : 0x%x\r\n", ftype);165break;166 }167168 printf("\r\n");169 }170171void processPacket(u_char *arg, const struct pcap_pkthdr *pkthdr, const u_char *packet) 172 {173int i = 0, *counter = (int *)arg;174175 printf("--------------------------------------------\r\n");176 printf("Packet Count: %d\n", ++(*counter));177 printf("Received Packet Size: %d\n", pkthdr->len);178 printf("Payload:\n");179180#if 1181for (i = 0; i < pkthdr->len; i++)182 {183if (isprint(packet[i]))184 {185 printf("%02d ", packet[i]);186 }187else188 {189 printf("%02x ", packet[i]);190 }191192if ((i % 16 == 0 && i != 0) || i == pkthdr->len-1)193 {194 printf("\n");195 }196197 }198#endif199200 parse_packet(packet, pkthdr->len);201202return;203 }204205206void* thread_recv_pkt(void *)207 {208while(1)209 {210 cout << "recv pkt: " << endl;211 sleep(1);212 }213 }214215void* thread_send_pkt(void *)216 {217while (1)218 {219 cout << "send pkt: " << endl;220 sleep(1);221 }222 }223224int create_pkt_process_task()225 {226int ret = 0;227228 memset(&g_thread, 0, sizeof(g_thread));229230 ret = pthread_create(&g_thread[0], NULL, thread_send_pkt, NULL);231if (0 == ret)232 {233 cout << "packet send thread create successfully." << endl;234 }235else236 {237 cout << "packet send thread create failed." << endl;238 }239240 ret = pthread_create(&g_thread[1], NULL, thread_recv_pkt, NULL);241if (0 == ret)242 {243 cout << "packet send thread create successfully." << endl;244 }245else246 {247 cout << "packet send thread create failed." << endl;248 }249250return0;251 }252253void pkt_process_task_wait()254 {255if(g_thread[0] !=0)256 { //comment4257 pthread_join(g_thread[0],NULL);258 printf("线程1 已经结束\n");259 }260261if(g_thread[1] !=0)262 { //comment5263 pthread_join(g_thread[1],NULL);264 printf("线程2 已经结束\n");265 }266 }267268int main()269 {270271int i = 0, count = 0;272 pcap_t *descr = NULL;273char errbuf[PCAP_ERRBUF_SIZE], *device = NULL;274275 memset(errbuf, 0, PCAP_ERRBUF_SIZE);276277 create_pkt_process_task();278 pkt_process_task_wait();279280/* Get the name of the first device suitable for capture */281 device = pcap_lookupdev(errbuf);282if (!device)283 {284 printf("Open device failed.");285return -1;286 }287288 printf("Opening device %s\n", device);289290/* Open device in promiscuous mode */291 descr = pcap_open_live(device, MAXBYTE2CAPTURE, 1, 512, errbuf); 292293/* Loop forever & call processPacket() for every received packet */ 294 pcap_loop(descr, -1, processPacket, (u_char *)&count);295296return0;297 }。

CentOS安装libpcap

CentOS安装libpcap

CentOS安装libpcap1.安装GCC:yum -y install gcc-c++2.安装flex:yum -y install flex没有flex,直接安装libpcap会提⽰"Your operating system's lex is insufficient to compile libpcap"错误;3.安装bisonyum -y install bison前⾯安装的是flex,就需要搭配bison,如不会提⽰"don't have both flex and bison;reverting to lex/yacc"错误;解压软件包:tar zxf libpcap-1.0.0.tar.gz进⼊解压后的⽬录,输⼊命令⾏:命令如下:./configuremakemake install5.简单的例⼦测试⼀下libpcap://device.c#include <stdio.h>#include <pcap.h>int main(int argc,char *argv[]){char *dev, errbuf[PCAP_ERRBUF_SIZE];dev=pcap_lookupdev(errbuf);if(dev==NULL){fprintf(stderr,"couldn't find default device: %s\n",errbuf);return(2);}printf("Device: %s\n",dev);return(0);}编译指令:gcc -o device device.c -lpcap备注:编译时要使⽤libpcap的参数-lpcap,否则会提⽰“pcap_lookupdev 未定义的引⽤”的错误;运⾏指令:./device运⾏遇到错误解决办法://-----------------------------------------------------------//AUTHOR:lanyang123456//DATE:2011-11-10//-----------------------------------------------------------Linux系统下,运⾏sniff程序需要libpcap库。

libpcap函数

libpcap函数

libpcap函数1)ioctl函数定义ioctl()函数非常庞杂,它可以控制各种文件的属性。

ioctl函数原型为:int ioctl(int handle,int cmd[,int *argdx,int argcx]);2)socket函数定义常用的Socket类型有两种:流式Socket(SOCK_STREAM)和数据包式Socket(SOCK_DGRAM)。

流式是一种面向连接的Socket,针对面向连接的TCP服务应用;数据报式Socket是一种无连接的Socket,针对无连接的UDP服务应用。

Socket函数原型为:int socket(int domain, int type,int protocol);3)recvfrom()函数定义用recvfrom()函数来实现接收数据包,recvfrom()是具备“阻塞式I/O”特性的函数,能够在没有数据包到达的情况下暂时挂起等待,直至接收到数据包后,再激活转入下一步处理。

recvfrom()函数的原型为:int recvfrom(SOCKET s,char FAR *buf,int len,int flags,structsockaddr FAR *from,int *fromlen);本函数从已连接套接口上接收数据,并捕获数据发送源的地址。

对于SOCK_STREAM类型的套接口,最多可以接收缓冲区大小个数据。

如果套接口被设置为线内接收带外数据(选项为 SO_OOBINLINE),且有带外数据未读入,则返回带外数据。

应用程序可通过调用ioctlsocket()的SOCATMARK命令来确定是否有带外数据待读入。

对于SOCK_STREAM类型套接口,忽略from和fromlen参数。

因为面向连接的话不用再指定地址了。

4)一些“字节顺序”转换函数因为网络和主机采用的存储字节时内存顺序安排方式的差异,就存在“字节顺序”的问题。

在网络环境下存储时,高位字节存放在内存的起始位置,而低字节则存放在较高的位置。

解决libpcap出现undefinedreference问题

解决libpcap出现undefinedreference问题

解决libpcap出现undefinedreference问题我测试 libpcap 的源码void parse_pacp(){char errbuf[PCAP_ERRBUF_SIZE] = ""; // PCAP_ERRBUF_SIZE 为 512 字节// const char* dir = "****";pcap_t *pcap_ptr = pcap_open_offline( dir, errbuf);if(!pcap_ptr)cout << " open pcap file faied ~" << endl;elsecout << " open pcap file success ~ " << endl;pcap_close(pcap_ptr);}执⾏ parse_pcap 函数会报错:undefined reference to `pcap_open_offline'undefined reference to `pcap_close'明显链接时问题,查了相关问题后基本上都是在编译运⾏命令后加上参数 -lpcap就⾏,即:g++ pcap_ -o pcap_parse -lpcap注意: -lpcap 要加在最后⾯,同时也可以通过 -L参数指定位置,不过没必要由于我在 ubuntu 下都是⽤的 vscode,⽽ vscode 可以通过 tasks.json 配置编译运⾏时命令的组成情况,因此我直接将 -lpcap 加在该项⽬的 task.json 中,vscode 直接执⾏成功。

// ubuntu{"version": "2.0.0","tasks": [{"type": "shell","label": "g++ build active file","command": "/usr/bin/g++","args": ["-g","${file}","-o","${fileDirname}/${fileBasenameNoExtension}","-lpcap"],"options": {"cwd": "/usr/bin"},"problemMatcher": ["$gcc"],"group": {"kind": "build","isDefault": true}}]}参考⽂档:。

pcap2socks原理

pcap2socks原理

pcap2socks原理pcap2socks是一种网络流量转发工具,它是基于Linux上的Libpcap和Libnet库开发而成的。

其主要功能是将抓取到的网络数据包转发给指定的代理服务器,使得网络数据可以经过代理服务器进行进一步处理。

第一步是抓包。

pcap2socks使用Libpcap库来进行网络数据包抓取。

Libpcap库是一个用于捕获网络数据包的库,它能够从网络接口上捕获数据包,并将其存储为pcap文件格式。

pcap2socks通过使用Libpcap库来打开指定的网络接口,并设置过滤规则来只捕获特定的网络数据包。

一旦网络数据包被捕获,pcap2socks就会将其存储在内存中等待进一步的处理。

第二步是数据处理。

一旦网络数据包被抓取,pcap2socks会对其进行解析和处理。

首先,pcap2socks会根据数据包的协议类型(如TCP、UDP等)解析出源IP地址、目标IP地址、源端口号和目标端口号等信息。

然后,pcap2socks会根据用户提供的代理服务器地址和端口号,创建一个与代理服务器的网络连接。

接着,pcap2socks会将解析出的源IP地址、目标IP地址、源端口号和目标端口号等信息封装成一个新的数据包,并使用Libnet库发送给代理服务器。

第三步是数据转发。

一旦新的数据包被发送给代理服务器,它就会根据协议类型和目标IP地址、目标端口号等信息进行进一步的处理。

例如,如果数据包的协议类型是TCP,代理服务器就会尝试与目标服务器建立一个TCP连接,并将数据包转发给目标服务器。

类似地,如果数据包的协议类型是UDP,代理服务器就会将数据包封装成一个新的UDP数据包,并发送给目标服务器。

代理服务器还可以对数据包进行加密、解密、压缩等处理,以提高数据传输的安全性和效率。

总结起来,pcap2socks的原理是利用Libpcap库进行网络数据包抓取,通过解析、处理和封装网络数据包,将其转发给指定的代理服务器进行进一步处理。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

libpcap详解libpcap(Packet Capture Library),即数据包捕获函数库,是Unix/Linux平台下的网络数据包捕获函数库。

它是一个独立于系统的用户层包捕获的API接口,为底层网络监测提供了一个可移植的框架。

(通过将网卡设置为混杂模式,可以捕获所有经过该网络接口的数据包)的数据包。

一、libpcap工作原理:libpcap主要由两部份组成:网络分接头(Network Tap)和数据过滤器(Packet Filter)。

网络分接头从网络设备驱动程序中收集数据拷贝,过滤器决定是否接收该数据包。

Libpcap利用BSD Packet Filter(BPF)算法对网卡接收到的链路层数据包进行过滤。

BPF算法的基本思想是在有BPF监听的网络中,网卡驱动将接收到的数据包复制一份交给BPF过滤器,过滤器根据用户定义的规则决定是否接收此数据包以及需要拷贝该数据包的那些内容,然后将过滤后的数据给与过滤器相关联的上层应用程序。

libpcap的包捕获机制就是在数据链路层加一个旁路处理。

当一个数据包到达网络接口时,libpcap首先利用已经创建的Socket 从链路层驱动程序中获得该数据包的拷贝,再通过Tap函数将数据包发给BPF过滤器。

BPF过滤器根据用户已经定义好的过滤规则对数据包进行逐一匹配,匹配成功则放入内核缓冲区,并传递给用户缓冲区,匹配失败则直接丢弃。

如果没有设置过滤规则,所有数据包都将放入内核缓冲区,并传递给用户层缓冲区。

一个包捕获机制包含三个主要部分,分别是面向底层的包捕获引擎,面向中间层的数据包过滤器,面向应用层的用户接口。

对应用程序而言,Libpcap包捕获机制只是提供了一个统一的API接口,用户只需要按照相关的编程流程,简单地调用若干函数就可以捕获到感兴趣的数据包。

二、libpcap的抓包框架pcap_lookupdev()函数用于查找网络设备,返回可被pcap_open_live()函数调用的网络设备名指针。

pcap_open_live()函数用于打开网络设备,并且返回用于捕获网络数据包的数据包捕获描述字。

对于此网络设备的操作都要基于此网络设备描述字。

pcap_lookupnet()函数获得指定网络设备的网络号和掩码。

pcap_compile()函数用于将用户制定的过滤策略编译到过滤程序中。

pcap_setfilter()函数用于设置过滤器。

pcap_loop()函数pcap_dispatch()函数用于捕获数据包,捕获后还可以进行处理,此外pcap_next()和pcap_next_ex()两个函数也可以用来捕获数据包。

pcap_close()函数用于关闭网络设备,释放资源。

其实pcap的应用程序格式很简单,总的来说可以可以分为以下5部分,相信看了以下的5部分,大概能对pcap的总体布局有个大概的了解了吧:1.我们从决定用哪一个接口进行嗅探开始。

在Linux中,这可能是eth0,而在BSD系统中则可能是xl1等等。

我们也可以用一个字符串来定义这个设备,或者采用pcap提供的接口名来工作。

2.初始化pcap。

在这里我们要告诉pcap对什么设备进行嗅探。

假如愿意的话,我们还可以嗅探多个设备。

怎样区分它们呢?使用文件句柄。

就像打开一个文件进行读写一样,必须命名我们的嗅探“会话”,以此使它们各自区别开来。

3.假如我们只想嗅探特定的传输(如TCP/IP包,发往端口23的包等等),我们必须创建一个规则集合,编译并且使用它。

这个过程分为三个相互紧密关联的阶段。

规则集合被置于一个字符串内,并且被转换成能被pcap读的格式(因此编译它)。

编译实际上就是在我们的程序里调用一个不被外部程序使用的函数。

接下来我们要告诉pcap使用它来过滤出我们想要的那一个会话。

4.最后,我们告诉pcap进入它的主体执行循环。

在这个阶段内pcap一直工作到它接收了所有我们想要的包为止。

每当它收到一个包就调用另一个已经定义好的函数,这个函数可以做我们想要的任何工作,它可以剖析所部获的包并给用户打印出结果,它可以将结果保存为一个文件,或者什么也不作。

5.在嗅探到所需的数据后,我们要关闭会话并结束。

三、实现libpcap的每一个步骤(1)设置设备这是很简单的。

有两种方法设置想要嗅探的设备。

第一种,我们可以简单的让用户告诉我们。

考察下面的程序:#include#includeint main(int argc, char *argv[]){char *dev = argv[1];printf("Device: %s", dev);return(0);}用户通过传递给程序的第一个参数来指定设备。

字符串“dev”以pcap能“理解”的格式保存了我们要嗅探的接口的名字(当然,用户必须给了我们一个真正存在的接口)。

另一种也是同样的简单。

来看这段程序:#include#includeint main(){char *dev, errbuf[PCAP_ERRBUF_SIZE];dev = pcap_lookupdev(errbuf);printf("Device: %s", dev);return(0);}(2)打开设备进行嗅探创建一个嗅探会话的任务真的非常简单。

为此,我们使用pcap_open_live()函数。

此函数的原型(根据pcap的手册页)如下:pcap_t *pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)其第一个参数是我们在上一节中指定的设备,snaplen是整形的,它定义了将被pcap捕捉的最大字节数。

当promisc设为true时将置指定接口为混杂模式(然而,当它置为false时接口仍处于混杂模式的非凡情况也是有可能的)。

to_ms是读取时的超时值,单位是毫秒(假如为0则一直嗅探直到错误发生,为-1则不确定)。

最后,ebuf是一个我们可以存入任何错误信息的字符串(就像上面的errbuf)。

此函数返回其会话句柄。

混杂模式与非混杂模式的区别:这两种方式区别很大。

一般来说,非混杂模式的嗅探器中,主机仅嗅探那些跟它直接有关的通信,如发向它的,从它发出的,或经它路由的等都会被嗅探器捕捉。

而在混杂模式中则嗅探传输线路上的所有通信。

在非交换式网络中,这将是整个网络的通信。

这样做最明显的优点就是使更多的包被嗅探到,它们因你嗅探网络的原因或者对你有帮助,或者没有。

但是,混杂模式是可被探测到的。

一个主机可以通过高强度的测试判定另一台主机是否正在进行混杂模式的嗅探。

其次,它仅在非交换式的网络环境中有效工作(如集线器,或者交换中的ARP层面)。

再次,在高负荷的网络中,主机的系统资源将消耗的非常严重。

(3)过滤通信实现这一过程由pcap_compile()与pcap_setfilter()这两个函数完成。

在使用我们自己的过滤器前必须编译它。

过滤表达式被保存在一个字符串中(字符数组)。

其句法在tcpdump的手册页中被证实非常好。

我建议你亲自阅读它。

但是我们将使用简单的测试表达式,这样你可能很轻易理解我的例子。

我们调用pcap_compile()来编译它,其原型是这样定义的:int pcap_compile(pcap_t *p, strUCt bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask)第一个参数是会话句柄。

接下来的是我们存储被编译的过滤器版本的地址的引用。

再接下来的则是表达式本身,存储在规定的字符串格式里。

再下边是一个定义表达式是否被优化的整形量(0为false,1为true,标准规定)。

最后,我们必须指定应用此过滤器的网络掩码。

函数返回-1为失败,其他的任何值都表明是成功的。

表达式被编译之后就可以使用了。

现在进入pcap_setfilter()。

仿照我们介绍pcap的格式,先来看一看pcap_setfilter()的原型:int pcap_setfilter(pcap_t *p, struct bpf_program *fp)这非常直观,第一个参数是会话句柄,第二个参数是被编译表达式版本的引用(可推测出它与pcap_compile()的第二个参数相同)。

下面的代码示例可能能使你更好的理解:#includepcap_t *handle; /* 会话的句柄*/char dev[] = "eth0"; /* 执行嗅探的设备*/char errbuf[PCAP_ERRBUF_SIZE]; /* 存储错误信息的字符串*/struct bpf_program filter; /*已经编译好的过滤表达式*/char filter_app[] = "port 23"; /* 过滤表达式*/bpf_u_int32 mask; /* 执行嗅探的设备的网络掩码*/bpf_u_int32 net; /* 执行嗅探的设备的IP地址*/pcap_lookupnet(dev, &net, &mask, errbuf);handle = pcap_open_live(dev, BUFSIZ, 1, 0, errbuf);pcap_compile(handle, &filter, filter_app, 0, net);pcap_setfilter(handle, &filter);这个程序使嗅探器嗅探经由端口23的所有通信,使用混杂模式,设备是eth0。

(4)实际的嗅探有两种手段捕捉包。

我们可以一次只捕捉一个包,也可以进入一个循环,等捕捉到多个包再进行处理。

我们将先看看怎样去捕捉单个包,然后再看看使用循环的方法。

为此,我们使用函数pcap_next()。

pcap_next()的原型及其简单:u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)第一个参数是会话句柄,第二个参数是指向一个包括了当前数据包总体信息(被捕捉时的时间,包的长度,其被指定的部分长度)的结构体的指针(在这里只有一个片断,只作为一个示例)。

pcap_next()返回一个u_char指针给被这个结构体描述的包。

我们将稍后讨论这种实际读取包本身的手段。

这里有一个演示怎样使用pcap_next()来嗅探一个包的例子:#include#includeint main(){pcap_t *handle; /* 会话句柄*/char *dev; /* 执行嗅探的设备*/char errbuf[PCAP_ERRBUF_SIZE]; /* 存储错误信息的字符串*/struct bpf_program filter; /* 已经编译好的过滤器*/char filter_app[] = "port 23"; /* 过滤表达式*/ bpf_u_int32 mask; /* 所在网络的掩码*/bpf_u_int32 net; /* 主机的IP地址*/struct pcap_pkthdr header; /* 由pcap.h定义*/ const u_char *packet; /* 实际的包*//* Define the device */dev = pcap_lookupdev(errbuf);/* 探查设备属性*/pcap_lookupnet(dev, &net, &mask, errbuf);/* 以混杂模式打开会话*/handle = pcap_open_live(dev, BUFSIZ, 1, 0, errbuf); /* 编译并应用过滤器*/pcap_compile(handle, &filter, filter_app, 0, net); pcap_setfilter(handle, &filter);/* 截获一个包*/packet = pcap_next(handle, &header);/* 打印它的长度*/printf("Jacked a packet with length of [%d]", header.len);/* 关闭会话*/pcap_close(handle);return(0);}这个程序嗅探被pcap_lookupdev()返回的设备并将它置为混杂模式。

相关文档
最新文档