src/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
  19 #include "xmalloc.h"
  20 #include "trafgen_parser.tab.h"
  21 #include "trafgen_conf.h"
  22 #include "built_in.h"
  23 #include "die.h"
  24 #include "csum.h"
  25
  26 #define YYERROR_VERBOSE         0
  27 #define YYDEBUG                 0
  28 #define YYENABLE_NLS            1
  29 #define YYLTYPE_IS_TRIVIAL      1
  30 #define ENABLE_NLS              1
  31
  32 extern FILE *yyin;
  33 extern int yylex(void);
  34 extern void yyerror(const char *);
  35 extern int yylineno;
  36 extern char *yytext;
  37
  38 extern struct packet *packets;
  39 extern size_t plen;
  40 #define packet_last             (plen - 1)
  41 #define payload_last            (packets[packet_last].len - 1)
  42
  43 extern struct packet_dyn *packet_dyn;
  44 extern size_t dlen;
  45 #define packetd_last            (dlen - 1)
  46 #define packetdc_last           (packet_dyn[packetd_last].clen - 1)
  47 #define packetdr_last           (packet_dyn[packetd_last].rlen - 1)
  48
  49 static int dfunc_note_flag = 0, our_cpu, min_cpu = -1, max_cpu = -1;
  50
  51 static inline int test_ignore(void)
  52 {
  53         if (min_cpu < 0 && max_cpu < 0)
  54                 return 0;
  55         else if (max_cpu >= our_cpu && min_cpu <= our_cpu)
  56                 return 0;
  57         else
  58                 return 1;
  59 }
  60
  61 static void give_note_dynamic(void)
  62 {
  63         if (!dfunc_note_flag) {
  64                 printf("Note: dynamic elements like drnd, dinc, ddec and "
  65                        "others make trafgen slower!\n");
  66                 dfunc_note_flag = 1;
  67         }
  68 }
  69
  70 static inline void __init_new_packet_slot(struct packet *slot)
  71 {
  72         slot->payload = NULL;
  73         slot->len = 0;
  74 }
  75
  76 static inline void __init_new_counter_slot(struct packet_dyn *slot)
  77 {
  78         slot->cnt = NULL;
  79         slot->clen = 0;
  80 }
  81
  82 static inline void __init_new_randomizer_slot(struct packet_dyn *slot)
  83 {
  84         slot->rnd = NULL;
  85         slot->rlen = 0;
  86 }
  87
  88 static void realloc_packet(void)
  89 {
  90         if (test_ignore())
  91                 return;
  92
  93         plen++;
  94         packets = xrealloc(packets, 1, plen * sizeof(*packets));
  95
  96         __init_new_packet_slot(&packets[packet_last]);
  97
  98         dlen++;
  99         packet_dyn = xrealloc(packet_dyn, 1, dlen * sizeof(*packet_dyn));
 100
 101         __init_new_counter_slot(&packet_dyn[packetd_last]);
 102         __init_new_randomizer_slot(&packet_dyn[packetd_last]);
 103 }
 104
 105 static void set_byte(uint8_t val)
 106 {
 107         struct packet *pkt = &packets[packet_last];
 108
 109         if (test_ignore())
 110                 return;
 111
 112         pkt->len++;
 113         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 114         pkt->payload[payload_last] = val;
 115 }
 116
 117 static void set_fill(uint8_t val, size_t len)
 118 {
 119         size_t i;
 120         struct packet *pkt = &packets[packet_last];
 121
 122         if (test_ignore())
 123                 return;
 124
 125         pkt->len += len;
 126         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 127         for (i = 0; i < len; ++i)
 128                 pkt->payload[payload_last - i] = val;
 129 }
 130
 131 static void set_csum16(size_t from, size_t to)
 132 {
 133         struct packet *pkt = &packets[packet_last];
 134         uint16_t sum;
 135         uint8_t *psum;
 136
 137         if (test_ignore())
 138                 return;
 139
 140         if (to < from) {
 141                 size_t tmp = to;
 142
 143                 to = from;
 144                 from = tmp;
 145         }
 146
 147         bug_on(!(from < to));
 148
 149         if (to >= pkt->len)
 150                 to = pkt->len - 1;
 151
 152         sum = htons(calc_csum(pkt->payload + from, to - from, 0));
 153         psum = (uint8_t *) &sum;
 154
 155         set_byte(psum[0]);
 156         set_byte(psum[1]);
 157 }
 158
 159 static void set_rnd(size_t len)
 160 {
 161         size_t i;
 162         struct packet *pkt = &packets[packet_last];
 163
 164         if (test_ignore())
 165                 return;
 166
 167         pkt->len += len;
 168         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 169         for (i = 0; i < len; ++i)
 170                 pkt->payload[payload_last - i] = (uint8_t) rand();
 171 }
 172
 173 static void set_seqinc(uint8_t start, size_t len, uint8_t stepping)
 174 {
 175         size_t i;
 176         struct packet *pkt = &packets[packet_last];
 177
 178         if (test_ignore())
 179                 return;
 180
 181         pkt->len += len;
 182         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 183         for (i = 0; i < len; ++i) {
 184                 off_t off = len - 1 - i;
 185
 186                 pkt->payload[payload_last - off] = start;
 187                 start += stepping;
 188         }
 189 }
 190
 191 static void set_seqdec(uint8_t start, size_t len, uint8_t stepping)
 192 {
 193         size_t i;
 194         struct packet *pkt = &packets[packet_last];
 195
 196         if (test_ignore())
 197                 return;
 198
 199         pkt->len += len;
 200         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 201         for (i = 0; i < len; ++i) {
 202                 int off = len - 1 - i;
 203
 204                 pkt->payload[payload_last - off] = start;
 205                 start -= stepping;
 206         }
 207 }
 208
 209 static inline void __setup_new_counter(struct counter *c, uint8_t start,
 210                                        uint8_t stop, uint8_t stepping,
 211                                        int type)
 212 {
 213         c->min = start;
 214         c->max = stop;
 215         c->inc = stepping;
 216         c->val = (type == TYPE_INC) ? start : stop;
 217         c->off = payload_last;
 218         c->type = type;
 219 }
 220
 221 static inline void __setup_new_randomizer(struct randomizer *r)
 222 {
 223         r->val = (uint8_t) rand();
 224         r->off = payload_last;
 225 }
 226
 227 static void set_drnd(void)
 228 {
 229         struct packet *pkt = &packets[packet_last];
 230         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 231
 232         if (test_ignore())
 233                 return;
 234
 235         give_note_dynamic();
 236
 237         pkt->len++;
 238         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 239
 240         pktd->rlen++;
 241         pktd->rnd = xrealloc(pktd->rnd, 1, pktd->rlen * sizeof(struct randomizer));
 242
 243         __setup_new_randomizer(&pktd->rnd[packetdr_last]);
 244 }
 245
 246 static void set_dincdec(uint8_t start, uint8_t stop, uint8_t stepping, int type)
 247 {
 248         struct packet *pkt = &packets[packet_last];
 249         struct packet_dyn *pktd = &packet_dyn[packetd_last];
 250
 251         if (test_ignore())
 252                 return;
 253
 254         give_note_dynamic();
 255
 256         pkt->len++;
 257         pkt->payload = xrealloc(pkt->payload, 1, pkt->len);
 258
 259         pktd->clen++;
 260         pktd->cnt =xrealloc(pktd->cnt, 1, pktd->clen * sizeof(struct counter));
 261
 262         __setup_new_counter(&pktd->cnt[packetdc_last], start, stop, stepping, type);
 263 }
 264
 265 %}
 266
 267 %union {
 268         long int number;
 269 }
 270
 271 %token K_COMMENT K_FILL K_RND K_SEQINC K_SEQDEC K_DRND K_DINC K_DDEC K_WHITE
 272 %token K_CPU K_CSUM16
 273
 274 %token ',' '{' '}' '(' ')' '[' ']' ':'
 275
 276 %token number
 277
 278 %type <number> number
 279
 280 %%
 281
 282 packets
 283         : { }
 284         | packets packet { }
 285         | packets inline_comment { }
 286         | packets K_WHITE { }
 287         ;
 288
 289 inline_comment
 290         : K_COMMENT { }
 291         ;
 292
 293 packet
 294         : '{' delimiter payload delimiter '}' {
 295                         min_cpu = max_cpu = -1;
 296                         realloc_packet();
 297                 }
 298         | K_CPU '(' number ':' number ')' ':' K_WHITE '{' delimiter payload delimiter '}' {
 299                         min_cpu = $3;
 300                         max_cpu = $5;
 301
 302                         if (min_cpu > max_cpu) {
 303                                 int tmp = min_cpu;
 304
 305                                 min_cpu = max_cpu;
 306                                 max_cpu = tmp;
 307                         }
 308
 309                         realloc_packet();
 310                 }
 311         | K_CPU '(' number ')' ':' K_WHITE '{' delimiter payload delimiter '}' {
 312                         min_cpu = max_cpu = $3;
 313                         realloc_packet();
 314                 }
 315         ;
 316
 317 payload
 318         : elem { }
 319         | payload elem_delimiter { }
 320         ;
 321
 322 delimiter
 323         : ',' { }
 324         | K_WHITE { }
 325         | ',' K_WHITE { }
 326         ;
 327
 328 elem_delimiter
 329         : delimiter elem { }
 330         ;
 331
 332 elem
 333         : number { set_byte((uint8_t) $1); }
 334         | fill { }
 335         | rnd { }
 336         | drnd { }
 337         | seqinc { }
 338         | seqdec { }
 339         | dinc { }
 340         | ddec { }
 341         | csum { }
 342         | inline_comment { }
 343         ;
 344
 345 fill
 346         : K_FILL '(' number delimiter number ')'
 347                 { set_fill($3, $5); }
 348         ;
 349
 350 rnd
 351         : K_RND '(' number ')'
 352                 { set_rnd($3); }
 353         ;
 354
 355 csum
 356         : K_CSUM16 '(' number delimiter number ')'
 357                 { set_csum16($3, $5); }
 358         ;
 359
 360 seqinc
 361         : K_SEQINC '(' number delimiter number ')'
 362                 { set_seqinc($3, $5, 1); }
 363         | K_SEQINC '(' number delimiter number delimiter number ')'
 364                 { set_seqinc($3, $5, $7); }
 365         ;
 366
 367 seqdec
 368         : K_SEQDEC '(' number delimiter number ')'
 369                 { set_seqdec($3, $5, 1); }
 370         | K_SEQDEC '(' number delimiter number delimiter number ')'
 371                 { set_seqdec($3, $5, $7); }
 372         ;
 373
 374 drnd
 375         : K_DRND '(' ')'
 376                 { set_drnd(); }
 377         | K_DRND '(' number ')'
 378                 {
 379                         int i, max = $3;
 380                         for (i = 0; i < max; ++i)
 381                                 set_drnd();
 382                 }
 383         ;
 384
 385 dinc
 386         : K_DINC '(' number delimiter number ')'
 387                 { set_dincdec($3, $5, 1, TYPE_INC); }
 388         | K_DINC '(' number delimiter number delimiter number ')'
 389                 { set_dincdec($3, $5, $7, TYPE_INC); }
 390         ;
 391
 392 ddec
 393         : K_DDEC '(' number delimiter number ')'
 394                 { set_dincdec($3, $5, 1, TYPE_DEC); }
 395         | K_DDEC '(' number delimiter number delimiter number ')'
 396                 { set_dincdec($3, $5, $7, TYPE_DEC); }
 397         ;
 398
 399 %%
 400
 401 static void finalize_packet(void)
 402 {
 403         /* XXX hack ... we allocated one packet pointer too much */
 404         plen--;
 405         dlen--;
 406 }
 407
 408 static void dump_conf(void)
 409 {
 410         size_t i, j;
 411
 412         for (i = 0; i < plen; ++i) {
 413                 printf("[%zu] pkt\n", i);
 414                 printf(" len %zu cnts %zu rnds %zu\n",
 415                        packets[i].len,
 416                        packet_dyn[i].clen,
 417                        packet_dyn[i].rlen);
 418
 419                 printf(" payload ");
 420                 for (j = 0; j < packets[i].len; ++j)
 421                         printf("%02x ", packets[i].payload[j]);
 422                 printf("\n");
 423
 424                 for (j = 0; j < packet_dyn[i].clen; ++j)
 425                         printf(" cnt%zu [%u,%u], inc %u, off %ld type %s\n", j,
 426                                packet_dyn[i].cnt[j].min,
 427                                packet_dyn[i].cnt[j].max,
 428                                packet_dyn[i].cnt[j].inc,
 429                                packet_dyn[i].cnt[j].off,
 430                                packet_dyn[i].cnt[j].type == TYPE_INC ?
 431                                "inc" : "dec");
 432
 433                 for (j = 0; j < packet_dyn[i].rlen; ++j)
 434                         printf(" rnd%zu off %ld\n", j,
 435                                packet_dyn[i].rnd[j].off);
 436         }
 437 }
 438
 439 void cleanup_packets(void)
 440 {
 441         size_t i;
 442
 443         for (i = 0; i < plen; ++i) {
 444                 if (packets[i].len > 0)
 445                         xfree(packets[i].payload);
 446         }
 447
 448         free(packets);
 449
 450         for (i = 0; i < dlen; ++i) {
 451                 free(packet_dyn[i].cnt);
 452                 free(packet_dyn[i].rnd);
 453         }
 454
 455         free(packet_dyn);
 456 }
 457
 458 int compile_packets(char *file, int verbose, int cpu)
 459 {
 460         our_cpu = cpu;
 461
 462         yyin = fopen(file, "r");
 463         if (!yyin)
 464                 panic("Cannot open file!\n");
 465
 466         realloc_packet();
 467         yyparse();
 468         finalize_packet();
 469
 470         if (our_cpu == 0 && verbose)
 471                 dump_conf();
 472
 473         fclose(yyin);
 474         return 0;
 475 }
 476
 477 void yyerror(const char *err)
 478 {
 479         panic("Syntax error at line%d, at char '%s'! %s!\n", yylineno, yytext, err);
 480 }