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 packet
 348         : '{' delimiter payload delimiter '}' {
 349                         min_cpu = max_cpu = -1;
 350                         realloc_packet();
 351                 }
 352         | K_CPU '(' number ':' number ')' ':' K_WHITE '{' delimiter payload delimiter '}' {
 353                         min_cpu = $3;
 354                         max_cpu = $5;
 355
 356                         if (min_cpu > max_cpu) {
 357                                 int tmp = min_cpu;
 358
 359                                 min_cpu = max_cpu;
 360                                 max_cpu = tmp;
 361                         }
 362
 363                         realloc_packet();
 364                 }
 365         | K_CPU '(' number ')' ':' K_WHITE '{' delimiter payload delimiter '}' {
 366                         min_cpu = max_cpu = $3;
 367                         realloc_packet();
 368                 }
 369         ;
 370
 371 payload
 372         : elem { }
 373         | payload elem_delimiter { }
 374         ;
 375
 376 delimiter
 377         : ',' { }
 378         | K_WHITE { }
 379         | ',' K_WHITE { }
 380         ;
 381
 382 elem_delimiter
 383         : delimiter elem { }
 384         ;
 385
 386 elem
 387         : number { set_byte((uint8_t) $1); }
 388         | string { set_multi_byte((uint8_t *) $1 + 1, strlen($1) - 2); }
 389         | fill { }
 390         | rnd { }
 391         | drnd { }
 392         | seqinc { }
 393         | seqdec { }
 394         | dinc { }
 395         | ddec { }
 396         | csum { }
 397         | const { }
 398         | inline_comment { }
 399         ;
 400
 401 expression
 402         : number
 403                 { $$ = $1; }
 404         | expression '+' expression
 405                 { $$ = $1 + $3; }
 406         | expression '-' expression
 407                 { $$ = $1 - $3; }
 408         | expression '*' expression
 409                 { $$ = $1 * $3; }
 410         | expression '/' expression
 411                 { $$ = $1 / $3; }
 412         | expression '%' expression
 413                 { $$ = $1 % $3; }
 414         | expression '&' expression
 415                 { $$ = $1 & $3; }
 416         | expression '|' expression
 417                 { $$ = $1 | $3; }
 418         | expression '^' expression
 419                 { $$ = $1 ^ $3; }
 420         | expression '<' '<' expression
 421                 { $$ = $1 << $4; }
 422         | expression '>' '>' expression
 423                 { $$ = $1 >> $4; }
 424         | '(' expression ')'
 425                 { $$ = $2;}
 426         ;
 427
 428 fill
 429         : K_FILL '(' number delimiter number ')'
 430                 { set_fill($3, $5); }
 431         ;
 432
 433 const
 434         : K_CONST8 '(' expression ')'
 435                 { set_byte((uint8_t) $3); }
 436         | K_CONST16 '(' expression ')' {
 437                         uint16_t __c = cpu_to_be16((uint16_t) $3);
 438
 439                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 440                 }
 441         | K_CONST32 '(' expression ')' {
 442                         uint32_t __c = cpu_to_be32((uint32_t) $3);
 443
 444                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 445                 }
 446         | K_CONST64 '(' expression ')' {
 447                         uint64_t __c = cpu_to_be64((uint64_t) $3);
 448
 449                         set_multi_byte((uint8_t *) &__c, sizeof(__c));
 450                 }
 451         ;
 452
 453 rnd
 454         : K_RND '(' number ')'
 455                 { set_rnd($3); }
 456         ;
 457
 458 csum
 459         : K_CSUMIP '(' number delimiter number ')'
 460                 { set_csum16($3, $5, CSUM_IP); }
 461         | K_CSUMTCP '(' number delimiter number ')'
 462                 { set_csum16($3, $5, CSUM_TCP); }
 463         | K_CSUMUDP '(' number delimiter number ')'
 464                 { set_csum16($3, $5, CSUM_UDP); }
 465         ;
 466
 467 seqinc
 468         : K_SEQINC '(' number delimiter number ')'
 469                 { set_sequential_inc($3, $5, 1); }
 470         | K_SEQINC '(' number delimiter number delimiter number ')'
 471                 { set_sequential_inc($3, $5, $7); }
 472         ;
 473
 474 seqdec
 475         : K_SEQDEC '(' number delimiter number ')'
 476                 { set_sequential_dec($3, $5, 1); }
 477         | K_SEQDEC '(' number delimiter number delimiter number ')'
 478                 { set_sequential_dec($3, $5, $7); }
 479         ;
 480
 481 drnd
 482         : K_DRND '(' ')'
 483                 { set_dynamic_rnd(); }
 484         | K_DRND '(' number ')'
 485                 {
 486                         int i, max = $3;
 487                         for (i = 0; i < max; ++i)
 488                                 set_dynamic_rnd();
 489                 }
 490         ;
 491
 492 dinc
 493         : K_DINC '(' number delimiter number ')'
 494                 { set_dynamic_incdec($3, $5, 1, TYPE_INC); }
 495         | K_DINC '(' number delimiter number delimiter number ')'
 496                 { set_dynamic_incdec($3, $5, $7, TYPE_INC); }
 497         ;
 498
 499 ddec
 500         : K_DDEC '(' number delimiter number ')'
 501                 { set_dynamic_incdec($3, $5, 1, TYPE_DEC); }
 502         | K_DDEC '(' number delimiter number delimiter number ')'
 503                 { set_dynamic_incdec($3, $5, $7, TYPE_DEC); }
 504         ;
 505
 506 %%
 507
 508 static void finalize_packet(void)
 509 {
 510         /* XXX hack ... we allocated one packet pointer too much */
 511         plen--;
 512         dlen--;
 513 }
 514
 515 static void dump_conf(void)
 516 {
 517         size_t i, j;
 518
 519         for (i = 0; i < plen; ++i) {
 520                 printf("[%zu] pkt\n", i);
 521                 printf(" len %zu cnts %zu rnds %zu\n",
 522                        packets[i].len,
 523                        packet_dyn[i].clen,
 524                        packet_dyn[i].rlen);
 525
 526                 printf(" payload ");
 527                 for (j = 0; j < packets[i].len; ++j)
 528                         printf("%02x ", packets[i].payload[j]);
 529                 printf("\n");
 530
 531                 for (j = 0; j < packet_dyn[i].clen; ++j)
 532                         printf(" cnt%zu [%u,%u], inc %u, off %ld type %s\n", j,
 533                                packet_dyn[i].cnt[j].min,
 534                                packet_dyn[i].cnt[j].max,
 535                                packet_dyn[i].cnt[j].inc,
 536                                packet_dyn[i].cnt[j].off,
 537                                packet_dyn[i].cnt[j].type == TYPE_INC ?
 538                                "inc" : "dec");
 539
 540                 for (j = 0; j < packet_dyn[i].rlen; ++j)
 541                         printf(" rnd%zu off %ld\n", j,
 542                                packet_dyn[i].rnd[j].off);
 543         }
 544 }
 545
 546 void cleanup_packets(void)
 547 {
 548         size_t i;
 549
 550         for (i = 0; i < plen; ++i) {
 551                 if (packets[i].len > 0)
 552                         xfree(packets[i].payload);
 553         }
 554
 555         free(packets);
 556
 557         for (i = 0; i < dlen; ++i) {
 558                 free(packet_dyn[i].cnt);
 559                 free(packet_dyn[i].rnd);
 560         }
 561
 562         free(packet_dyn);
 563 }
 564
 565 int compile_packets(char *file, int verbose, int cpu, bool invoke_cpp)
 566 {
 567         char tmp_file[128];
 568
 569         memset(tmp_file, 0, sizeof(tmp_file));
 570         our_cpu = cpu;
 571
 572         if (invoke_cpp) {
 573                 char cmd[256], *dir, *base, *a, *b;
 574
 575                 dir = dirname((a = xstrdup(file)));
 576                 base = basename((b = xstrdup(file)));
 577
 578                 slprintf(tmp_file, sizeof(tmp_file), "%s/.tmp-%u-%s", dir, rand(), base);
 579                 slprintf(cmd, sizeof(cmd), "cpp -I/etc/netsniff-ng/ %s > %s", file, tmp_file);
 580                 system(cmd);
 581
 582                 file = tmp_file;
 583                 xfree(a);
 584                 xfree(b);
 585         }
 586
 587         if (!strncmp("-", file, strlen("-")))
 588                 yyin = stdin;
 589         else
 590                 yyin = fopen(file, "r");
 591         if (!yyin)
 592                 panic("Cannot open %s: %s!\n", file, strerror(errno));
 593
 594         realloc_packet();
 595         yyparse();
 596         finalize_packet();
 597
 598         if (our_cpu == 0 && verbose)
 599                 dump_conf();
 600
 601         fclose(yyin);
 602         if (invoke_cpp)
 603                 unlink(tmp_file);
 604
 605         return 0;
 606 }
 607
 608 void yyerror(const char *err)
 609 {
 610         panic("Syntax error at line%d, at char '%s'! %s!\n", yylineno, yytext, err);
 611 }