trafgen_parser.y

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2012 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 <signal.h>
  16 #include <stdint.h>
  17 #include <errno.h>
  18 #include <stdbool.h>
  19 #include <libgen.h>
  20
  21 #include "xmalloc.h"
  22 #include "trafgen_parser.tab.h"
  23 #include "trafgen_conf.h"
  24 #include "built_in.h"
  25 #include "die.h"
  26 #include "csum.h"
  27 #include "xutils.h"
  28
  29 #define YYERROR_VERBOSE         0
  30 #define YYDEBUG                 0
  31 #define YYENABLE_NLS            1
  32 #define YYLTYPE_IS_TRIVIAL      1
  33 #define ENABLE_NLS              1
  34
  35 extern FILE *yyin;
  36 extern int yylex(void);
  37 extern void yyerror(const char *);
  38 extern int yylineno;
  39 extern char *yytext;
  40
  41 extern struct packet *packets;
  42 extern size_t plen;
  43
  44 #define packet_last             (plen - 1)
  45
  46 #define payload_last            (packets[packet_last].len - 1)
  47
  48 extern struct packet_dyn *packet_dyn;
  49 extern size_t dlen;
  50
  51 #define packetd_last            (dlen - 1)
  52
  53 #define packetdc_last           (packet_dyn[packetd_last].clen - 1)
  54 #define packetdr_last           (packet_dyn[packetd_last].rlen - 1)
  55 #define packetds_last           (packet_dyn[packetd_last].slen - 1)
  56
  57 static int our_cpu, min_cpu = -1, max_cpu = -1;
  58
  59 static inline int test_ignore(void)
  60 {
  61         if (min_cpu < 0 && max_cpu < 0)
  62                 return 0;
  63         else if (max_cpu >= our_cpu && min_cpu <= our_cpu)
  64                 return 0;
  65         else
  66                 return 1;
  67 }
  68
  69 static inline int has_dynamic_elems(struct packet_dyn *p)
  70 {
  71         return (p->rlen + p->slen + p->clen);
  72 }
  73
  74 static inline void __init_new_packet_slot(struct packet *slot)
  75 {
  76         slot->payload = NULL;
  77         slot->len = 0;
  78 }
  79
  80 static inline void __init_new_counter_slot(struct packet_dyn *slot)
  81 {
  82         slot->cnt = NULL;
  83         slot->clen = 0;
  84 }
  85
  86 static inline void __init_new_randomizer_slot(struct packet_dyn *slot)
  87 {
  88         slot->rnd = NULL;
  89         slot->rlen = 0;
  90 }
  91
  92 static inline void __init_new_csum_slot(struct packet_dyn *slot)
  93 {
  94         slot->csum = NULL;
  95         slot->slen = 0;
  96 }
  97
  98 static inline void __setup_new_counter(struct counter *c, uint8_t start,
  99                                        uint8_t stop, uint8_t stepping,
 100                                        int type)
 101 {
 102         c->min = start;
 103         c->max = stop;
 104         c->inc = stepping;
 105         c->val = (type == TYPE_INC) ? start : stop;
 106         c->off = payload_last;
 107         c->type = type;
 108 }
 109
 110 static inline void __setup_new_randomizer(struct randomizer *r)
 111 {
 112         r->off = payload_last;
 113 }
 114
 115 static inline void __setup_new_csum16(struct csum16 *s, off_t from, off_t to,
 116                                       enum csum which)
 117 {
 118         s->off = payload_last - 1;
 119         s->from = from;
 120         s->to = to;
 121         s->which = which;
 122 }
 123
 124 static void realloc_packet(void)
 125 {
 126         if (test_ignore())
 127                 return;
 128
 129         plen++;
 130         packets = xrealloc(packets, 1, plen * sizeof(*packets));
 131
 132         __init_new_packet_slot(&packets[packet_last]);
 133
 134         dlen++;
 135         packet_dyn = xrealloc(packet_dyn, 1, dlen * sizeof(*packet_dyn));
 136
 137         __init_new_counter_slot(&packet_dyn[packetd_last]);
 138         __init_new_randomizer_slot(&packet_dyn[packetd_last]);
 139         __init_new_csum_slot(&packet_dyn[packetd_last]);
 140 }
 141
 142 static void set_byte(uint8_t val)
 143 {
 144         struct packet *pkt = &packets[packet_last];
 145
 146         if (test_ignore())
 147                 return;
 148
 149         pkt->len++;
 150         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 151         pkt->payload[payload_last] = val;
 152 }
 153
 154 static void set_multi_byte(uint8_t *s, size_t len)
 155 {
 156         int i;
 157
 158         for (i = 0; i < len; ++i)
 159                 set_byte(s[i]);
 160 }
 161
 162 static void set_fill(uint8_t val, size_t len)
 163 {
 164         size_t i;
 165         struct packet *pkt = &packets[packet_last];
 166
 167         if (test_ignore())
 168                 return;
 169
 170         pkt->len += len;
 171         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 172         for (i = 0; i < len; ++i)
 173                 pkt->payload[payload_last - i] = val;
 174 }
 175
 176 static void __set_csum16_dynamic(size_t from, size_t to, enum csum which)
 177 {
 178         struct packet *pkt = &packets[packet_last];
 179         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 180
 181         pkt->len += 2;
 182         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 183
 184         pktd->slen++;
 185         pktd->csum = xrealloc(pktd->csum, 1, pktd->slen * sizeof(struct csum16));
 186
 187         __setup_new_csum16(&pktd->csum[packetds_last], from, to, which);
 188 }
 189
 190 static void __set_csum16_static(size_t from, size_t to, enum csum which)
 191 {
 192         struct packet *pkt = &packets[packet_last];
 193         uint16_t sum;
 194         uint8_t *psum;
 195
 196         sum = htons(calc_csum(pkt->payload + from, to - from, 0));
 197         psum = (uint8_t *) &sum;
 198
 199         set_byte(psum[0]);
 200         set_byte(psum[1]);
 201 }
 202
 203 static void set_csum16(size_t from, size_t to, enum csum which)
 204 {
 205         int make_it_dynamic = 0;
 206         struct packet *pkt = &packets[packet_last];
 207         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 208
 209         if (test_ignore())
 210                 return;
 211
 212         if (to < from) {
 213                 size_t tmp = to;
 214
 215                 to = from;
 216                 from = tmp;
 217         }
 218
 219         bug_on(!(from < to));
 220
 221         if (to >= pkt->len || which == CSUM_TCP || which == CSUM_UDP)
 222                 make_it_dynamic = 1;
 223
 224         if (has_dynamic_elems(pktd) || make_it_dynamic)
 225                 __set_csum16_dynamic(from, to, which);
 226         else
 227                 __set_csum16_static(from, to, which);
 228 }
 229
 230 static void set_rnd(size_t len)
 231 {
 232         size_t i;
 233         struct packet *pkt = &packets[packet_last];
 234
 235         if (test_ignore())
 236                 return;
 237
 238         pkt->len += len;
 239         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 240         for (i = 0; i < len; ++i)
 241                 pkt->payload[payload_last - i] = (uint8_t) rand();
 242 }
 243
 244 static void set_sequential_inc(uint8_t start, size_t len, uint8_t stepping)
 245 {
 246         size_t i;
 247         struct packet *pkt = &packets[packet_last];
 248
 249         if (test_ignore())
 250                 return;
 251
 252         pkt->len += len;
 253         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 254         for (i = 0; i < len; ++i) {
 255                 off_t off = len - 1 - i;
 256
 257                 pkt->payload[payload_last - off] = start;
 258                 start += stepping;
 259         }
 260 }
 261
 262 static void set_sequential_dec(uint8_t start, size_t len, uint8_t stepping)
 263 {
 264         size_t i;
 265         struct packet *pkt = &packets[packet_last];
 266
 267         if (test_ignore())
 268                 return;
 269
 270         pkt->len += len;
 271         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 272         for (i = 0; i < len; ++i) {
 273                 int off = len - 1 - i;
 274
 275                 pkt->payload[payload_last - off] = start;
 276                 start -= stepping;
 277         }
 278 }
 279
 280 static void set_dynamic_rnd(void)
 281 {
 282         struct packet *pkt = &packets[packet_last];
 283         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 284
 285         if (test_ignore())
 286                 return;
 287
 288         pkt->len++;
 289         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 290
 291         pktd->rlen++;
 292         pktd->rnd = xrealloc(pktd->rnd, 1, pktd->rlen * sizeof(struct randomizer));
 293
 294         __setup_new_randomizer(&pktd->rnd[packetdr_last]);
 295 }
 296
 297 static void set_dynamic_incdec(uint8_t start, uint8_t stop, uint8_t stepping,
 298                                int type)
 299 {
 300         struct packet *pkt = &packets[packet_last];
 301         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 302
 303         if (test_ignore())
 304                 return;
 305
 306         pkt->len++;
 307         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 308
 309         pktd->clen++;
 310         pktd->cnt =xrealloc(pktd->cnt, 1, pktd->clen * sizeof(struct counter));
 311
 312         __setup_new_counter(&pktd->cnt[packetdc_last], start, stop, stepping, type);
 313 }
 314
 315 %}
 316
 317 %union {
 318         long long int number;
 319         char *str;
 320 }
 321
 322 %token K_COMMENT K_FILL K_RND K_SEQINC K_SEQDEC K_DRND K_DINC K_DDEC K_WHITE
 323 %token K_CPU K_CSUMIP K_CSUMUDP K_CSUMTCP K_CONST8 K_CONST16 K_CONST32 K_CONST64
 324
 325 %token ',' '{' '}' '(' ')' '[' ']' ':' '-' '+' '*' '/' '%' '&' '|' '<' '>' '^'
 326
 327 %token number string
 328
 329 %type <number> number expression
 330 %type <str> string
 331
 332 %left '-' '+' '*' '/' '%' '&' '|' '<' '>' '^'
 333
 334 %%
 335
 336 packets
 337         : { }
 338         | packets packet { }
 339         | packets inline_comment { }
 340         | packets K_WHITE { }
 341         ;
 342
 343 inline_comment
 344         : K_COMMENT { }
 345         ;
 346
 347 cpu_delim
 348         : ':' { }
 349         | '-' { }
 350         ;
 351
 352 noenforce_white
 353         : { }
 354         | K_WHITE { }
 355         ;
 356
 357 packet
 358         : '{' delimiter payload delimiter '}' {
 359                         min_cpu = max_cpu = -1;
 360                         realloc_packet();
 361                 }
 362         | K_CPU '(' number cpu_delim number ')' ':' noenforce_white '{' delimiter payload delimiter '}' {
 363                         min_cpu = $3;
 364                         max_cpu = $5;
 365
 366                         if (min_cpu > max_cpu) {
 367                                 int tmp = min_cpu;
 368
 369                                 min_cpu = max_cpu;
 370                                 max_cpu = tmp;
 371                         }
 372
 373                         realloc_packet();
 374                 }
 375         | K_CPU '(' number ')' ':' noenforce_white '{' delimiter payload delimiter '}' {
 376                         min_cpu = max_cpu = $3;
 377                         realloc_packet();
 378                 }
 379         ;
 380
 381 payload
 382         : elem { }
 383         | payload elem_delimiter { }
 384         ;
 385
 386 delimiter
 387         : ',' { }
 388         | K_WHITE { }
 389         | ',' K_WHITE { }
 390         ;
 391
 392 elem_delimiter
 393         : delimiter elem { }
 394         ;
 395
 396 elem
 397         : number { set_byte((uint8_t) $1); }
 398         | string { set_multi_byte((uint8_t *) $1 + 1, strlen($1) - 2); }
 399         | fill { }
 400         | rnd { }
 401         | drnd { }
 402         | seqinc { }
 403         | seqdec { }
 404         | dinc { }
 405         | ddec { }
 406         | csum { }
 407         | const { }
 408         | inline_comment { }
 409         ;
 410
 411 expression
 412         : number
 413                 { $$ = $1; }
 414         | expression '+' expression
 415                 { $$ = $1 + $3; }
 416         | expression '-' expression
 417                 { $$ = $1 - $3; }
 418         | expression '*' expression
 419                 { $$ = $1 * $3; }
 420         | expression '/' expression
 421                 { $$ = $1 / $3; }
 422         | expression '%' expression
 423                 { $$ = $1 % $3; }
 424         | expression '&' expression
 425                 { $$ = $1 & $3; }
 426         | expression '|' expression
 427                 { $$ = $1 | $3; }
 428         | expression '^' expression
 429                 { $$ = $1 ^ $3; }
 430         | expression '<' '<' expression
 431                 { $$ = $1 << $4; }
 432         | expression '>' '>' expression
 433                 { $$ = $1 >> $4; }
 434         | '(' expression ')'
 435                 { $$ = $2;}
 436         ;
 437
 438 fill
 439         : K_FILL '(' number delimiter number ')'
 440                 { set_fill($3, $5); }
 441         ;
 442
 443 const
 444         : K_CONST8 '(' expression ')'
 445                 { set_byte((uint8_t) $3); }
 446         | K_CONST16 '(' expression ')' {
 447                         uint16_t __c = cpu_to_be16((uint16_t) $3);
 448
 449                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 450                 }
 451         | K_CONST32 '(' expression ')' {
 452                         uint32_t __c = cpu_to_be32((uint32_t) $3);
 453
 454                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 455                 }
 456         | K_CONST64 '(' expression ')' {
 457                         uint64_t __c = cpu_to_be64((uint64_t) $3);
 458
 459                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 460                 }
 461         ;
 462
 463 rnd
 464         : K_RND '(' number ')'
 465                 { set_rnd($3); }
 466         ;
 467
 468 csum
 469         : K_CSUMIP '(' number delimiter number ')'
 470                 { set_csum16($3, $5, CSUM_IP); }
 471         | K_CSUMTCP '(' number delimiter number ')'
 472                 { set_csum16($3, $5, CSUM_TCP); }
 473         | K_CSUMUDP '(' number delimiter number ')'
 474                 { set_csum16($3, $5, CSUM_UDP); }
 475         ;
 476
 477 seqinc
 478         : K_SEQINC '(' number delimiter number ')'
 479                 { set_sequential_inc($3, $5, 1); }
 480         | K_SEQINC '(' number delimiter number delimiter number ')'
 481                 { set_sequential_inc($3, $5, $7); }
 482         ;
 483
 484 seqdec
 485         : K_SEQDEC '(' number delimiter number ')'
 486                 { set_sequential_dec($3, $5, 1); }
 487         | K_SEQDEC '(' number delimiter number delimiter number ')'
 488                 { set_sequential_dec($3, $5, $7); }
 489         ;
 490
 491 drnd
 492         : K_DRND '(' ')'
 493                 { set_dynamic_rnd(); }
 494         | K_DRND '(' number ')'
 495                 {
 496                         int i, max = $3;
 497                         for (i = 0; i < max; ++i)
 498                                 set_dynamic_rnd();
 499                 }
 500         ;
 501
 502 dinc
 503         : K_DINC '(' number delimiter number ')'
 504                 { set_dynamic_incdec($3, $5, 1, TYPE_INC); }
 505         | K_DINC '(' number delimiter number delimiter number ')'
 506                 { set_dynamic_incdec($3, $5, $7, TYPE_INC); }
 507         ;
 508
 509 ddec
 510         : K_DDEC '(' number delimiter number ')'
 511                 { set_dynamic_incdec($3, $5, 1, TYPE_DEC); }
 512         | K_DDEC '(' number delimiter number delimiter number ')'
 513                 { set_dynamic_incdec($3, $5, $7, TYPE_DEC); }
 514         ;
 515
 516 %%
 517
 518 static void finalize_packet(void)
 519 {
 520         /* XXX hack ... we allocated one packet pointer too much */
 521         plen--;
 522         dlen--;
 523 }
 524
 525 static void dump_conf(void)
 526 {
 527         size_t i, j;
 528
 529         for (i = 0; i < plen; ++i) {
 530                 printf("[%zu] pkt\n", i);
 531                 printf(" len %zu cnts %zu rnds %zu\n",
 532                        packets[i].len,
 533                        packet_dyn[i].clen,
 534                        packet_dyn[i].rlen);
 535
 536                 printf(" payload ");
 537                 for (j = 0; j < packets[i].len; ++j)
 538                         printf("%02x ", packets[i].payload[j]);
 539                 printf("\n");
 540
 541                 for (j = 0; j < packet_dyn[i].clen; ++j)
 542                         printf(" cnt%zu [%u,%u], inc %u, off %ld type %s\n", j,
 543                                packet_dyn[i].cnt[j].min,
 544                                packet_dyn[i].cnt[j].max,
 545                                packet_dyn[i].cnt[j].inc,
 546                                packet_dyn[i].cnt[j].off,
 547                                packet_dyn[i].cnt[j].type == TYPE_INC ?
 548                                "inc" : "dec");
 549
 550                 for (j = 0; j < packet_dyn[i].rlen; ++j)
 551                         printf(" rnd%zu off %ld\n", j,
 552                                packet_dyn[i].rnd[j].off);
 553         }
 554 }
 555
 556 void cleanup_packets(void)
 557 {
 558         size_t i;
 559
 560         for (i = 0; i < plen; ++i) {
 561                 if (packets[i].len > 0)
 562                         xfree(packets[i].payload);
 563         }
 564
 565         free(packets);
 566
 567         for (i = 0; i < dlen; ++i) {
 568                 free(packet_dyn[i].cnt);
 569                 free(packet_dyn[i].rnd);
 570         }
 571
 572         free(packet_dyn);
 573 }
 574
 575 int compile_packets(char *file, int verbose, int cpu, bool invoke_cpp)
 576 {
 577         char tmp_file[128];
 578
 579         memset(tmp_file, 0, sizeof(tmp_file));
 580         our_cpu = cpu;
 581
 582         if (invoke_cpp) {
 583                 char cmd[256], *dir, *base, *a, *b;
 584
 585                 dir = dirname((a = xstrdup(file)));
 586                 base = basename((b = xstrdup(file)));
 587
 588                 slprintf(tmp_file, sizeof(tmp_file), "%s/.tmp-%u-%s", dir, rand(), base);
 589                 slprintf(cmd, sizeof(cmd), "cpp -I" PREFIX_STRING
 590                          "/etc/netsniff-ng/ %s > %s", file, tmp_file);
 591                 system(cmd);
 592
 593                 file = tmp_file;
 594                 xfree(a);
 595                 xfree(b);
 596         }
 597
 598         if (!strncmp("-", file, strlen("-")))
 599                 yyin = stdin;
 600         else
 601                 yyin = fopen(file, "r");
 602         if (!yyin)
 603                 panic("Cannot open %s: %s!\n", file, strerror(errno));
 604
 605         realloc_packet();
 606         yyparse();
 607         finalize_packet();
 608
 609         if (our_cpu == 0 && verbose)
 610                 dump_conf();
 611
 612         fclose(yyin);
 613         if (invoke_cpp)
 614                 unlink(tmp_file);
 615
 616         return 0;
 617 }
 618
 619 void yyerror(const char *err)
 620 {
 621         panic("Syntax error at line%d, at char '%s'! %s!\n", yylineno, yytext, err);
 622 }