src/bpf_parser.y

   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 %{
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <stdbool.h>
  14 #include <signal.h>
  15 #include <stdint.h>
  16 #include <errno.h>
  17
  18 #include "bpf.h"
  19 #include "xmalloc.h"
  20 #include "bpf_parser.tab.h"
  21 #include "built_in.h"
  22 #include "die.h"
  23
  24 #define MAX_INSTRUCTIONS        4096
  25
  26 int compile_filter(char *file, int verbose, int bypass);
  27
  28 static int curr_instr = 0;
  29
  30 static struct sock_filter out[MAX_INSTRUCTIONS];
  31
  32 static char *labels[MAX_INSTRUCTIONS];
  33
  34 static char *labels_jt[MAX_INSTRUCTIONS];
  35 static char *labels_jf[MAX_INSTRUCTIONS];
  36 static char *labels_k[MAX_INSTRUCTIONS];
  37
  38 #define YYERROR_VERBOSE         0
  39 #define YYDEBUG                 0
  40 #define YYENABLE_NLS            1
  41 #define YYLTYPE_IS_TRIVIAL      1
  42 #define ENABLE_NLS              1
  43
  44 extern FILE *yyin;
  45 extern int yylex(void);
  46 extern void yyerror(const char *);
  47 extern int yylineno;
  48 extern char *yytext;
  49
  50 static inline void set_curr_instr(uint16_t code, uint8_t jt, uint8_t jf, uint32_t k)
  51 {
  52         if (curr_instr >= MAX_INSTRUCTIONS)
  53                 panic("Exceeded maximal number of instructions!\n");
  54
  55         out[curr_instr].code = code;
  56         out[curr_instr].jt = jt;
  57         out[curr_instr].jf = jf;
  58         out[curr_instr].k = k;
  59
  60         curr_instr++;
  61 }
  62
  63 static inline void set_curr_label(char *label)
  64 {
  65         if (curr_instr >= MAX_INSTRUCTIONS)
  66                 panic("Exceeded maximal number of instructions!\n");
  67
  68         labels[curr_instr] = label;
  69 }
  70
  71 #define JTL 1
  72 #define JFL 2
  73 #define JKL 3
  74
  75 static inline void set_jmp_label(char *label, int which)
  76 {
  77         if (curr_instr >= MAX_INSTRUCTIONS)
  78                 panic("Exceeded maximal number of instructions!\n");
  79
  80         bug_on(which != JTL && which != JFL && which != JKL);
  81
  82         if (which == JTL)
  83                 labels_jt[curr_instr] = label;
  84         else if (which == JFL)
  85                 labels_jf[curr_instr] = label;
  86         else
  87                 labels_k[curr_instr] = label;
  88 }
  89
  90 static int find_intr_offset_or_panic(char *label_to_search)
  91 {
  92         int i, max = curr_instr, ret = -ENOENT;
  93
  94         bug_on(!label_to_search);
  95
  96         for (i = 0; i < max; ++i) {
  97                 if (labels[i] != NULL) {
  98                         /* Both are \0-terminated! */
  99                         if (!strcmp(label_to_search, labels[i])) {
 100                                 ret = i;
 101                                 break;
 102                         }
 103                 }
 104         }
 105
 106         if (ret == -ENOENT)
 107                 panic("No such label!\n");
 108
 109         return ret;
 110 }
 111
 112 %}
 113
 114 %union {
 115         char *label;
 116         long int number;
 117 }
 118
 119 %token OP_LDB OP_LDH OP_LD OP_LDX OP_ST OP_STX OP_JMP OP_JEQ OP_JGT OP_JGE
 120 %token OP_JSET OP_ADD OP_SUB OP_MUL OP_DIV OP_AND OP_OR OP_XOR OP_LSH OP_RSH
 121 %token OP_RET OP_TAX OP_TXA OP_LDXB OP_MOD OP_NEG K_PKT_LEN K_PROTO K_TYPE
 122 %token K_NLATTR K_NLATTR_NEST K_MARK K_QUEUE K_HATYPE K_RXHASH K_CPU K_COMMENT
 123 %token K_IFIDX
 124
 125 %token ':' ',' '[' ']' '(' ')' 'x' 'a' '+' 'M' '*' '&' '#'
 126
 127 %token number_hex number_dec number_oct number_bin label comment
 128
 129 %type <number> number_hex number_dec number_oct number_bin number
 130 %type <label> label
 131
 132 %%
 133
 134 prog
 135         : {}
 136         | prog line { }
 137         ;
 138
 139 line
 140         : instr { }
 141         | labeled_instr { }
 142         ;
 143
 144 labeled_instr
 145         : do_label instr { }
 146         ;
 147
 148 instr
 149         : do_ldb { }
 150         | do_ldh { }
 151         | do_ld { }
 152         | do_ldx { }
 153         | do_st { }
 154         | do_stx { }
 155         | do_jmp { }
 156         | do_jeq { }
 157         | do_jgt { }
 158         | do_jge { }
 159         | do_jset { }
 160         | do_add { }
 161         | do_sub { }
 162         | do_mul { }
 163         | do_div { }
 164         | do_mod { }
 165         | do_neg { }
 166         | do_and { }
 167         | do_or { }
 168         | do_xor { }
 169         | do_lsh { }
 170         | do_rsh { }
 171         | do_ret { }
 172         | do_tax { }
 173         | do_txa { }
 174         | do_comment { }
 175         ;
 176
 177 number
 178         : number_dec { $$ = $1; }
 179         | number_hex { $$ = $1; }
 180         | number_oct { $$ = $1; }
 181         | number_bin { $$ = $1; }
 182         ;
 183
 184 do_comment
 185         : K_COMMENT { }
 186         ;
 187
 188 do_label
 189         : label ':' { set_curr_label($1); }
 190         ;
 191
 192 do_ldb
 193         : OP_LDB '[' 'x' '+' number ']' {
 194                 set_curr_instr(BPF_LD | BPF_B | BPF_IND, 0, 0, $5); }
 195         | OP_LDB '[' number ']' {
 196                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0, $3); }
 197         | OP_LDB '#' K_PROTO {
 198                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 199                                SKF_AD_OFF + SKF_AD_PROTOCOL); }
 200         | OP_LDB '#' K_TYPE {
 201                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 202                                SKF_AD_OFF + SKF_AD_PKTTYPE); }
 203         | OP_LDB '#' K_IFIDX {
 204                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 205                                SKF_AD_OFF + SKF_AD_IFINDEX); }
 206         | OP_LDB '#' K_NLATTR {
 207                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 208                                SKF_AD_OFF + SKF_AD_NLATTR); }
 209         | OP_LDB '#' K_NLATTR_NEST {
 210                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 211                                SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
 212         | OP_LDB '#' K_MARK {
 213                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 214                                SKF_AD_OFF + SKF_AD_MARK); }
 215         | OP_LDB '#' K_QUEUE {
 216                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 217                                SKF_AD_OFF + SKF_AD_QUEUE); }
 218         | OP_LDB '#' K_HATYPE {
 219                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 220                                SKF_AD_OFF + SKF_AD_HATYPE); }
 221         | OP_LDB '#' K_RXHASH {
 222                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 223                                SKF_AD_OFF + SKF_AD_RXHASH); }
 224         | OP_LDB '#' K_CPU {
 225                 set_curr_instr(BPF_LD | BPF_B | BPF_ABS, 0, 0,
 226                                SKF_AD_OFF + SKF_AD_CPU); }
 227         ;
 228
 229 do_ldh
 230         : OP_LDH '[' 'x' '+' number ']' {
 231                 set_curr_instr(BPF_LD | BPF_H | BPF_IND, 0, 0, $5); }
 232         | OP_LDH '[' number ']' {
 233                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0, $3); }
 234         | OP_LDH '#' K_PROTO {
 235                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 236                                SKF_AD_OFF + SKF_AD_PROTOCOL); }
 237         | OP_LDH '#' K_TYPE {
 238                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 239                                SKF_AD_OFF + SKF_AD_PKTTYPE); }
 240         | OP_LDH '#' K_IFIDX {
 241                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 242                                SKF_AD_OFF + SKF_AD_IFINDEX); }
 243         | OP_LDH '#' K_NLATTR {
 244                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 245                                SKF_AD_OFF + SKF_AD_NLATTR); }
 246         | OP_LDH '#' K_NLATTR_NEST {
 247                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 248                                SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
 249         | OP_LDH '#' K_MARK {
 250                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 251                                SKF_AD_OFF + SKF_AD_MARK); }
 252         | OP_LDH '#' K_QUEUE {
 253                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 254                                SKF_AD_OFF + SKF_AD_QUEUE); }
 255         | OP_LDH '#' K_HATYPE {
 256                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 257                                SKF_AD_OFF + SKF_AD_HATYPE); }
 258         | OP_LDH '#' K_RXHASH {
 259                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 260                                SKF_AD_OFF + SKF_AD_RXHASH); }
 261         | OP_LDH '#' K_CPU {
 262                 set_curr_instr(BPF_LD | BPF_H | BPF_ABS, 0, 0,
 263                                SKF_AD_OFF + SKF_AD_CPU); }
 264         ;
 265
 266 do_ld
 267         : OP_LD '#' number {
 268                 set_curr_instr(BPF_LD | BPF_IMM, 0, 0, $3); }
 269         | OP_LD '#' K_PKT_LEN {
 270                 set_curr_instr(BPF_LD | BPF_W | BPF_LEN, 0, 0, 0); }
 271         | OP_LD '#' K_PROTO {
 272                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 273                                SKF_AD_OFF + SKF_AD_PROTOCOL); }
 274         | OP_LD '#' K_TYPE {
 275                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 276                                SKF_AD_OFF + SKF_AD_PKTTYPE); }
 277         | OP_LD '#' K_IFIDX {
 278                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 279                                SKF_AD_OFF + SKF_AD_IFINDEX); }
 280         | OP_LD '#' K_NLATTR {
 281                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 282                                SKF_AD_OFF + SKF_AD_NLATTR); }
 283         | OP_LD '#' K_NLATTR_NEST {
 284                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 285                                SKF_AD_OFF + SKF_AD_NLATTR_NEST); }
 286         | OP_LD '#' K_MARK {
 287                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 288                                SKF_AD_OFF + SKF_AD_MARK); }
 289         | OP_LD '#' K_QUEUE {
 290                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 291                                SKF_AD_OFF + SKF_AD_QUEUE); }
 292         | OP_LD '#' K_HATYPE {
 293                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 294                                SKF_AD_OFF + SKF_AD_HATYPE); }
 295         | OP_LD '#' K_RXHASH {
 296                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 297                                SKF_AD_OFF + SKF_AD_RXHASH); }
 298         | OP_LD '#' K_CPU {
 299                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0,
 300                                SKF_AD_OFF + SKF_AD_CPU); }
 301         | OP_LD 'M' '[' number ']' {
 302                 set_curr_instr(BPF_LD | BPF_MEM, 0, 0, $4); }
 303         | OP_LD '[' 'x' '+' number ']' {
 304                 set_curr_instr(BPF_LD | BPF_W | BPF_IND, 0, 0, $5); }
 305         | OP_LD '[' number ']' {
 306                 set_curr_instr(BPF_LD | BPF_W | BPF_ABS, 0, 0, $3); }
 307         ;
 308
 309 do_ldx
 310         : OP_LDX '#' number {
 311                 set_curr_instr(BPF_LDX | BPF_IMM, 0, 0, $3); }
 312         | OP_LDX 'M' '[' number ']' {
 313                 set_curr_instr(BPF_LDX | BPF_MEM, 0, 0, $4); }
 314         | OP_LDXB number '*' '(' '[' number ']' '&' number ')' {
 315                 if ($2 != 4 || $9 != 0xf) {
 316                         panic("ldxb offset not supported!\n");
 317                 } else {
 318                         set_curr_instr(BPF_LDX | BPF_MSH | BPF_B, 0, 0, $6); } }
 319         | OP_LDX number '*' '(' '[' number ']' '&' number ')' {
 320                 if ($2 != 4 || $9 != 0xf) {
 321                         panic("ldxb offset not supported!\n");
 322                 } else {
 323                         set_curr_instr(BPF_LDX | BPF_MSH | BPF_B, 0, 0, $6); } }
 324         ;
 325
 326 do_st
 327         : OP_ST 'M' '[' number ']' {
 328                 set_curr_instr(BPF_ST, 0, 0, $4); }
 329         ;
 330
 331 do_stx
 332         : OP_STX 'M' '[' number ']' {
 333                 set_curr_instr(BPF_STX, 0, 0, $4); }
 334         ;
 335
 336 do_jmp
 337         : OP_JMP label {
 338                 set_jmp_label($2, JKL);
 339                 set_curr_instr(BPF_JMP | BPF_JA, 0, 0, 0); }
 340         ;
 341
 342 do_jeq
 343         : OP_JEQ '#' number ',' label ',' label {
 344                 set_jmp_label($5, JTL);
 345                 set_jmp_label($7, JFL);
 346                 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_K, 0, 0, $3); }
 347         | OP_JEQ 'x' ',' label ',' label {
 348                 set_jmp_label($4, JTL);
 349                 set_jmp_label($6, JFL);
 350                 set_curr_instr(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 0); }
 351         ;
 352
 353 do_jgt
 354         : OP_JGT '#' number ',' label ',' label {
 355                 set_jmp_label($5, JTL);
 356                 set_jmp_label($7, JFL);
 357                 set_curr_instr(BPF_JMP | BPF_JGT | BPF_K, 0, 0, $3); }
 358         | OP_JGT 'x' ',' label ',' label {
 359                 set_jmp_label($4, JTL);
 360                 set_jmp_label($6, JFL);
 361                 set_curr_instr(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 0); }
 362         ;
 363
 364 do_jge
 365         : OP_JGE '#' number ',' label ',' label {
 366                 set_jmp_label($5, JTL);
 367                 set_jmp_label($7, JFL);
 368                 set_curr_instr(BPF_JMP | BPF_JGE | BPF_K, 0, 0, $3); }
 369         | OP_JGE 'x' ',' label ',' label {
 370                 set_jmp_label($4, JTL);
 371                 set_jmp_label($6, JFL);
 372                 set_curr_instr(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 0); }
 373         ;
 374
 375 do_jset
 376         : OP_JSET '#' number ',' label ',' label {
 377                 set_jmp_label($5, JTL);
 378                 set_jmp_label($7, JFL);
 379                 set_curr_instr(BPF_JMP | BPF_JSET | BPF_K, 0, 0, $3); }
 380         | OP_JSET 'x' ',' label ',' label {
 381                 set_jmp_label($4, JTL);
 382                 set_jmp_label($6, JFL);
 383                 set_curr_instr(BPF_JMP | BPF_JSET | BPF_X, 0, 0, 0); }
 384         ;
 385
 386 do_add
 387         : OP_ADD '#' number {
 388                 set_curr_instr(BPF_ALU | BPF_ADD | BPF_K, 0, 0, $3); }
 389         | OP_ADD 'x' {
 390                 set_curr_instr(BPF_ALU | BPF_ADD | BPF_X, 0, 0, 0); }
 391         ;
 392
 393 do_sub
 394         : OP_SUB '#' number {
 395                 set_curr_instr(BPF_ALU | BPF_SUB | BPF_K, 0, 0, $3); }
 396         | OP_SUB 'x' {
 397                 set_curr_instr(BPF_ALU | BPF_SUB | BPF_X, 0, 0, 0); }
 398         ;
 399
 400 do_mul
 401         : OP_MUL '#' number {
 402                 set_curr_instr(BPF_ALU | BPF_MUL | BPF_K, 0, 0, $3); }
 403         | OP_MUL 'x' {
 404                 set_curr_instr(BPF_ALU | BPF_MUL | BPF_X, 0, 0, 0); }
 405         ;
 406
 407 do_div
 408         : OP_DIV '#' number {
 409                 set_curr_instr(BPF_ALU | BPF_DIV | BPF_K, 0, 0, $3); }
 410         | OP_DIV 'x' {
 411                 set_curr_instr(BPF_ALU | BPF_DIV | BPF_X, 0, 0, 0); }
 412         ;
 413
 414 do_mod
 415         : OP_MOD '#' number {
 416                 set_curr_instr(BPF_ALU | BPF_MOD | BPF_K, 0, 0, $3); }
 417         | OP_MOD 'x' {
 418                 set_curr_instr(BPF_ALU | BPF_MOD | BPF_X, 0, 0, 0); }
 419         ;
 420
 421 do_neg
 422         : OP_NEG {
 423                 set_curr_instr(BPF_ALU | BPF_NEG, 0, 0, 0); }
 424         ;
 425
 426 do_and
 427         : OP_AND '#' number {
 428                 set_curr_instr(BPF_ALU | BPF_AND | BPF_K, 0, 0, $3); }
 429         | OP_AND 'x' {
 430                 set_curr_instr(BPF_ALU | BPF_AND | BPF_X, 0, 0, 0); }
 431         ;
 432
 433 do_or
 434         : OP_OR '#' number {
 435                 set_curr_instr(BPF_ALU | BPF_OR | BPF_K, 0, 0, $3); }
 436         | OP_OR 'x' {
 437                 set_curr_instr(BPF_ALU | BPF_OR | BPF_X, 0, 0, 0); }
 438         ;
 439
 440 do_xor
 441         : OP_XOR '#' number {
 442                 set_curr_instr(BPF_ALU | BPF_XOR | BPF_K, 0, 0, $3); }
 443         | OP_XOR 'x' {
 444                 set_curr_instr(BPF_ALU | BPF_XOR | BPF_X, 0, 0, 0); }
 445         ;
 446
 447 do_lsh
 448         : OP_LSH '#' number {
 449                 set_curr_instr(BPF_ALU | BPF_LSH | BPF_K, 0, 0, $3); }
 450         | OP_LSH 'x' {
 451                 set_curr_instr(BPF_ALU | BPF_LSH | BPF_X, 0, 0, 0); }
 452         ;
 453
 454 do_rsh
 455         : OP_RSH '#' number {
 456                 set_curr_instr(BPF_ALU | BPF_RSH | BPF_K, 0, 0, $3); }
 457         | OP_RSH 'x' {
 458                 set_curr_instr(BPF_ALU | BPF_RSH | BPF_X, 0, 0, 0); }
 459         ;
 460
 461 do_ret
 462         : OP_RET 'a' {
 463                 set_curr_instr(BPF_RET | BPF_A, 0, 0, 0); }
 464         | OP_RET '#' number {
 465                 set_curr_instr(BPF_RET | BPF_K, 0, 0, $3); }
 466         ;
 467
 468 do_tax
 469         : OP_TAX {
 470                 set_curr_instr(BPF_MISC | BPF_TAX, 0, 0, 0); }
 471         ;
 472
 473 do_txa
 474         : OP_TXA {
 475                 set_curr_instr(BPF_MISC | BPF_TXA, 0, 0, 0); }
 476         ;
 477
 478 %%
 479
 480 static void stage_1_inline(void)
 481 {
 482         yyparse();
 483 }
 484
 485 static void stage_2_label_reduce(void)
 486 {
 487         int i, max = curr_instr, off;
 488
 489         /* 1. reduce k jumps */
 490         for (i = 0; i < max; ++i) {
 491                 if (labels_k[i] != NULL) {
 492                         off = find_intr_offset_or_panic(labels_k[i]);
 493                         out[i].k = (uint32_t) (off - i - 1);
 494                 }
 495         }
 496
 497         /* 1. reduce jt jumps */
 498         for (i = 0; i < max; ++i) {
 499                 if (labels_jt[i] != NULL) {
 500                         off = find_intr_offset_or_panic(labels_jt[i]);
 501                         out[i].jt = (uint8_t) (off - i -1);
 502                 }
 503         }
 504
 505         /* 1. reduce jf jumps */
 506         for (i = 0; i < max; ++i) {
 507                 if (labels_jf[i] != NULL) {
 508                         off = find_intr_offset_or_panic(labels_jf[i]);
 509                         out[i].jf = (uint8_t) (off - i - 1);
 510                 }
 511         }
 512 }
 513
 514 int compile_filter(char *file, int verbose, int bypass)
 515 {
 516         int i;
 517         struct sock_fprog res;
 518
 519         yyin = fopen(file, "r");
 520         if (!yyin)
 521                 panic("Cannot open file!\n");
 522
 523         memset(out, 0, sizeof(out));
 524         memset(labels, 0, sizeof(labels));
 525         memset(labels_jf, 0, sizeof(labels_jf));
 526         memset(labels_jt, 0, sizeof(labels_jt));
 527         memset(labels_k, 0, sizeof(labels_k));
 528
 529         stage_1_inline();
 530         stage_2_label_reduce();
 531
 532         res.filter = out;
 533         res.len = curr_instr;
 534
 535         if (verbose) {
 536                 printf("Generated program:\n");
 537                 bpf_dump_all(&res);
 538         }
 539
 540         if (!bypass) {
 541                 if (verbose) {
 542                         printf("Validating: ");
 543                         fflush(stdout);
 544                 }
 545
 546                 if (bpf_validate(&res) == 0) {
 547                         if (verbose)
 548                                 whine("Semantic error! BPF validation "
 549                                       "failed!\n");
 550                         else
 551                                 panic("Semantic error! BPF validation failed! "
 552                                       "Try -V for debugging output!\n");
 553                 } else if (verbose) {
 554                         printf("is runnable!\n");
 555                 }
 556         }
 557
 558         if (verbose)
 559                 printf("Result:\n");
 560         for (i = 0; i < res.len; ++i) {
 561                 printf("{ 0x%x, %u, %u, 0x%08x },\n",
 562                        res.filter[i].code, res.filter[i].jt,
 563                        res.filter[i].jf, res.filter[i].k);
 564                 if (labels[i] != NULL)
 565                         xfree(labels[i]);
 566                 if (labels_jt[i] != NULL)
 567                         xfree(labels_jt[i]);
 568                 if (labels_jf[i] != NULL)
 569                         xfree(labels_jf[i]);
 570                 if (labels_k[i] != NULL)
 571                         xfree(labels_k[i]);
 572         }
 573
 574         fclose(yyin);
 575         return 0;
 576 }
 577
 578 void yyerror(const char *err)
 579 {
 580         panic("Syntax error at line %d: %s! %s!\n",
 581               yylineno, yytext, err);
 582 }