epan/dfilter/grammar.lemon

   1
   2 %include {
   3 #include "config.h"
   4 #define WS_LOG_DOMAIN LOG_DOMAIN_DFILTER
   5
   6 #include <assert.h>
   7
   8 #include "dfilter-int.h"
   9 #include "syntax-tree.h"
  10 #include "sttype-field.h"
  11 #include "sttype-slice.h"
  12 #include "sttype-op.h"
  13 #include "sttype-function.h"
  14 #include "sttype-set.h"
  15 #include "drange.h"
  16 #include <epan/strutil.h>
  17
  18 #include "grammar.h"
  19
  20 #ifdef _MSC_VER
  21 #pragma warning(disable:4671)
  22 #endif
  23
  24 static stnode_t *
  25 new_reference(dfsyntax_t *dfs, stnode_t *node);
  26
  27 static stnode_t *
  28 new_function(dfsyntax_t *dfs, stnode_t *node);
  29
  30 static stnode_t *
  31 resolve_unparsed(dfsyntax_t *dfs, stnode_t *node);
  32
  33 #define FAIL(dfs, node, ...) \
  34     do { \
  35         ws_noisy("Parsing failed here."); \
  36         dfilter_fail(dfs, DF_ERROR_GENERIC, stnode_location(node), __VA_ARGS__); \
  37     } while (0)
  38
  39 DIAG_OFF_LEMON()
  40 } /* end of %include */
  41
  42 %code {
  43 DIAG_ON_LEMON()
  44 }
  45
  46 /* Parser Information */
  47 %name           Dfilter
  48 %token_prefix   TOKEN_
  49 %extra_argument {dfsyntax_t *dfs}
  50
  51 /* Terminal and Non-Terminal types and destructors */
  52 %token_type                     {stnode_t*}
  53 %token_destructor               {
  54     (void)dfs;
  55     stnode_free($$);
  56 }
  57
  58 %default_type                   {stnode_t*}
  59 %default_destructor             {stnode_free($$);}
  60
  61 %type           range_node_list {GSList*}
  62 %destructor     range_node_list {drange_node_free_list($$);}
  63
  64 %type           func_params_list {GSList*}
  65 %destructor     func_params_list {st_funcparams_free($$);}
  66
  67 %type           set_list        {GSList*}
  68 %destructor     set_list        {set_nodelist_free($$);}
  69
  70 %type           set_element_list {GSList*}
  71 %destructor     set_element_list {set_nodelist_free($$);}
  72
  73 /* This is called as soon as a syntax error happens. After that,
  74 any "error" symbols are shifted, if possible. */
  75 %syntax_error {
  76     if (!TOKEN) {
  77         dfilter_fail(dfs, DF_ERROR_UNEXPECTED_END, DFILTER_LOC_EMPTY, "Unexpected end of filter expression.");
  78         return;
  79     }
  80     FAIL(dfs, TOKEN, "\"%s\" was unexpected in this context.", stnode_token(TOKEN));
  81 }
  82
  83 /* ----------------- The grammar -------------- */
  84
  85 /* Associativity */
  86 %left TEST_OR.
  87 %left TEST_XOR.
  88 %left TEST_AND.
  89 %right TEST_NOT.
  90 %nonassoc TEST_ALL_EQ TEST_ANY_EQ TEST_ALL_NE TEST_ANY_NE TEST_LT TEST_LE TEST_GT TEST_GE
  91             TEST_CONTAINS TEST_MATCHES.
  92 %left BITWISE_AND.
  93 %left PLUS MINUS.
  94 %left STAR RSLASH PERCENT.
  95 %nonassoc UNARY_PLUS UNARY_MINUS.
  96
  97 /* Top-level targets */
  98 sentence ::= expr(X).           { dfs->st_root = X; }
  99 sentence ::= .                  { dfs->st_root = NULL; }
 100
 101 expr(X) ::= relation(R).        { X = R; }
 102 expr(X) ::= arithmetic_expr(E). { X = E; }
 103
 104 /* Logical tests */
 105 expr(X) ::= expr(Y) TEST_AND(T) expr(Z).
 106 {
 107     X = T;
 108     sttype_oper_set2(X, STNODE_OP_AND, Y, Z);
 109     stnode_merge_location(X, Y, Z);
 110 }
 111
 112 expr(X) ::= expr(Y) TEST_OR(T) expr(Z).
 113 {
 114     X = T;
 115     sttype_oper_set2(X, STNODE_OP_OR, Y, Z);
 116     stnode_merge_location(X, Y, Z);
 117 }
 118
 119 expr(X) ::= expr(Y) TEST_XOR(T) expr(Z).
 120 {
 121     stnode_t *A = stnode_new(STTYPE_TEST, NULL, NULL, DFILTER_LOC_EMPTY);
 122     sttype_oper_set2(A, STNODE_OP_OR, stnode_dup(Y), stnode_dup(Z));
 123
 124     stnode_t *B = stnode_new(STTYPE_TEST, NULL, NULL, DFILTER_LOC_EMPTY);
 125     sttype_oper_set2(B, STNODE_OP_AND, Y, Z);
 126
 127     stnode_t *C = stnode_new(STTYPE_TEST, NULL, NULL, DFILTER_LOC_EMPTY);
 128     sttype_oper_set1(C, STNODE_OP_NOT, B);
 129
 130     X = T;
 131     sttype_oper_set2(X, STNODE_OP_AND, A, C);
 132     stnode_merge_location(X, Y, Z);
 133 }
 134
 135 expr(X) ::= TEST_NOT(T) expr(Y).
 136 {
 137     X = T;
 138     sttype_oper_set1(X, STNODE_OP_NOT, Y);
 139     stnode_merge_location(X, T, Y);
 140 }
 141
 142 /* Any expression inside parens is simply that expression */
 143 expr(X) ::= LPAREN(L) expr(Y) RPAREN(R).
 144 {
 145     X = Y;
 146     stnode_merge_location(X, L, R);
 147     stnode_free(L);
 148     stnode_free(R);
 149 }
 150
 151 /* Entities, or things that can be compared/tested/checked */
 152 atom(A) ::= STRING(S).      { A = S; }
 153 atom(A) ::= CHARCONST(N).   { A = N; }
 154 atom(A) ::= LITERAL(S).     { A = S; }
 155 atom(A) ::= NUMBER(N).      { A = N; }
 156
 157 %code {
 158     static stnode_t *
 159     resolve_unparsed(dfsyntax_t *dfs, stnode_t *node)
 160     {
 161         if (stnode_type_id(node) != STTYPE_UNPARSED) {
 162             ws_assert(stnode_type_id(node) == STTYPE_FIELD);
 163             return node;
 164         }
 165         const char *name = stnode_token(node);
 166         header_field_info *hfinfo = dfilter_resolve_unparsed(name, dfs->deprecated);
 167         if (hfinfo == NULL) {
 168             FAIL(dfs, node, "\"%s\" is not a valid protocol or protocol field.", name);
 169         }
 170         stnode_replace(node, STTYPE_FIELD, hfinfo); // NULL is OK here, we will fail later
 171         return node;
 172     }
 173 }
 174
 175 field(X) ::= FIELD(F).      { X = F; }
 176 field(X) ::= IDENTIFIER(U). { X = U; }
 177 field(X) ::= UNPARSED(U).   { X = U; }
 178
 179 layered_field(X) ::= field(F).
 180 {
 181     X = F;
 182 }
 183
 184 layered_field(X) ::= field(F) HASH LBRACKET range_node_list(L) RBRACKET(R).
 185 {
 186     X = resolve_unparsed(dfs, F);
 187     sttype_field_set_range(X, L);
 188     g_slist_free(L);
 189     stnode_merge_location(X, F, R);
 190     stnode_free(R);
 191 }
 192
 193 layered_field(X) ::= field(F) HASH INDEX(N).
 194 {
 195     X = resolve_unparsed(dfs, F);
 196     char *err_msg = NULL;
 197     drange_node *range = drange_node_from_str(stnode_token(N), &err_msg);
 198     if (err_msg != NULL) {
 199         FAIL(dfs, N, "%s", err_msg);
 200         g_free(err_msg);
 201     }
 202     sttype_field_set_range1(X, range);
 203     stnode_merge_location(X, F, N);
 204     stnode_free(N);
 205 }
 206
 207 rawable_field(X) ::= layered_field(F).
 208 {
 209     X = F;
 210 }
 211
 212 rawable_field(X) ::= ATSIGN(A) layered_field(F).
 213 {
 214     X = resolve_unparsed(dfs, F);
 215     sttype_field_set_raw(X, true);
 216     stnode_merge_location(X, A, F);
 217     stnode_free(A);
 218 }
 219
 220 %code {
 221     static stnode_t *
 222     new_reference(dfsyntax_t *dfs _U_, stnode_t *node)
 223     {
 224         /* convert field to reference */
 225
 226         stnode_t *ref = stnode_new(STTYPE_REFERENCE, sttype_field_hfinfo(node), g_strdup(stnode_token(node)), stnode_location(node));
 227         sttype_field_set_drange(ref, sttype_field_drange_steal(node));
 228         sttype_field_set_raw(ref, sttype_field_raw(node));
 229         return ref;
 230     }
 231 }
 232
 233 reference(X) ::= DOLLAR(D) LBRACE rawable_field(F) RBRACE(R).
 234 {
 235     F = resolve_unparsed(dfs, F);
 236     X = new_reference(dfs, F);
 237     stnode_merge_location(X, D, R);
 238     stnode_free(F);
 239     stnode_free(D);
 240     stnode_free(R);
 241 }
 242
 243 reference(X) ::= DOLLAR(D) rawable_field(F).
 244 {
 245     F = resolve_unparsed(dfs, F);
 246     X = new_reference(dfs, F);
 247     stnode_merge_location(X, D, F);
 248     stnode_free(F);
 249     stnode_free(D);
 250 }
 251
 252 entity(E) ::= atom(A).          { E = A; }
 253 entity(E) ::= slice(R).         { E = R; }
 254 entity(E) ::= function(F).      { E = F; }
 255 entity(E) ::= rawable_field(F). { E = F; }
 256 entity(E) ::= reference(R).     { E = R; }
 257
 258 arithmetic_expr(T) ::= entity(N).
 259 {
 260     T = N;
 261 }
 262
 263 arithmetic_expr(T) ::= PLUS(P) arithmetic_expr(N).  [UNARY_PLUS]
 264 {
 265     T = N;
 266     stnode_merge_location(T, P, N);
 267     stnode_free(P);
 268 }
 269
 270 arithmetic_expr(T) ::= MINUS(M) arithmetic_expr(N). [UNARY_MINUS]
 271 {
 272     T = M;
 273     sttype_oper_set1(T, STNODE_OP_UNARY_MINUS, N);
 274     stnode_merge_location(T, M, N);
 275 }
 276
 277 arithmetic_expr(T) ::= arithmetic_expr(F) BITWISE_AND(O) arithmetic_expr(M).
 278 {
 279     T = O;
 280     sttype_oper_set2(T, STNODE_OP_BITWISE_AND, F, M);
 281     stnode_merge_location(T, F, M);
 282 }
 283
 284 arithmetic_expr(T) ::= arithmetic_expr(F) PLUS(O) arithmetic_expr(M).
 285 {
 286     T = O;
 287     sttype_oper_set2(T, STNODE_OP_ADD, F, M);
 288     stnode_merge_location(T, F, M);
 289 }
 290
 291 arithmetic_expr(T) ::= arithmetic_expr(F) MINUS(O) arithmetic_expr(M).
 292 {
 293     T = O;
 294     sttype_oper_set2(T, STNODE_OP_SUBTRACT, F, M);
 295     stnode_merge_location(T, F, M);
 296 }
 297
 298 arithmetic_expr(T) ::= arithmetic_expr(F) STAR(O) arithmetic_expr(M).
 299 {
 300     T = O;
 301     sttype_oper_set2(T, STNODE_OP_MULTIPLY, F, M);
 302     stnode_merge_location(T, F, M);
 303 }
 304
 305 arithmetic_expr(T) ::= arithmetic_expr(F) RSLASH(O) arithmetic_expr(M).
 306 {
 307     T = O;
 308     sttype_oper_set2(T, STNODE_OP_DIVIDE, F, M);
 309     stnode_merge_location(T, F, M);
 310 }
 311
 312 arithmetic_expr(T) ::= arithmetic_expr(F) PERCENT(O) arithmetic_expr(M).
 313 {
 314     T = O;
 315     sttype_oper_set2(T, STNODE_OP_MODULO, F, M);
 316     stnode_merge_location(T, F, M);
 317 }
 318
 319 arithmetic_expr(T) ::= LBRACE(L) arithmetic_expr(F) RBRACE(R).
 320 {
 321     T = F;
 322     stnode_merge_location(T, L, R);
 323     stnode_free(L);
 324     stnode_free(R);
 325 }
 326
 327 /* Relational tests */
 328 cmp_op(O) ::= TEST_ALL_EQ(L).
 329 {
 330     O = L;
 331     sttype_oper_set_op(O, STNODE_OP_ALL_EQ);
 332 }
 333
 334 cmp_op(O) ::= TEST_ANY_EQ(L).
 335 {
 336     O = L;
 337     sttype_oper_set_op(O, STNODE_OP_ANY_EQ);
 338 }
 339
 340 cmp_op(O) ::= TEST_ALL_NE(L).
 341 {
 342     O = L;
 343     sttype_oper_set_op(O, STNODE_OP_ALL_NE);
 344 }
 345
 346 cmp_op(O) ::= TEST_ANY_NE(L).
 347 {
 348     O = L;
 349     sttype_oper_set_op(O, STNODE_OP_ANY_NE);
 350 }
 351
 352 cmp_op(O) ::= TEST_GT(L).
 353 {
 354     O = L;
 355     sttype_oper_set_op(O, STNODE_OP_GT);
 356 }
 357
 358 cmp_op(O) ::= TEST_GE(L).
 359 {
 360     O = L;
 361     sttype_oper_set_op(O, STNODE_OP_GE);
 362 }
 363
 364 cmp_op(O) ::= TEST_LT(L).
 365 {
 366     O = L;
 367     sttype_oper_set_op(O, STNODE_OP_LT);
 368 }
 369
 370 cmp_op(O) ::= TEST_LE(L).
 371 {
 372     O = L;
 373     sttype_oper_set_op(O, STNODE_OP_LE);
 374 }
 375
 376 comparison_test(T) ::= arithmetic_expr(E) cmp_op(O) arithmetic_expr(F).
 377 {
 378     T = O;
 379     sttype_oper_set2_args(O, E, F);
 380     stnode_merge_location(T, E, F);
 381 }
 382
 383 /* 'a == b == c' or 'a < b <= c <= d < e' */
 384 comparison_test(T) ::= arithmetic_expr(E) cmp_op(O) comparison_test(R).
 385 {
 386     stnode_t *L, *F;
 387
 388     F = R;
 389     while (stnode_type_id(F) == STTYPE_TEST) {
 390         sttype_oper_get(F, NULL, &F, NULL);
 391     }
 392
 393     L = O;
 394     sttype_oper_set2_args(L, E, stnode_dup(F));
 395
 396     T = stnode_new_empty(STTYPE_TEST);
 397     sttype_oper_set2(T, STNODE_OP_AND, L, R);
 398     stnode_merge_location(T, E, R);
 399 }
 400
 401 relation_test(T) ::= comparison_test(C).    { T = C; }
 402
 403 relation_test(T) ::= entity(E) TEST_CONTAINS(L) entity(F).
 404 {
 405     T = L;
 406     sttype_oper_set2(T, STNODE_OP_CONTAINS, E, F);
 407     stnode_merge_location(T, E, F);
 408 }
 409
 410 relation_test(T) ::= entity(E) TEST_MATCHES(L) entity(F).
 411 {
 412     T = L;
 413     sttype_oper_set2(T, STNODE_OP_MATCHES, E, F);
 414     stnode_merge_location(T, E, F);
 415 }
 416
 417 relation_test(T) ::= entity(E) TEST_IN(O) set(S).
 418 {
 419     T = O;
 420     sttype_oper_set2(T, STNODE_OP_IN, E, S);
 421     stnode_merge_location(T, E, S);
 422 }
 423
 424 relation_test(T) ::= entity(E) TEST_NOT TEST_IN(O) set(S).
 425 {
 426     T = O;
 427     sttype_oper_set2(O, STNODE_OP_NOT_IN, E, S);
 428     stnode_merge_location(T, E, S);
 429 }
 430
 431 relation(R) ::= relation_test(T).   { R = T; }
 432
 433 relation(R) ::= ANY(A) relation_test(T).
 434 {
 435     R = T;
 436     sttype_test_set_match(R, STNODE_MATCH_ANY);
 437     stnode_merge_location(R, A, T);
 438     stnode_free(A);
 439 }
 440
 441 relation(R) ::= ALL(A) relation_test(T).
 442 {
 443     R = T;
 444     sttype_test_set_match(R, STNODE_MATCH_ALL);
 445     stnode_merge_location(R, A, T);
 446     stnode_free(A);
 447 }
 448
 449 /* Sets */
 450
 451 set_element_list(N) ::= arithmetic_expr(X).
 452 {
 453     N = g_slist_append(NULL, X);
 454     N = g_slist_append(N, NULL);
 455 }
 456
 457 set_element_list(N) ::= arithmetic_expr(X) DOTDOT arithmetic_expr(Y).
 458 {
 459     N = g_slist_append(NULL, X);
 460     N = g_slist_append(N, Y);
 461 }
 462
 463 set_list(L) ::= set_element_list(N).
 464 {
 465     L = g_slist_concat(NULL, N);
 466 }
 467
 468 set_list(L) ::= set_list(P) COMMA set_element_list(N).
 469 {
 470     L = g_slist_concat(P, N);
 471 }
 472
 473 set(S) ::= LBRACE(LB) set_list(L) RBRACE(RB).
 474 {
 475     S = stnode_new(STTYPE_SET, L, NULL, DFILTER_LOC_EMPTY);
 476     stnode_merge_location(S, LB, RB);
 477     stnode_free(LB);
 478     stnode_free(RB);
 479 }
 480
 481 /* Slices */
 482
 483 slice(R) ::= entity(E) LBRACKET range_node_list(L) RBRACKET.
 484 {
 485     R = stnode_new(STTYPE_SLICE, NULL, NULL, DFILTER_LOC_EMPTY);
 486     sttype_slice_set(R, E, L);
 487
 488     /* Delete the list, but not the drange_nodes that
 489      * the list contains. */
 490     g_slist_free(L);
 491 }
 492
 493 range_node_list(L) ::= RANGE_NODE(N).
 494 {
 495     char *err_msg = NULL;
 496     drange_node *rn = drange_node_from_str(stnode_token(N), &err_msg);
 497     if (err_msg != NULL) {
 498         FAIL(dfs, N, "%s", err_msg);
 499         g_free(err_msg);
 500     }
 501     L = g_slist_append(NULL, rn);
 502     stnode_free(N);
 503 }
 504
 505 range_node_list(L) ::= range_node_list(P) COMMA RANGE_NODE(N).
 506 {
 507     char *err_msg = NULL;
 508     drange_node *rn = drange_node_from_str(stnode_token(N), &err_msg);
 509     if (err_msg != NULL) {
 510         FAIL(dfs, N, "%s", err_msg);
 511         g_free(err_msg);
 512     }
 513     L = g_slist_append(P, rn);
 514     stnode_free(N);
 515 }
 516
 517 /* Functions */
 518
 519 %code {
 520     static stnode_t *
 521     new_function(dfsyntax_t *dfs, stnode_t *node)
 522     {
 523         const char *name = stnode_token(node);
 524
 525         df_func_def_t *def = df_func_lookup(name);
 526         if (!def) {
 527             FAIL(dfs, node, "Function '%s' does not exist", name);
 528         }
 529         stnode_replace(node, STTYPE_FUNCTION, def);
 530         return node;
 531     }
 532 }
 533
 534 /* A function can have one or more parameters */
 535 function(F) ::= IDENTIFIER(U) LPAREN func_params_list(P) RPAREN(R).
 536 {
 537     F = new_function(dfs, U);
 538     sttype_function_set_params(F, P);
 539     stnode_merge_location(F, U, R);
 540     stnode_free(R);
 541 }
 542
 543 /* A function can have zero parameters. */
 544 function(F) ::= IDENTIFIER(U) LPAREN RPAREN(R).
 545 {
 546     F = new_function(dfs, U);
 547     stnode_merge_location(F, U, R);
 548     stnode_free(R);
 549 }
 550
 551 func_params_list(P) ::= arithmetic_expr(E).
 552 {
 553     P = g_slist_append(NULL, E);
 554 }
 555
 556 func_params_list(P) ::= func_params_list(L) COMMA arithmetic_expr(E).
 557 {
 558     P = g_slist_append(L, E);
 559 }