bpf and netfiter

ubuntuer

今天看libpcap代码,文章说bpf(bsd packet filter)不错,自己写了个sniff,不过pcap那一套毕竟要copy数据包,就算是mmap pcap也要copy一次,而netfilter不用copy数据包...

   我想能不能把bpf搞到netfilter呢？？如果是应用层的话可以实用setsockopt来做
if ( (sock=socket(PF_PACKET, SOCK_RAW,
                    htons(ETH_P_IP)))<0) {
    perror("socket");
    exit(1);
  }


  /* Attach the filter to the socket */
  if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
                &Filter, sizeof(Filter))<0){
    perror("setsockopt");
    close(sock);
    exit(1);
  }


   内核态呢???   不解...    由于对bpf也不是很熟悉,欢迎讨论

platinum

内核态的实现在 <kernel>/net/core/filter.c 中

1. 
   
2. /**
   
3. *      sk_run_filter - run a filter on a socket
   
4. *      @skb: buffer to run the filter on
   
5. *      @filter: filter to apply
   
6. *      @flen: length of filter
   
7. *
   
8. * Decode and apply filter instructions to the skb->data.
   
9. * Return length to keep, 0 for none. skb is the data we are
   
10. * filtering, filter is the array of filter instructions, and
    
11. * len is the number of filter blocks in the array.
    
12. */
    
13. unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen)
    
14. {
    
15.         struct sock_filter *fentry;     /* We walk down these */
    
16.         void *ptr;
    
17.         u32 A = 0;                      /* Accumulator */
    
18.         u32 X = 0;                      /* Index Register */
    
19.         u32 mem[BPF_MEMWORDS];          /* Scratch Memory Store */
    
20.         u32 tmp;
    
21.         int k;
    
22.         int pc;
    
23. 
    
24.         /*
    
25.          * Process array of filter instructions.
    
26.          */
    
27.         for (pc = 0; pc < flen; pc++) {
    
28.                 fentry = &filter[pc];
    
29. 
    
30.                 switch (fentry->code) {
    
31.                 case BPF_ALU|BPF_ADD|BPF_X:
    
32.                         A += X;
    
33.                         continue;
    
34.                 case BPF_ALU|BPF_ADD|BPF_K:
    
35.                         A += fentry->k;
    
36.                         continue;
    
37.                 case BPF_ALU|BPF_SUB|BPF_X:
    
38.                         A -= X;
    
39.                         continue;
    
40.                 case BPF_ALU|BPF_SUB|BPF_K:
    
41.                         A -= fentry->k;
    
42.                         continue;
    
43.                 case BPF_ALU|BPF_MUL|BPF_X:
    
44.                         A *= X;
    
45.                         continue;
    
46.                 case BPF_ALU|BPF_MUL|BPF_K:
    
47.                         A *= fentry->k;
    
48.                         continue;
    
49.                 case BPF_ALU|BPF_DIV|BPF_X:
    
50.                         if (X == 0)
    
51.                                 return 0;
    
52.                         A /= X;
    
53.                         continue;
    
54.                 case BPF_ALU|BPF_DIV|BPF_K:
    
55.                         A /= fentry->k;
    
56.                         continue;
    
57.                 case BPF_ALU|BPF_AND|BPF_X:
    
58.                         A &= X;
    
59.                         continue;
    
60.                 case BPF_ALU|BPF_AND|BPF_K:
    
61.                         A &= fentry->k;
    
62.                         continue;
    
63.                 case BPF_ALU|BPF_OR|BPF_X:
    
64.                         A |= X;
    
65.                         continue;
    
66.                 case BPF_ALU|BPF_OR|BPF_K:
    
67.                         A |= fentry->k;
    
68.                         continue;
    
69.                 case BPF_ALU|BPF_LSH|BPF_X:
    
70.                         A <<= X;
    
71.                         continue;
    
72.                 case BPF_ALU|BPF_LSH|BPF_K:
    
73.                         A <<= fentry->k;
    
74.                         continue;
    
75.                 case BPF_ALU|BPF_RSH|BPF_X:
    
76.                         A >>= X;
    
77.                         continue;
    
78.                 case BPF_ALU|BPF_RSH|BPF_K:
    
79.                         A >>= fentry->k;
    
80.                         continue;
    
81.                 case BPF_ALU|BPF_NEG:
    
82.                         A = -A;
    
83.                         continue;
    
84.                 case BPF_JMP|BPF_JA:
    
85.                         pc += fentry->k;
    
86.                         continue;
    
87.                 case BPF_JMP|BPF_JGT|BPF_K:
    
88.                         pc += (A > fentry->k) ? fentry->jt : fentry->jf;
    
89.                         continue;
    
90.                 case BPF_JMP|BPF_JGE|BPF_K:
    
91.                         pc += (A >= fentry->k) ? fentry->jt : fentry->jf;
    
92.                         continue;
    
93.                 case BPF_JMP|BPF_JEQ|BPF_K:
    
94.                         pc += (A == fentry->k) ? fentry->jt : fentry->jf;
    
95.                         continue;
    
96.                 case BPF_JMP|BPF_JSET|BPF_K:
    
97.                         pc += (A & fentry->k) ? fentry->jt : fentry->jf;
    
98.                         continue;
    
99.                 case BPF_JMP|BPF_JGT|BPF_X:
    
100.                         pc += (A > X) ? fentry->jt : fentry->jf;
     
101.                         continue;
     
102.                 case BPF_JMP|BPF_JGE|BPF_X:
     
103.                         pc += (A >= X) ? fentry->jt : fentry->jf;
     
104.                         continue;
     
105.                 case BPF_JMP|BPF_JEQ|BPF_X:
     
106.                         pc += (A == X) ? fentry->jt : fentry->jf;
     
107.                         continue;
     
108.                 case BPF_JMP|BPF_JSET|BPF_X:
     
109.                         pc += (A & X) ? fentry->jt : fentry->jf;
     
110.                         continue;
     
111.                 case BPF_LD|BPF_W|BPF_ABS:
     
112.                         k = fentry->k;
     
113. load_w:
     
114.                         ptr = load_pointer(skb, k, 4, &tmp);
     
115.                         if (ptr != NULL) {
     
116.                                 A = ntohl(get_unaligned((__be32 *)ptr));
     
117.                                 continue;
     
118.                         }
     
119.                         break;
     
120.                 case BPF_LD|BPF_H|BPF_ABS:
     
121.                         k = fentry->k;
     
122. load_h:
     
123.                         ptr = load_pointer(skb, k, 2, &tmp);
     
124.                         if (ptr != NULL) {
     
125.                                 A = ntohs(get_unaligned((__be16 *)ptr));
     
126.                                 continue;
     
127.                         }
     
128.                         break;
     
129.                 case BPF_LD|BPF_B|BPF_ABS:
     
130.                         k = fentry->k;
     
131. load_b:
     
132.                         ptr = load_pointer(skb, k, 1, &tmp);
     
133.                         if (ptr != NULL) {
     
134.                                 A = *(u8 *)ptr;
     
135.                                 continue;
     
136.                         }
     
137.                         break;
     
138.                 case BPF_LD|BPF_W|BPF_LEN:
     
139.                         A = skb->len;
     
140.                         continue;
     
141.                 case BPF_LDX|BPF_W|BPF_LEN:
     
142.                         X = skb->len;
     
143.                         continue;
     
144.                 case BPF_LD|BPF_W|BPF_IND:
     
145.                         k = X + fentry->k;
     
146.                         goto load_w;
     
147.                 case BPF_LD|BPF_H|BPF_IND:
     
148.                         k = X + fentry->k;
     
149.                         goto load_h;
     
150.                 case BPF_LD|BPF_B|BPF_IND:
     
151.                         k = X + fentry->k;
     
152.                         goto load_b;
     
153.                 case BPF_LDX|BPF_B|BPF_MSH:
     
154.                         ptr = load_pointer(skb, fentry->k, 1, &tmp);
     
155.                         if (ptr != NULL) {
     
156.                                 X = (*(u8 *)ptr & 0xf) << 2;
     
157.                                 continue;
     
158.                         }
     
159.                         return 0;
     
160.                 case BPF_LD|BPF_IMM:
     
161.                         A = fentry->k;
     
162.                         continue;
     
163.                 case BPF_LDX|BPF_IMM:
     
164.                         X = fentry->k;
     
165.                         continue;
     
166.                 case BPF_LD|BPF_MEM:
     
167.                         A = mem[fentry->k];
     
168.                         continue;
     
169.                 case BPF_LDX|BPF_MEM:
     
170.                         X = mem[fentry->k];
     
171.                         continue;
     
172.                 case BPF_MISC|BPF_TAX:
     
173.                         X = A;
     
174.                         continue;
     
175.                 case BPF_MISC|BPF_TXA:
     
176.                         A = X;
     
177.                         continue;
     
178.                 case BPF_RET|BPF_K:
     
179.                         return fentry->k;
     
180.                 case BPF_RET|BPF_A:
     
181.                         return A;
     
182.                 case BPF_ST:
     
183.                         mem[fentry->k] = A;
     
184.                         continue;
     
185.                 case BPF_STX:
     
186.                         mem[fentry->k] = X;
     
187.                         continue;
     
188.                 default:
     
189.                         WARN_ON(1);
     
190.                         return 0;
     
191.                 }
     
192. 
     
193.                 /*
     
194.                  * Handle ancillary data, which are impossible
     
195.                  * (or very difficult) to get parsing packet contents.
     
196.                  */
     
197.                 switch (k-SKF_AD_OFF) {
     
198.                 case SKF_AD_PROTOCOL:
     
199.                         A = ntohs(skb->protocol);
     
200.                         continue;
     
201.                 case SKF_AD_PKTTYPE:
     
202.                         A = skb->pkt_type;
     
203.                         continue;
     
204.                 case SKF_AD_IFINDEX:
     
205.                         A = skb->dev->ifindex;
     
206.                         continue;
     
207.                 default:
     
208.                         return 0;
     
209.                 }
     
210.         }
     
211. 
     
212.         return 0;
     
213. }
     

复制代码

这是一个类似有穷状态机的实现方式
个人认为如果 filter 的书写比较单一的话，还是有很高提升空间的
上上周刚结束一个 case，改写了 filter，实现自己的抓包过滤机制，由于规则模式很单一，所以改用 hash 实现，效率比 bpf 高出不少

platinum

另外，bpf 本身就是在 kernel 实现的，他把，且仅把你要的数据 copy 到用户空间
所以你的理解可能存在错误，误以为是所有数据都 copy 到用户空间然后才选择性丢弃的

ubuntuer

原帖由 platinum 于 2010-1-11 15:48 发表
另外，bpf 本身就是在 kernel 实现的，他把，且仅把你要的数据 copy 到用户空间
所以你的理解可能存在错误，误以为是所有数据都 copy 到用户空间然后才选择性丢弃的

呵呵 理解是没错的   可能我上面的描述有误^_^   
谢谢指点  我看看filter.c

emmoblin

bpf就是在内核态过滤。
tcpdump就是用pcap实现的。

速度已经不错了，要是抓包软件无论如何都是要把抓得包copy到用户层的。

如果只是过滤的话，五元组匹配可以通过hash表。不过没测试过bpf的效率

rogge321

回复 1# ubuntuer


   你好，我最近在学习libpcap中的bpf，我的开发环境是CentOS5.5，使用的是libpcap1.2.1
   我一直有个问题很困惑，是不是所有的linux都支持bpf？我在安装libpcap的源码时，看了一下make的输出，
   并没有使用pcap-bpf.c这个文件，当然libpcap是完全可以运行的，也可以抓到数据包，但我不知道是不是使用的bpf的机制？
   您能把您的sniff 的源码发给我一份吗，十分感谢，邮箱rogge321@163.com。