./configure
./make
./make install

char * device; /* 用来捕获数据包的网络接口的名称 */
pcap_t * p; /* 捕获数据包句柄，最重要的数据结构 */
struct bpf_program fcode; /* BPF 过滤代码结构 */

/* 第一步：查找可以捕获数据包的设备 */
device = pcap_lookupdev(errbuf)；

/* 第二步：创建捕获句柄，准备进行捕获 */
p = pcap_open_live(device, 8000, 1, 500, errbuf)；

/* 第三步：如果用户设置了过滤条件，则编译和安装过滤代码 */
pcap_compile(p, &fcode, filter_string, 0, netmask)；
pcap_setfilter(p, &fcode)；

/* 第四步：进入（死）循环，反复捕获数据包 */
for( ; ; )
{
while((ptr = (char *)(pcap_next(p, &hdr))) == NULL);
		
/* 第五步：对捕获的数据进行类型转换，转化成以太数据包类型 */
eth = (struct libnet_ethernet_hdr *)ptr;

/* 第六步：对以太头部进行分析，判断所包含的数据包类型，做进一步的处理 */
if(eth->ether_type == ntohs(ETHERTYPE_IP)) 
…………
if(eth->ether_type == ntohs(ETHERTYPE_ARP)) 
…………
}
	
/* 最后一步：关闭捕获句柄,一个简单技巧是在程序初始化时增加信号处理函数，
以便在程序退出前执行本条代码 */
pcap_close(p)；

	/* libpcap 自定义的接口信息链表 [pcap.h] */
struct pcap_if 
{
struct pcap_if *next; 
char *name; /* 接口设备名 */
char *description; /* 接口描述 */
		
/*接口的 IP 地址, 地址掩码, 广播地址,目的地址 */
struct pcap_addr addresses; 
bpf_u_int32 flags;	/* 接口的参数 */
};

char * pcap_lookupdev(register char * errbuf)
{
	pcap_if_t *alldevs;
	……
		pcap_findalldevs(&alldevs, errbuf)；
		……
		strlcpy(device, alldevs->name, sizeof(device));
	}
	

struct pcap [pcap-int.h]
{ 
	int fd; /* 文件描述字，实际就是 socket */
	
		/* 在 socket 上，可以使用 select() 和 poll() 等 I/O 复用类型函数 */
	int selectable_fd; 

	int snapshot; /* 用户期望的捕获数据包最大长度 */
	int linktype; /* 设备类型 */
	int tzoff;		/* 时区位置，实际上没有被使用 */
	int offset;	/* 边界对齐偏移量 */

	int break_loop; /* 强制从读数据包循环中跳出的标志 */

	struct pcap_sf sf; /* 数据包保存到文件的相关配置数据结构 */
	struct pcap_md md; /* 具体描述如下 */
	
	int bufsize; /* 读缓冲区的长度 */
	u_char buffer; /* 读缓冲区指针 */
	u_char *bp;
	int cc;
	u_char *pkt;

	/* 相关抽象操作的函数指针，最终指向特定操作系统的处理函数 */
	int	(*read_op)(pcap_t *, int cnt, pcap_handler, u_char *);
	int	(*setfilter_op)(pcap_t *, struct bpf_program *);
	int	(*set_datalink_op)(pcap_t *, int);
	int	(*getnonblock_op)(pcap_t *, char *);
	int	(*setnonblock_op)(pcap_t *, int, char *);
	int	(*stats_op)(pcap_t *, struct pcap_stat *);
	void (*close_op)(pcap_t *);

	/*如果 BPF 过滤代码不能在内核中执行,则将其保存并在用户空间执行 */
	struct bpf_program fcode; 

	/* 函数调用出错信息缓冲区 */
	char errbuf[PCAP_ERRBUF_SIZE + 1]; 
	
	/* 当前设备支持的、可更改的数据链路类型的个数 */
	int dlt_count;
	/* 可更改的数据链路类型号链表，在 linux 下没有使用 */
	int *dlt_list;

	/* 数据包自定义头部，对数据包捕获时间、捕获长度、真实长度进行描述 [pcap.h] */
	struct pcap_pkthdr pcap_header;	
};

/* 包含了捕获句柄的接口、状态、过滤信息  [pcap-int.h] */
struct pcap_md {
/* 捕获状态结构  [pcap.h] */
struct pcap_stat stat;  

	int use_bpf; /* 如果为1，则代表使用内核过滤*/ 
	u_long	TotPkts; 
	u_long	TotAccepted; /* 被接收数据包数目 */ 
	u_long	TotDrops;	/* 被丢弃数据包数目 */ 
	long	TotMissed;	/* 在过滤进行时被接口丢弃的数据包数目 */
	long	OrigMissed; /*在过滤进行前被接口丢弃的数据包数目*/
#ifdef linux
	int	sock_packet; /* 如果为 1，则代表使用 2.0 内核的 SOCK_PACKET 模式 */
	int	timeout;	/* pcap_open_live() 函数超时返回时间*/ 
	int	clear_promisc; /* 关闭时设置接口为非混杂模式 */ 
	int	cooked;		/* 使用 SOCK_DGRAM 类型 */
	int	lo_ifindex;	/* 回路设备索引号 */
	char *device;	/* 接口设备名称 */ 
	
/* 以混杂模式打开 SOCK_PACKET 类型 socket 的 pcap_t 链表*/
struct pcap *next;	
#endif
};

static int
live_open_new(pcap_t *handle, const char *device, int promisc,
   int to_ms, char *ebuf)
{
/* 如果设备给定,则打开一个 RAW 类型的套接字,否则,打开 DGRAM 类型的套接字 */
sock_fd = device ?
			socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))
		      : socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL));

/* 取得回路设备接口的索引 */
handle->md.lo_ifindex = iface_get_id(sock_fd, "lo", ebuf);

/* 如果设备给定，但接口类型未知或是某些必须工作在加工模式下的特定类型，则使用加工模式 */
if (device) {
/* 取得接口的硬件类型 */
arptype = iface_get_arptype(sock_fd, device, ebuf); 

/* linux 使用 ARPHRD_xxx 标识接口的硬件类型，而 libpcap 使用DLT_xxx
来标识。本函数是对上述二者的做映射变换，设置句柄的链路层类型为
DLT_xxx，并设置句柄的偏移量为合适的值，使其与链路层头部之和为 4 的倍数，目的是边界对齐 */
map_arphrd_to_dlt(handle, arptype, 1);

/* 如果接口是前面谈到的不支持链路层头部的类型，则退而求其次，使用 SOCK_DGRAM 模式 */
if (handle->linktype == xxx) 
{
close(sock_fd)；
sock_fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL));
}

/* 获得给定的设备名的索引 */
device_id = iface_get_id(sock_fd, device, ebuf);
			
/* 把套接字和给定的设备绑定，意味着只从给定的设备上捕获数据包 */
iface_bind(sock_fd, device_id, ebuf)；

} else { /* 现在是加工模式 */
handle->md.cooked = 1;
/* 数据包链路层头部为结构 sockaddr_ll， SLL 大概是结构名称的简写形式 */
handle->linktype = DLT_LINUX_SLL;
			device_id = -1;
		}
		
/* 设置给定设备为混杂模式 */
if (device && promisc) 
{
memset(&mr, 0, sizeof(mr));
mr.mr_ifindex = device_id;
mr.mr_type = PACKET_MR_PROMISC;
setsockopt(sock_fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, 
&mr, sizeof(mr))；
}

/* 最后把创建的 socket 保存在句柄 pcap_t 中 */
handle->fd = sock_fd;
	}

/* 2.0 内核下函数要简单的多，因为只有唯一的一种 socket 方式 */
static int
live_open_old(pcap_t *handle, const char *device, int promisc,
	      int to_ms, char *ebuf)
{
/* 首先创建一个SOCK_PACKET类型的 socket */
handle->fd = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL));
		
/* 2.0 内核下，不支持捕获所有接口，设备必须给定 */
if (!device) {
strncpy(ebuf, "pcap_open_live: The \"any\" device isn't supported on 2.0[.x]-kernel systems", PCAP_ERRBUF_SIZE);
break;
}
		
/* 把 socket 和给定的设备绑定 */
iface_bind_old(handle->fd, device, ebuf)；
		
/*以下的处理和 2.2 版本下的相似，有所区别的是如果接口链路层类型未知，则 libpcap 直接退出 */
		 
arptype = iface_get_arptype(handle->fd, device, ebuf);
map_arphrd_to_dlt(handle, arptype, 0);
if (handle->linktype == -1) {
snprintf(ebuf, PCAP_ERRBUF_SIZE, "unknown arptype %d", arptype);
break;
}

/* 设置给定设备为混杂模式 */
if (promisc) {
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
ioctl(handle->fd, SIOCGIFFLAGS, &ifr)；
ifr.ifr_flags |= IFF_PROMISC;
ioctl(handle->fd, SIOCSIFFLAGS, &ifr)；
}
}

iface_bind_old(int fd, const char *device, char *ebuf)
{
struct sockaddr	saddr;
memset(&saddr, 0, sizeof(saddr));
strncpy(saddr.sa_data, device, sizeof(saddr.sa_data));
bind(fd, &saddr, sizeof(saddr))；
}

iface_bind(int fd, int ifindex, char *ebuf)
{
struct sockaddr_ll	sll;
memset(&sll, 0, sizeof(sll));
sll.sll_family = AF_PACKET;
sll.sll_ifindex = ifindex;
sll.sll_protocol	= htons(ETH_P_ALL);
bind(fd, (struct sockaddr *) &sll, sizeof(sll)；
}

struct packet_mreq
{
int             mr_ifindex;    /* 接口索引号 */
unsigned short  mr_type;       /* 要执行的操作(号) */
unsigned short  mr_alen;       /* 地址长度 */
unsigned char   mr_address[8]; /* 物理层地址 */ 
};

/* 单个数据包结构，包含数据包元信息和数据信息 */
struct singleton [pcap.c]
{
struct pcap_pkthdr hdr; /* libpcap 自定义数据包头部 */
const u_char * pkt; /* 指向捕获到的网络数据 */
};

/* 自定义头部在把数据包保存到文件中也被使用 */
struct pcap_pkthdr 
{
		struct timeval ts; /* 捕获时间戳 */ 
		bpf_u_int32 caplen; /* 捕获到数据包的长度 */
		bpf_u_int32 len; /* 数据包的真正长度 */
}

/* 函数 pcap_next() 实际上是对函数 pcap_dispatch()[pcap.c] 的一个包装 */
const u_char * pcap_next(pcap_t *p, struct pcap_pkthdr *h)
{
struct singleton s;
s.hdr = h;

/*入参"1"代表收到1个数据包就返回；回调函数 pcap_oneshot() 是对结构 singleton 的属性赋值 */
if (pcap_dispatch(p, 1, pcap_oneshot, (u_char*)&s) <= 0)
return (0);
return (s.pkt); /* 返回数据包缓冲区的指针 */
}

static int
pcap_read_packet(pcap_t *handle, pcap_handler callback, u_char *userdata)
{
/* 数据包缓冲区指针 */
u_char * bp;

/* bp 与捕获句柄 pcap_t 中 handle->buffer
之间的偏移量，其目的是为在加工模式捕获情况下，为合成的伪数据链路层头部留出空间 */
int offset;

/* PACKET_SOCKET 方式下，recvfrom() 返回 scokaddr_ll 类型，而在SOCK_PACKET 方式下，
返回 sockaddr 类型 */
#ifdef HAVE_PF_PACKET_SOCKETS 
			struct sockaddr_ll	from;
			struct sll_header	* hdrp;
#else
			struct sockaddr		from;
#endif

socklen_t		fromlen;
int			packet_len, caplen;

/* libpcap 自定义的头部 */
struct pcap_pkthdr	pcap_header;

#ifdef HAVE_PF_PACKET_SOCKETS
/* 如果是加工模式，则为合成的链路层头部留出空间 */
if (handle->md.cooked)
offset = SLL_HDR_LEN;

/* 其它两中方式下，链路层头部不做修改的被返回，不需要留空间 */
else
offset = 0;
#else
offset = 0;
#endif

bp = handle->buffer + handle->offset;
	
/* 从内核中接收一个数据包，注意函数入参中对 bp 的位置进行修正 */
packet_len = recvfrom( handle->fd, bp + offset,
handle->bufsize - offset, MSG_TRUNC,
(struct sockaddr *) &from, &fromlen);
	
#ifdef HAVE_PF_PACKET_SOCKETS
	
/* 如果是回路设备,则只捕获接收的数据包，而拒绝发送的数据包。显然，我们只能在 PF_PACKET
方式下这样做,因为 SOCK_PACKET 方式下返回的链路层地址类型为
sockaddr_pkt，缺少了判断数据包类型的信息。*/
if (!handle->md.sock_packet &&
from.sll_ifindex == handle->md.lo_ifindex &&
from.sll_pkttype == PACKET_OUTGOING)
return 0;
#endif

#ifdef HAVE_PF_PACKET_SOCKETS
/* 如果是加工模式，则合成伪链路层头部 */
if (handle->md.cooked) {
/* 首先修正捕包数据的长度，加上链路层头部的长度 */
packet_len += SLL_HDR_LEN;
		hdrp = (struct sll_header *)bp;
		
/* 以下的代码分别对伪链路层头部的数据赋值 */
hdrp->sll_pkttype = xxx;
hdrp->sll_hatype = htons(from.sll_hatype);
hdrp->sll_halen = htons(from.sll_halen);
memcpy(hdrp->sll_addr, from.sll_addr, 
(from.sll_halen > SLL_ADDRLEN) ? 
SLL_ADDRLEN : from.sll_halen);
hdrp->sll_protocol = from.sll_protocol;
}
#endif
	
/* 修正捕获的数据包的长度，根据前面的讨论，SOCK_PACKET 方式下长度可能是不准确的 */
caplen = packet_len;
if (caplen > handle->snapshot)
caplen = handle->snapshot;

/* 如果没有使用内核级的包过滤,则在用户空间进行过滤*/
if (!handle->md.use_bpf && handle->fcode.bf_insns) {
if (bpf_filter(handle->fcode.bf_insns, bp,
packet_len, caplen) == 0)
{
/* 没有通过过滤，数据包被丢弃 */
return 0;
}
}

/* 填充 libpcap 自定义数据包头部数据：捕获时间,捕获的长度,真实的长度 */
ioctl(handle->fd, SIOCGSTAMP, &pcap_header.ts)；
pcap_header.caplen	= caplen;
pcap_header.len		= packet_len;
	
/* 累加捕获数据包数目，注意到在不同内核/捕获方式情况下数目可能不准确 */
handle->md.stat.ps_recv++;

/* 调用用户定义的回调函数 */
callback(userdata, &pcap_header, bp);
}

flex -Ppcap_ -t scanner.l > $$.scanner.c; mv $$.scanner.c scanner.c
bison -y -p pcap_ -d grammar.y
mv y.tab.c grammar.c
mv y.tab.h tokdefs.h

int pcap_compile(pcap_t *p, struct bpf_program *program,
	     char *buf, int optimize, bpf_u_int32 mask)

/* [pcap-bpf.h] */
struct bpf_program {
u_int bf_len; /* BPF 代码中谓词判断指令的数目 */
struct bpf_insn *bf_insns; /* 第一个谓词判断指令 */
};
	
/* 谓词判断指令结构，含意在前面已描述 [pcap-bpf.h] */
struct bpf_insn {
u_short	code;
u_char 	jt;
u_char 	jf;
bpf_int32 k;
};

/* 在包捕获设备上附加 BPF 代码 [pcap-linux.c]*/
static int
pcap_setfilter_linux(pcap_t *handle, struct bpf_program *filter)
{
#ifdef SO_ATTACH_FILTER
struct sock_fprog	fcode;
int can_filter_in_kernel;
int err = 0;
#endif

/* 检查句柄和过滤器结构的正确性 */
if (!handle)
return -1;
if (!filter) {
strncpy(handle->errbuf, "setfilter: No filter specified",
sizeof(handle->errbuf));
return -1;
}

/* 具体描述如下 */ 
if (install_bpf_program(handle, filter) < 0)
return -1;

/* 缺省情况下在用户空间运行过滤器,但如果在内核安装成功,则值为 1 */
handle->md.use_bpf = 0;

	
/* 尝试在内核安装过滤器 */
#ifdef SO_ATTACH_FILTER
#ifdef USHRT_MAX
if (handle->fcode.bf_len > USHRT_MAX) {
/*过滤器代码太长，内核不支持 */
fprintf(stderr, "Warning: Filter too complex for kernel\n");
fcode.filter = NULL;
can_filter_in_kernel = 0;
} else
#endif /* USHRT_MAX */
{
/* linux 内核设置过滤器时使用的数据结构是 sock_fprog，而不是 BPF 的结构 bpf_program ,因此应做结构之间的转换 */
switch (fix_program(handle, &fcode)) {
					
/* 严重错误，直接退出 */
case -1:
default: 
return -1;
					
/* 通过检查，但不能工作在内核中 */
case 0: 
can_filter_in_kernel = 0;
break;

/* BPF 可以在内核中工作 */
case 1: 
can_filter_in_kernel = 1;
break;
}
}

/* 如果可以在内核中过滤，则安装过滤器到内核中 */
if (can_filter_in_kernel) {
if ((err = set_kernel_filter(handle, &fcode)) == 0)
{
/* 安装成功 !!! */
handle->md.use_bpf = 1;
}
else if (err == -1)	/* 出现非致命性错误 */
{
if (errno != ENOPROTOOPT && errno != EOPNOTSUPP) {
fprintf(stderr, "Warning: Kernel filter failed:
 %s\n",pcap_strerror(errno));
}
}
}

/* 如果不能在内核中使用过滤器，则去掉曾经可能在此 socket
上安装的内核过滤器。主要目的是为了避免存在的过滤器对数据包过滤的干扰 */
if (!handle->md.use_bpf)
reset_kernel_filter(handle);[pcap-linux.c]
#endif 
}


/* 把 BPF 代码拷贝到 pcap_t 数据结构的 fcode 上 */
int install_bpf_program(pcap_t *p, struct bpf_program *fp)
{
size_t prog_size;

/* 首先释放可能已存在的 BPF 代码 */ 
pcap_freecode(&p->fcode);

/* 计算过滤代码的长度，分配内存空间 */
prog_size = sizeof(*fp->bf_insns) * fp->bf_len;
p->fcode.bf_len = fp->bf_len;
p->fcode.bf_insns = (struct bpf_insn *)malloc(prog_size);
if (p->fcode.bf_insns == NULL) {
snprintf(p->errbuf, sizeof(p->errbuf),
"malloc: %s", pcap_strerror(errno));
return (-1);
}

/* 把过滤代码保存在捕获句柄中 */
memcpy(p->fcode.bf_insns, fp->bf_insns, prog_size);
			
return (0);
}

/* 在内核中安装过滤器 */
static int set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode)
{
int total_filter_on = 0;
int save_mode;
int ret;
int save_errno;

/*在设置过滤器前，socket 的数据包接收队列中可能已存在若干数据包。当设置过滤器后，
这些数据包极有可能不满足过滤条件，但它们不被过滤器丢弃。
这意味着，传递到用户空间的头几个数据包不满足过滤条件。
注意到在用户空间过滤这不是问题，因为用户空间的过滤器是在包进入队列后执行的。
Libpcap 解决这个问题的方法是在设置过滤器之前，
首先读完接收队列中所有的数据包。具体步骤如下。*/
	 
/*为了避免无限循环的情况发生（反复的读数据包并丢弃，但新的数据包不停的到达），首先设置一个过滤器，阻止所有的包进入 */
	 
setsockopt(handle->fd, SOL_SOCKET, SO_ATTACH_FILTER,
&total_fcode, sizeof(total_fcode)；

/* 保存 socket 当前的属性 */
save_mode = fcntl(handle->fd, F_GETFL, 0);

/* 设置 socket 它为非阻塞模式 */
fcntl(handle->fd, F_SETFL, save_mode | O_NONBLOCK)；

/* 反复读队列中的数据包，直到没有数据包可读。这意味着接收队列已被清空 */
while (recv(handle->fd, &drain, sizeof drain, MSG_TRUNC) >= 0)；
				
/* 恢复曾保存的 socket 属性 */
fcntl(handle->fd, F_SETFL, save_mode);
			
/* 现在安装新的过滤器 */
setsockopt(handle->fd, SOL_SOCKET, SO_ATTACH_FILTER,
fcode, sizeof(*fcode));
}

/* 释放 socket 上可能有的内核过滤器 */
static int reset_kernel_filter(pcap_t *handle)
{
int dummy;
return setsockopt(handle->fd, SOL_SOCKET, SO_DETACH_FILTER,
&dummy, sizeof(dummy));
}

[net/core/sock.c]
#ifdef CONFIG_FILTER
case SO_ATTACH_FILTER:
……
/* 把过滤条件结构从用户空间拷贝到内核空间 */
if (copy_from_user(&fprog, optval, sizeof(fprog)))
break;
/* 在 socket 上安装过滤器 */
ret = sk_attach_filter(&fprog, sk);
			……

case SO_DETACH_FILTER:
/* 使用自旋锁锁住 socket */
spin_lock_bh(&sk->lock.slock);

filter = sk->filter;
/* 如果在 socket 上有过滤器，则简单设置为空，并释放过滤器内存 */
if (filter) {
sk->filter = NULL;
spin_unlock_bh(&sk->lock.slock);
sk_filter_release(sk, filter);
break;
}
spin_unlock_bh(&sk->lock.slock);
ret = -ENONET;
break;
#endif