示范代码片段：

#include <pcap.h>...pcap_t *handle;handle =pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);if (handle == NULL) {fprintf(stderr,"Couldn't open device %s: %s\n", dev, errbuf);return(2);}

这段代码将打开的设备保存到dev变量中，捕获的数据最大字节数为BUFSIZ（在pcap.h中定义）。设置设备为promiscuous模式；直到出现错误时嗅探才结束；如果出现错误将错误存储在errbuf字符串中。

Promiscuous sniffing vs. non-promiscuous sniffing：两种不同的技术，标准情况下non-promiscuous嗅探只嗅探和直接自己相关的流量，包括自己发送的、接受的和路由时经过自己的流量。Promiscuous模式则相反，它嗅探线路上的所有流量，在非变换环境下，可能是所有的流量。Promiscuous模式的显著优点是可以嗅探更多的数据包，对于嗅探着来说可能有用也可能没有用；当然这也是有缺点的，首先promiscuous模式的嗅探是可以被侦测到的，一台机器可以准确的侦测到是否有另一台机器在嗅探。其次这种模式只能工作在non-switched环境下（例如，中心节点，或者正在经受ARP泛洪的交换机）。最后一个缺点是：当网络流量很多时，嗅探所有流量将消耗大部分的系统资源。

不是所有的设备有相同的链路层包头。以太网和一些非以太网设备提供以太网包头，其他类型的设备却不是（例如，BSD和OS X中的回环设备、ppp接口、监控嗅探模式下的Wi-Fi接口）

你需要确定设备所提供的链路层包头的类型，处理数据包内容时使用到这个类型。pcap_datalink()函数返回值是链路层包头的类型详情参照the list of link-layer header type values. 这种错误由于设备不支持以太网数据包头，下面的代码适用于这种情况，因为它假设以太网包头。

        if (pcap_datalink(handle) != DLT_EN10MB) {fprintf(stderr,"Device %s doesn't provide Ethernet headers - not supported\n", dev);return(2);}

流量过滤

大多数情况，我们的嗅探器只对特定的流量感兴趣。例如 ，在密码搜索时我们只想要端口23（telnet）的流量、或者我们想截断端口21（FTP）正在发送的文件、有时我们只想要DNS流量（端口53UDP）。无论哪一种情况，我们几乎不会盲目的嗅探所有的流量。相关函数有pcap_compile()and pcap_setfilter()。

这个过程有时so easy！在调用pcap_open_live()之后我们拥有了一个嗅探会话，这时就可以使用过滤器了。使用过滤器而不使用if/else条件语句有两个原因：首先，pcap的过滤器非常高效，因为它直接调用BPF过滤器。其次是BPF驱动可以替我们做很多操作，这使得编程更简洁。

在使用我们的过滤器之前，必须“编译”它。过滤器表达式基于一个正则表达式字符串，主页tcpdump的开发文档有详细的语法规则，自己阅读去吧。我们使用简单的测试表达式，所以你可以很容易地从我的例子中搞明白它。

pcap_compile（）函数的原型：

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

第一个参数是嗅探会话句柄，在前面的例子中出现，第二个参数是存储过滤器编译版本的结构体的指针，第三个参数是字符串类型的正则表达式，第四个参数指定过滤规则表达式是否被优化（0表示没有，1表示是）最后一个参数指定过滤器适用的网络的网络掩码。函数执行失败返回-1。

过滤规则表达式编译后就派上用场了，根据pcap文档使用pcap_setfilter()函数，下面是函数声明原型：

        intpcap_setfilter(pcap_t *p, struct bpf_program *fp)

如此直截了当，第一个参数是嗅探会话句柄，第二个参数是存储过滤器编译版本的结构体的指针，和pcap_compile()的第二个参数一样。

废话少说，上代码：

  #include<pcap.h>...pcap_t *handle;               /* Session handle */char dev[] = "rl0";           /* Device to sniff on */char errbuf[PCAP_ERRBUF_SIZE];       /* Error string */struct bpf_program fp;               /* The compiled filter expression */char filter_exp[] = "port 23";       /* The filter expression */bpf_u_int32 mask;             /* The netmask of our sniffing device */bpf_u_int32 net;              /* The IP of our sniffing device */if (pcap_lookupnet(dev, &net, &mask,errbuf) == -1) {fprintf(stderr, "Can't get netmask fordevice %s\n", dev);net = 0;mask = 0;}handle = pcap_open_live(dev, BUFSIZ, 1, 1000,errbuf);if (handle == NULL) {fprintf(stderr, "Couldn't open device %s:%s\n", dev, errbuf);return(2);}if (pcap_compile(handle, &fp, filter_exp,0, net) == -1) {fprintf(stderr, "Couldn't parse filter%s: %s\n", filter_exp, pcap_geterr(handle));return(2);}if (pcap_setfilter(handle, &fp) == -1) {fprintf(stderr, "Couldn't install filter%s: %s\n", filter_exp, pcap_geterr(handle));return(2);}

程序将嗅探所有来自或抵达设备r10端口23的流量，工作在混合模式下。

你也许已经发现前面的代码中有一个函数我们没有讨论过。Pcap_looupnet()通过设备名参数dev，返回设备IPV4网络号和相应的子网掩码（网络号是IPV4地址和子网掩码异或的结果，仅仅包含IP地址的网络部分）。这是最基本的，因为应用过滤器时需要直到子网掩码。这个函数的详细解释在文档末尾的Miscellaneous模块。据我所知，过滤器不能在所有的操作系统上正常工作。在我的环境下，我发现原版的OpenBSD2.9支持这种过滤器，但是原版FreeBSD4.3不支持。因人而异。

此刻，我我们已经学习了怎样定义设备、如何初始化设备和如何使用过滤器。是该行动的时候了。抓包有两个主要的技术，我们可以一次抓取一个包，也可以使用循环一次抓取n个包。先演示抓取一个包，在使用循环一次抓取多个包。使用pcap_next（）可以完成这个目标，它的声明如下：

        u_char*pcap_next(pcap_t *p, struct pcap_pkthdr *h)

第一个参数是任务句柄，第二个参数是一个指向存储数据包概略信息结构体的指针，结构体中数据成员time是嗅探时刻的时间，结构体中有数据域length（包的长度），函数返回一个包的结构体指针，是u_char型。后面我们会讨论解读包内容的技术。使用pcap_next（）的demo。

 #include<pcap.h>#include <stdio.h>int main(int argc, char *argv[]){pcap_t*handle;                /* Session handle*/char*dev;                     /* The device tosniff on */charerrbuf[PCAP_ERRBUF_SIZE]; /* Error string*/structbpf_program fp;         /* The compiledfilter */charfilter_exp[] = "port 23"; /* Thefilter expression */bpf_u_int32mask;              /* Our netmask */bpf_u_int32net;               /* Our IP */structpcap_pkthdr header;     /* The header thatpcap gives us */constu_char *packet;          /* The actualpacket *//*Define the device */dev =pcap_lookupdev(errbuf);if(dev == NULL) {fprintf(stderr,"Couldn't find default device: %s\n", errbuf);return(2);}/*Find the properties for the device */if(pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {fprintf(stderr,"Couldn't get netmask for device %s: %s\n", dev, errbuf);net= 0;mask= 0;}/*Open the session in promiscuous mode */handle= pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);if(handle == NULL) {fprintf(stderr,"Couldn't open device %s: %s\n", dev, errbuf);return(2);}/*Compile and apply the filter */if(pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {fprintf(stderr,"Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));return(2);}if(pcap_setfilter(handle, &fp) == -1) {fprintf(stderr,"Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));return(2);}/*Grab a packet */packet= pcap_next(handle, &header);/*Print its length */printf("Jackeda packet with length of [%d]\n", header.len);/*And close the session */pcap_close(handle);return(0);}

上面的代码在promiscuous模式下嗅探所有由pcap_lookupdev()返回的设备。它发现第一个经过端口23（telnet）的数据包并打印包的长度。程序也调用了

另一种方法是较复杂的同时也是更有用的，很少的嗅探器使用pcap_next()，更多情况下使用pcap_loop()或者pcap_dispatch()（pcap_dispatch()内部调用pcap_next()）。想要理解这两个函数就必须要了解回调单数。

回调函数不是新的内容，在许多API中都有。回调函数的概念也是很简单的，假设有一个等待排序事物的程序，程序的目的是，每当用户按下一个按键，就调用一个函数做一些处理，这个函数就叫做回调函数。额你当用户按键一次，程序将调用一次这个函数。在pcap中的调用中，“嗅探一个包”的操作类似前面例子中的“按键一次”。pcap_loop()和pcap_dispatch()都可以定义自己回调函数，两者回调操作的用法很相似。在每次有满足过滤规则的数据包被嗅探到的时候，他们都会调用回调。

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

第一个参数是任务句柄。第二个参数是一个非负整数，它告诉pcap_loop()函数，在返回或出错之前应该嗅探几个数据包。第三个参数是回调函数的名字，只有函数名没有小括号。最后一个参数在一些应用中是有用的，但是很多时候设为NULL，显然只有把这个参数转换成u_char指针类型才能确保不出错。后面我们将看到，pcap将一些有趣的流经的信息设置为u_char指针型，在举了一个相关例子之后就会直到它怎么做到的了，那时如果还不明白的话，请阅读C语言中指针部分的内容，本文不对指针的相关知识做详细的介绍。Pcap_dispatch()的使用几乎一样。两者唯一的不同的地方时pcap_dispatch()仅仅处理从系统接收的第一批数据包，而pcap_loop()会继续处理剩余所有的包，如果想深入了解两者的不同请阅读pcap主页。

在举一个使用pcap_loop()的例子之前，必须坚持回调函数的格式，不能随意定义回调函数，如果那样做pcap_loop()将不知道该怎么使用它了。所以统一使用下面的格式定义回调函数：

        voidgot_packet(u_char *args, const struct pcap_pkthdr *header,const u_char*packet);

深入了解。首先，函数没有返回值，其实这是符合逻辑的，因为pcap_loop()不知道怎样处理接收到的返回值。第一个参数和pcap_loop()的最后一个参数相同。每一次函数调用的时候，传给pcap_loop()的最后一个参数的值同时也传给回调函数的第一个参数。第二个参数是pcap头，这个pcap头包含了嗅探到的包的信息，比如包的大小等。Pcap_pkthdr结构体在pcap.h中定义，如下：

        structpcap_pkthdr {structtimeval ts; /* time stamp */bpf_u_int32caplen; /* length of portion present */bpf_u_int32len; /* length this packet (off wire) */};

这些参数都很简单呐，最后一个是最感兴趣的，往往也是初学者最困惑的，它也是一个u_char类型的指针，它指向pcap_loop()嗅探的完整的一个数据包的第一个字节。

如何利用数据包呢？一个数据包有很多属性，它是一个结构体而不是一个简单的字符串（比如，TCP/IP包的内容有一个以太网包头，一个IP包头和包的有效负载）。u_char指针指向这些结构体的序列号，在使用之前需要做一些转换。在转换之前需要先定义这些结构体，下面这段代码就是我定义的一个以太网上的TCP/IP包的结构体：

/* Ethernet addresses are 6 bytes */#define ETHER_ADDR_LEN 6/* Ethernetheader */structsniff_ethernet {u_charether_dhost[ETHER_ADDR_LEN]; /* Destination host address */u_charether_shost[ETHER_ADDR_LEN]; /* Source host address */u_shortether_type; /* IP? ARP? RARP? etc */};/* IP header*/structsniff_ip {u_charip_vhl;         /* version << 4 |header length >> 2 */u_charip_tos;         /* type of service */u_shortip_len;        /* total length */u_shortip_id;         /* identification */u_shortip_off;        /* fragment offset field */#defineIP_RF 0x8000           /* reservedfragment flag */#defineIP_DF 0x4000           /* dont fragmentflag */#defineIP_MF 0x2000           /* more fragmentsflag */#defineIP_OFFMASK 0x1fff      /* mask forfragmenting bits */u_charip_ttl;         /* time to live */u_charip_p;           /* protocol */u_shortip_sum;        /* checksum */structin_addr ip_src,ip_dst; /* source and dest address */};#defineIP_HL(ip)              (((ip)->ip_vhl)& 0x0f)  //得到后四位，即 header length>>2#defineIP_V(ip)               (((ip)->ip_vhl)>> 4) //得到前四位，即version/* TCPheader */typedefu_int tcp_seq;structsniff_tcp {u_shortth_sport;      /* source port */u_shortth_dport;      /* destination port */tcp_seqth_seq;        /* sequence number */tcp_seqth_ack;        /* acknowledgement number*/u_charth_offx2;       /* data offset, rsvd */#defineTH_OFF(th)     (((th)->th_offx2 &0xf0) >> 4)//得到前四位u_charth_flags;#defineTH_FIN 0x01#defineTH_SYN 0x02#defineTH_RST 0x04#defineTH_PUSH 0x08#defineTH_ACK 0x10#defineTH_URG 0x20#defineTH_ECE 0x40#defineTH_CWR 0x80#defineTH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)u_shortth_win;        /* window */u_shortth_sum;        /* checksum */u_shortth_urp;        /* urgent pointer */};

这些东西是如何跟pcap、神秘的u_char指针联系起来的呢？这个结构体定义了数据包的包头，那么我们如何拆解它呢？准备见证最实用的指针的用法（所有认为指针是没有用的C新手们，开始打脸喽！）

依然假设我们在处理以太网TCP/IP数据包。同样的技术应用到所有包，唯一不同的是使用的结构体类型。先从定义变量和解析数据包时所用到的编译时间开始。

/* ethernet headers are always exactly 14 bytes */#define SIZE_ETHERNET 14const structsniff_ethernet *ethernet; /* The ethernet header */const structsniff_ip *ip; /* The IP header */const structsniff_tcp *tcp; /* The TCP header */const char*payload; /* Packet payload */u_intsize_ip;u_intsize_tcp;

这里是神奇的类型转换

  ethernet =(struct sniff_ethernet*)(packet);ip = (structsniff_ip*)(packet + SIZE_ETHERNET); //以太网包头长14个字节size_ip =IP_HL(ip)*4; //IP包头长度由IP_HL(ip)*4指出，因为TCP包头和IP包头都是以“4个字节”为单位的if (size_ip< 20) {//IP包头长度应该}>=20printf("   * Invalid IP header length: %ubytes\n", size_ip);return;}tcp =(struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);size_tcp =TH_OFF(tcp)*4; //TCP包头长度由TCP_OFF(ip)*4指出，因为TCP包头和IP包头都是以“4个字节”为单位的if (size_tcp< 20) {printf("   * Invalid TCP header length: %ubytes\n", size_tcp);return;}payload =(u_char *)(packet + SIZE_ETHERNET + size_ip + size_tcp);

这样能行吗？思考一下数据包在内存中的存放。U_char指针仅仅只是一个包含内存地址的变量，这就是指针的本质，它指向内存中的位置。

简单的说，指针指向的地址是X，三个结构体变量连续的存放在内存中，第一个（以太网包头）被放在地址X处，我们可以很简单的找到它后面的结构体的地址，就是X+以太网包头的长度，即X+14

类似地，如果我们知道包头的地址，那么包头后面的结构体的地址就是包头的地址加上包头的长度。IP包头和以太网包头不一样，它不是定长的，它的长度是一个4字节为计数单位的无符整数，由IP包头中的IP包头长度域给出，由于它是一个4字节为计数单位的无符整数，所以乘以4才是真实的字节数，IP包头的最小长度是20个字节。

用表显示更直观

此时，我们知道怎么编写回调函数了，调用它就能找出被嗅探到的数据包的属性。你可能想：“写一个能用的嗅探器吧！”不过由于篇幅问题我就不在这里贴代码了，想要的话去这里下载sniffex.c

总结：
此时你应该能自己使用pcap写一个嗅探器了。你已经大体上了解开始一个pcap任务的基本概念了，嗅探数据包，应用过滤器，使用回调函数。是时候来到战场嗅探这无尽的网络了。