?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
trie: remove useless header comment
[netsniff-ng.git] / bpf_parser.y
blob307066e582872e920cec0a76cfbaf020e1df2c6a
1 /*
2 * netsniff-ng - the packet sniffing beast
3 * By Daniel Borkmann <daniel@netsniff-ng.org>
4 * Copyright 2011 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
5 * Swiss federal institute of technology (ETH Zurich)
6 * Subject to the GPL, version 2.
7 */
8
9 /* yaac-func-prefix: yy */
10
11 %{
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <stdbool.h>
16 #include <signal.h>
17 #include <stdint.h>
18 #include <errno.h>
19 #include <libgen.h>
20
21 #include "bpf.h"
22 #include "str.h"
23 #include "xmalloc.h"
24 #include "bpf_parser.tab.h"
25 #include "built_in.h"
26 #include "die.h"
27 #include "xutils.h"
28
29 #define MAX_INSTRUCTIONS 4096
30
31 int compile_filter(char *file, int verbose, int bypass, int format,
32 bool invoke_cpp);
33
34 static int curr_instr = 0;
35
36 static struct sock_filter out[MAX_INSTRUCTIONS];
37
38 static char *labels[MAX_INSTRUCTIONS];
39
40 static char *labels_jt[MAX_INSTRUCTIONS];
41 static char *labels_jf[MAX_INSTRUCTIONS];
42 static char *labels_k[MAX_INSTRUCTIONS];
43
44 #define YYERROR_VERBOSE 0
45 #define YYDEBUG 0
46 #define YYENABLE_NLS 1
47 #define YYLTYPE_IS_TRIVIAL 1
48 #define ENABLE_NLS 1
49
50 extern FILE *yyin;
51 extern int yylex(void);
52 extern void yyerror(const char *);
53 extern int yylineno;
54 extern char *yytext;
55
56 static inline void check_max_instr(void)
57 {
58 if (curr_instr >= MAX_INSTRUCTIONS)
59 panic("Exceeded maximal number of instructions!\n");
60 }
61
62 static inline void set_curr_instr(uint16_t code, uint8_t jt, uint8_t jf, uint32_t k)
63 {
64 check_max_instr();
65
66 out[curr_instr].code = code;
67 out[curr_instr].jt = jt;
68 out[curr_instr].jf = jf;
69 out[curr_instr].k = k;
70
71 curr_instr++;
72 }
73
74 static inline void set_curr_label(char *label)
75 {
76 check_max_instr();
77
78 labels[curr_instr] = label;
79 }
80
81 #define JTL 1
82 #define JFL 2
83 #define JKL 3
84
85 static inline void set_jmp_label(char *label, int which)
86 {
87 check_max_instr();
88
89 switch (which) {
90 case JTL:
91 labels_jt[curr_instr] = label;
92 break;
93 case JFL:
94 labels_jf[curr_instr] = label;
95 break;
96 case JKL:
97 labels_k[curr_instr] = label;
98 break;
99 default:
100 bug();
101 }
102 }
103
104 static int find_intr_offset_or_panic(char *label_to_search)
105 {
106 int i, max = curr_instr, ret = -ENOENT;
107
108 bug_on(!label_to_search);
109
110 for (i = 0; i < max; ++i) {
111 if (labels[i] != NULL) {
112 /* Both are \0-terminated! */
113 if (!strcmp(label_to_search, labels[i])) {
114 ret = i;
115 break;
116 }
117 }
118 }
119
120 if (ret == -ENOENT)
121 panic("No such label!\n");
122
123 return ret;
124 }
125
126 %}
127
128 %union {
129 char *label;
130 long int number;
131 }
132
133 %token OP_LDB OP_LDH OP_LD OP_LDX OP_ST OP_STX OP_JMP OP_JEQ OP_JGT OP_JGE
134 %token OP_JSET OP_ADD OP_SUB OP_MUL OP_DIV OP_AND OP_OR OP_XOR OP_LSH OP_RSH
135 %token OP_RET OP_TAX OP_TXA OP_LDXB OP_MOD OP_NEG OP_JNEQ OP_JLT OP_JLE OP_LDI
136 %token OP_LDXI
137
138 %token K_PKT_LEN K_PROTO K_TYPE K_NLATTR K_NLATTR_NEST K_MARK K_QUEUE K_HATYPE
139 %token K_RXHASH K_CPU K_IFIDX K_VLANT K_VLANP K_POFF
140
141 %token ':' ',' '[' ']' '(' ')' 'x' 'a' '+' 'M' '*' '&' '#'
142
143 %token number label
144
145 %type <number> number
146 %type <label> label
147
148 %%
149
150 prog
151 : line
152 | prog line
153 ;
154
155 line
156 : instr
157 | labelled_instr
158 ;
159
160 labelled_instr
161 : labelled instr
162 ;
163
164 instr
165 : ldb
166 | ldh
167 | ld
168 | ldi
169 | ldx
170 | ldxi
171 | st
172 | stx
173 | jmp
174 | jeq
175 | jneq
176 | jlt
177 | jle
178 | jgt
179 | jge
180 | jset
181 | add
182 | sub
183 | mul
184 | div
185 | mod
186 | neg
187 | and
188 | or
189 | xor
190 | lsh
191 | rsh
192 | ret
193 | tax
194 | txa
195 ;
196
197 labelled
198 : label ':' { set_curr_label($1); }
199 ;
200
201 ldb
202 : OP_LDB '[' 'x' '+' number ']' {
203 set_curr_instr(BPF_LD | BPF_B | BPF_IND, 0, 0, $5); }
204 | OP_LDB '[' number ']' {
205 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0, $3); }
206 | OP_LDB K_PROTO {
207 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
208 SKF_AD_OFF + SKF_AD_PROTOCOL); }
209 | OP_LDB K_TYPE {
210 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
211 SKF_AD_OFF + SKF_AD_PKTTYPE); }
212 | OP_LDB K_IFIDX {
213 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
214 SKF_AD_OFF + SKF_AD_IFINDEX); }
215 | OP_LDB K_NLATTR {
216 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
217 SKF_AD_OFF + SKF_AD_NLATTR); }
218 | OP_LDB K_NLATTR_NEST {
219 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
220 SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
221 | OP_LDB K_MARK {
222 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
223 SKF_AD_OFF + SKF_AD_MARK); }
224 | OP_LDB K_QUEUE {
225 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
226 SKF_AD_OFF + SKF_AD_QUEUE); }
227 | OP_LDB K_HATYPE {
228 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
229 SKF_AD_OFF + SKF_AD_HATYPE); }
230 | OP_LDB K_RXHASH {
231 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
232 SKF_AD_OFF + SKF_AD_RXHASH); }
233 | OP_LDB K_CPU {
234 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
235 SKF_AD_OFF + SKF_AD_CPU); }
236 | OP_LDB K_VLANT {
237 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
238 SKF_AD_OFF + SKF_AD_VLAN_TAG); }
239 | OP_LDB K_VLANP {
240 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
241 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT); }
242 | OP_LDB K_POFF {
243 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
244 SKF_AD_OFF + SKF_AD_PAY_OFFSET); }
245 ;
246
247 ldh
248 : OP_LDH '[' 'x' '+' number ']' {
249 set_curr_instr(BPF_LD | BPF_H | BPF_IND, 0, 0, $5); }
250 | OP_LDH '[' number ']' {
251 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0, $3); }
252 | OP_LDH K_PROTO {
253 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
254 SKF_AD_OFF + SKF_AD_PROTOCOL); }
255 | OP_LDH K_TYPE {
256 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
257 SKF_AD_OFF + SKF_AD_PKTTYPE); }
258 | OP_LDH K_IFIDX {
259 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
260 SKF_AD_OFF + SKF_AD_IFINDEX); }
261 | OP_LDH K_NLATTR {
262 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
263 SKF_AD_OFF + SKF_AD_NLATTR); }
264 | OP_LDH K_NLATTR_NEST {
265 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
266 SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
267 | OP_LDH K_MARK {
268 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
269 SKF_AD_OFF + SKF_AD_MARK); }
270 | OP_LDH K_QUEUE {
271 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
272 SKF_AD_OFF + SKF_AD_QUEUE); }
273 | OP_LDH K_HATYPE {
274 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
275 SKF_AD_OFF + SKF_AD_HATYPE); }
276 | OP_LDH K_RXHASH {
277 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
278 SKF_AD_OFF + SKF_AD_RXHASH); }
279 | OP_LDH K_CPU {
280 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
281 SKF_AD_OFF + SKF_AD_CPU); }
282 | OP_LDH K_VLANT {
283 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
284 SKF_AD_OFF + SKF_AD_VLAN_TAG); }
285 | OP_LDH K_VLANP {
286 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
287 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT); }
288 | OP_LDH K_POFF {
289 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
290 SKF_AD_OFF + SKF_AD_PAY_OFFSET); }
291 ;
292
293 ldi
294 : OP_LDI number {
295 set_curr_instr(BPF_LD | BPF_IMM, 0, 0, $2); }
296 ;
297
298 ld
299 : OP_LD '#' number {
300 set_curr_instr(BPF_LD | BPF_IMM, 0, 0, $3); }
301 | OP_LD K_PKT_LEN {
302 set_curr_instr(BPF_LD | BPF_W | BPF_LEN, 0, 0, 0); }
303 | OP_LD K_PROTO {
304 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
305 SKF_AD_OFF + SKF_AD_PROTOCOL); }
306 | OP_LD K_TYPE {
307 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
308 SKF_AD_OFF + SKF_AD_PKTTYPE); }
309 | OP_LD K_IFIDX {
310 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
311 SKF_AD_OFF + SKF_AD_IFINDEX); }
312 | OP_LD K_NLATTR {
313 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
314 SKF_AD_OFF + SKF_AD_NLATTR); }
315 | OP_LD K_NLATTR_NEST {
316 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
317 SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
318 | OP_LD K_MARK {
319 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
320 SKF_AD_OFF + SKF_AD_MARK); }
321 | OP_LD K_QUEUE {
322 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
323 SKF_AD_OFF + SKF_AD_QUEUE); }
324 | OP_LD K_HATYPE {
325 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
326 SKF_AD_OFF + SKF_AD_HATYPE); }
327 | OP_LD K_RXHASH {
328 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
329 SKF_AD_OFF + SKF_AD_RXHASH); }
330 | OP_LD K_CPU {
331 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
332 SKF_AD_OFF + SKF_AD_CPU); }
333 | OP_LD K_VLANT {
334 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
335 SKF_AD_OFF + SKF_AD_VLAN_TAG); }
336 | OP_LD K_VLANP {
337 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
338 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT); }
339 | OP_LD K_POFF {
340 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
341 SKF_AD_OFF + SKF_AD_PAY_OFFSET); }
342 | OP_LD 'M' '[' number ']' {
343 set_curr_instr(BPF_LD | BPF_MEM, 0, 0, $4); }
344 | OP_LD '[' 'x' '+' number ']' {
345 set_curr_instr(BPF_LD | BPF_W | BPF_IND, 0, 0, $5); }
346 | OP_LD '[' number ']' {
347 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0, $3); }
348 ;
349
350 ldxi
351 : OP_LDXI number {
352 set_curr_instr(BPF_LDX | BPF_IMM, 0, 0, $2); }
353 ;
354
355 ldx
356 : OP_LDX '#' number {
357 set_curr_instr(BPF_LDX | BPF_IMM, 0, 0, $3); }
358 | OP_LDX 'M' '[' number ']' {
359 set_curr_instr(BPF_LDX | BPF_MEM, 0, 0, $4); }
360 | OP_LDXB number '*' '(' '[' number ']' '&' number ')' {
361 if ($2 != 4 || $9 != 0xf) {
362 panic("ldxb offset not supported!\n");
363 } else {
364 set_curr_instr(BPF_LDX | BPF_MSH | BPF_B, 0, 0, $6); } }
365 | OP_LDX number '*' '(' '[' number ']' '&' number ')' {
366 if ($2 != 4 || $9 != 0xf) {
367 panic("ldxb offset not supported!\n");
368 } else {
369 set_curr_instr(BPF_LDX | BPF_MSH | BPF_B, 0, 0, $6); } }
370 ;
371
372 st
373 : OP_ST 'M' '[' number ']' {
374 set_curr_instr(BPF_ST, 0, 0, $4); }
375 ;
376
377 stx
378 : OP_STX 'M' '[' number ']' {
379 set_curr_instr(BPF_STX, 0, 0, $4); }
380 ;
381
382 jmp
383 : OP_JMP label {
384 set_jmp_label($2, JKL);
385 set_curr_instr(BPF_JMP | BPF_JA, 0, 0, 0); }
386 ;
387
388 jeq
389 : OP_JEQ '#' number ',' label ',' label {
390 set_jmp_label($5, JTL);
391 set_jmp_label($7, JFL);
392 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_K, 0, 0, $3); }
393 | OP_JEQ 'x' ',' label ',' label {
394 set_jmp_label($4, JTL);
395 set_jmp_label($6, JFL);
396 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 0); }
397 | OP_JEQ '#' number ',' label {
398 set_jmp_label($5, JTL);
399 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_K, 0, 0, $3); }
400 | OP_JEQ 'x' ',' label {
401 set_jmp_label($4, JTL);
402 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 0); }
403 ;
404
405 jneq
406 : OP_JNEQ '#' number ',' label {
407 set_jmp_label($5, JFL);
408 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_K, 0, 0, $3); }
409 | OP_JNEQ 'x' ',' label {
410 set_jmp_label($4, JFL);
411 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 0); }
412 ;
413
414 jlt
415 : OP_JLT '#' number ',' label {
416 set_jmp_label($5, JFL);
417 set_curr_instr(BPF_JMP | BPF_JGE | BPF_K, 0, 0, $3); }
418 | OP_JLT 'x' ',' label {
419 set_jmp_label($4, JFL);
420 set_curr_instr(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 0); }
421 ;
422
423 jle
424 : OP_JLE '#' number ',' label {
425 set_jmp_label($5, JFL);
426 set_curr_instr(BPF_JMP | BPF_JGT | BPF_K, 0, 0, $3); }
427 | OP_JLE 'x' ',' label {
428 set_jmp_label($4, JFL);
429 set_curr_instr(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 0); }
430 ;
431
432 jgt
433 : OP_JGT '#' number ',' label ',' label {
434 set_jmp_label($5, JTL);
435 set_jmp_label($7, JFL);
436 set_curr_instr(BPF_JMP | BPF_JGT | BPF_K, 0, 0, $3); }
437 | OP_JGT 'x' ',' label ',' label {
438 set_jmp_label($4, JTL);
439 set_jmp_label($6, JFL);
440 set_curr_instr(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 0); }
441 | OP_JGT '#' number ',' label {
442 set_jmp_label($5, JTL);
443 set_curr_instr(BPF_JMP | BPF_JGT | BPF_K, 0, 0, $3); }
444 | OP_JGT 'x' ',' label {
445 set_jmp_label($4, JTL);
446 set_curr_instr(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 0); }
447 ;
448
449 jge
450 : OP_JGE '#' number ',' label ',' label {
451 set_jmp_label($5, JTL);
452 set_jmp_label($7, JFL);
453 set_curr_instr(BPF_JMP | BPF_JGE | BPF_K, 0, 0, $3); }
454 | OP_JGE 'x' ',' label ',' label {
455 set_jmp_label($4, JTL);
456 set_jmp_label($6, JFL);
457 set_curr_instr(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 0); }
458 | OP_JGE '#' number ',' label {
459 set_jmp_label($5, JTL);
460 set_curr_instr(BPF_JMP | BPF_JGE | BPF_K, 0, 0, $3); }
461 | OP_JGE 'x' ',' label {
462 set_jmp_label($4, JTL);
463 set_curr_instr(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 0); }
464 ;
465
466 jset
467 : OP_JSET '#' number ',' label ',' label {
468 set_jmp_label($5, JTL);
469 set_jmp_label($7, JFL);
470 set_curr_instr(BPF_JMP | BPF_JSET | BPF_K, 0, 0, $3); }
471 | OP_JSET 'x' ',' label ',' label {
472 set_jmp_label($4, JTL);
473 set_jmp_label($6, JFL);
474 set_curr_instr(BPF_JMP | BPF_JSET | BPF_X, 0, 0, 0); }
475 | OP_JSET '#' number ',' label {
476 set_jmp_label($5, JTL);
477 set_curr_instr(BPF_JMP | BPF_JSET | BPF_K, 0, 0, $3); }
478 | OP_JSET 'x' ',' label {
479 set_jmp_label($4, JTL);
480 set_curr_instr(BPF_JMP | BPF_JSET | BPF_X, 0, 0, 0); }
481 ;
482
483 add
484 : OP_ADD '#' number {
485 set_curr_instr(BPF_ALU | BPF_ADD | BPF_K, 0, 0, $3); }
486 | OP_ADD 'x' {
487 set_curr_instr(BPF_ALU | BPF_ADD | BPF_X, 0, 0, 0); }
488 ;
489
490 sub
491 : OP_SUB '#' number {
492 set_curr_instr(BPF_ALU | BPF_SUB | BPF_K, 0, 0, $3); }
493 | OP_SUB 'x' {
494 set_curr_instr(BPF_ALU | BPF_SUB | BPF_X, 0, 0, 0); }
495 ;
496
497 mul
498 : OP_MUL '#' number {
499 set_curr_instr(BPF_ALU | BPF_MUL | BPF_K, 0, 0, $3); }
500 | OP_MUL 'x' {
501 set_curr_instr(BPF_ALU | BPF_MUL | BPF_X, 0, 0, 0); }
502 ;
503
504 div
505 : OP_DIV '#' number {
506 set_curr_instr(BPF_ALU | BPF_DIV | BPF_K, 0, 0, $3); }
507 | OP_DIV 'x' {
508 set_curr_instr(BPF_ALU | BPF_DIV | BPF_X, 0, 0, 0); }
509 ;
510
511 mod
512 : OP_MOD '#' number {
513 set_curr_instr(BPF_ALU | BPF_MOD | BPF_K, 0, 0, $3); }
514 | OP_MOD 'x' {
515 set_curr_instr(BPF_ALU | BPF_MOD | BPF_X, 0, 0, 0); }
516 ;
517
518 neg
519 : OP_NEG {
520 set_curr_instr(BPF_ALU | BPF_NEG, 0, 0, 0); }
521 ;
522
523 and
524 : OP_AND '#' number {
525 set_curr_instr(BPF_ALU | BPF_AND | BPF_K, 0, 0, $3); }
526 | OP_AND 'x' {
527 set_curr_instr(BPF_ALU | BPF_AND | BPF_X, 0, 0, 0); }
528 ;
529
530 or
531 : OP_OR '#' number {
532 set_curr_instr(BPF_ALU | BPF_OR | BPF_K, 0, 0, $3); }
533 | OP_OR 'x' {
534 set_curr_instr(BPF_ALU | BPF_OR | BPF_X, 0, 0, 0); }
535 ;
536
537 xor
538 : OP_XOR '#' number {
539 set_curr_instr(BPF_ALU | BPF_XOR | BPF_K, 0, 0, $3); }
540 | OP_XOR 'x' {
541 set_curr_instr(BPF_ALU | BPF_XOR | BPF_X, 0, 0, 0); }
542 ;
543
544 lsh
545 : OP_LSH '#' number {
546 set_curr_instr(BPF_ALU | BPF_LSH | BPF_K, 0, 0, $3); }
547 | OP_LSH 'x' {
548 set_curr_instr(BPF_ALU | BPF_LSH | BPF_X, 0, 0, 0); }
549 ;
550
551 rsh
552 : OP_RSH '#' number {
553 set_curr_instr(BPF_ALU | BPF_RSH | BPF_K, 0, 0, $3); }
554 | OP_RSH 'x' {
555 set_curr_instr(BPF_ALU | BPF_RSH | BPF_X, 0, 0, 0); }
556 ;
557
558 ret
559 : OP_RET 'a' {
560 set_curr_instr(BPF_RET | BPF_A, 0, 0, 0); }
561 | OP_RET 'x' {
562 set_curr_instr(BPF_RET | BPF_X, 0, 0, 0); }
563 | OP_RET '#' number {
564 set_curr_instr(BPF_RET | BPF_K, 0, 0, $3); }
565 ;
566
567 tax
568 : OP_TAX {
569 set_curr_instr(BPF_MISC | BPF_TAX, 0, 0, 0); }
570 ;
571
572 txa
573 : OP_TXA {
574 set_curr_instr(BPF_MISC | BPF_TXA, 0, 0, 0); }
575 ;
576
577 %%
578
579 static void stage_1_inline(void)
580 {
581 yyparse();
582 }
583
584 static void stage_2_label_reduce(void)
585 {
586 int i, max = curr_instr, off;
587
588 /* 1. reduce k jumps */
589 for (i = 0; i < max; ++i) {
590 if (labels_k[i] != NULL) {
591 off = find_intr_offset_or_panic(labels_k[i]);
592 out[i].k = (uint32_t) (off - i - 1);
593 }
594 }
595
596 /* 1. reduce jt jumps */
597 for (i = 0; i < max; ++i) {
598 if (labels_jt[i] != NULL) {
599 off = find_intr_offset_or_panic(labels_jt[i]);
600 out[i].jt = (uint8_t) (off - i -1);
601 }
602 }
603
604 /* 1. reduce jf jumps */
605 for (i = 0; i < max; ++i) {
606 if (labels_jf[i] != NULL) {
607 off = find_intr_offset_or_panic(labels_jf[i]);
608 out[i].jf = (uint8_t) (off - i - 1);
609 }
610 }
611 }
612
613 static void pretty_printer_c(const struct sock_fprog *prog)
614 {
615 int i;
616
617 for (i = 0; i < prog->len; ++i) {
618 printf("{ 0x%x, %u, %u, 0x%08x },\n",
619 prog->filter[i].code, prog->filter[i].jt,
620 prog->filter[i].jf, prog->filter[i].k);
621 }
622 }
623
624 static void pretty_printer_xt_bpf(const struct sock_fprog *prog)
625 {
626 int i;
627
628 printf("%d,", prog->len);
629 for (i = 0; i < prog->len; ++i) {
630 printf("%u %u %u %u,",
631 prog->filter[i].code, prog->filter[i].jt,
632 prog->filter[i].jf, prog->filter[i].k);
633 }
634
635 fflush(stdout);
636 }
637
638 static void pretty_printer_tcpdump(const struct sock_fprog *prog)
639 {
640 int i;
641
642 for (i = 0; i < prog->len; ++i) {
643 printf("%u %u %u %u\n",
644 prog->filter[i].code, prog->filter[i].jt,
645 prog->filter[i].jf, prog->filter[i].k);
646 }
647 }
648
649 static void pretty_printer(const struct sock_fprog *prog, int format)
650 {
651 switch (format) {
652 case 0:
653 pretty_printer_c(prog);
654 break;
655 case 1:
656 pretty_printer_xt_bpf(prog);
657 break;
658 case 2:
659 pretty_printer_tcpdump(prog);
660 break;
661 default:
662 bug();
663 }
664 }
665
666 int compile_filter(char *file, int verbose, int bypass, int format,
667 bool invoke_cpp)
668 {
669 int i;
670 struct sock_fprog res;
671 char tmp_file[128];
672
673 memset(tmp_file, 0, sizeof(tmp_file));
674
675 if (invoke_cpp) {
676 char cmd[256], *dir, *base, *a, *b;
677
678 dir = dirname((a = xstrdup(file)));
679 base = basename((b = xstrdup(file)));
680
681 slprintf(tmp_file, sizeof(tmp_file), "%s/.tmp-%u-%s", dir, rand(), base);
682 slprintf(cmd, sizeof(cmd), "cpp -I" PREFIX_STRING
683 "/etc/netsniff-ng/ %s > %s", file, tmp_file);
684 system(cmd);
685
686 file = tmp_file;
687 xfree(a);
688 xfree(b);
689 }
690
691 if (!strncmp("-", file, strlen("-")))
692 yyin = stdin;
693 else
694 yyin = fopen(file, "r");
695 if (!yyin)
696 panic("Cannot open file!\n");
697
698 memset(out, 0, sizeof(out));
699 memset(labels, 0, sizeof(labels));
700 memset(labels_jf, 0, sizeof(labels_jf));
701 memset(labels_jt, 0, sizeof(labels_jt));
702 memset(labels_k, 0, sizeof(labels_k));
703
704 stage_1_inline();
705 stage_2_label_reduce();
706
707 res.filter = out;
708 res.len = curr_instr;
709
710 if (verbose) {
711 printf("Generated program:\n");
712 bpf_dump_all(&res);
713 }
714
715 if (!bypass) {
716 if (verbose) {
717 printf("Validating: ");
718 fflush(stdout);
719 }
720
721 if (__bpf_validate(&res) == 0) {
722 if (verbose)
723 printf("Semantic error! BPF validation failed!\n");
724 else
725 panic("Semantic error! BPF validation failed! "
726 "Try -V for debugging output!\n");
727 } else if (verbose) {
728 printf("is runnable!\n");
729 }
730 }
731
732 if (verbose)
733 printf("Result:\n");
734
735 pretty_printer(&res, format);
736
737 for (i = 0; i < res.len; ++i) {
738 free(labels[i]);
739 free(labels_jt[i]);
740 free(labels_jf[i]);
741 free(labels_k[i]);
742 }
743
744 fclose(yyin);
745 if (invoke_cpp)
746 unlink(tmp_file);
747
748 return 0;
749 }
750
751 void yyerror(const char *err)
752 {
753 panic("Syntax error at line %d: %s! %s!\n",
754 yylineno, yytext, err);
755 }
netsniff-ng toolkit, the packet sniffing beast, staging tree