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