./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