src/cfgparser/oparse.y

   1 %{
   2
   3 /*
   4  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   5  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * * Redistributions of source code must retain the above copyright
  13  *   notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  *   notice, this list of conditions and the following disclaimer in
  16  *   the documentation and/or other materials provided with the
  17  *   distribution.
  18  * * Neither the name of olsr.org, olsrd nor the names of its
  19  *   contributors may be used to endorse or promote products derived
  20  *   from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  26  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  30  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  32  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * Visit http://www.olsr.org for more information.
  36  *
  37  * If you find this software useful feel free to make a donation
  38  * to the project. For more information see the website or contact
  39  * the copyright holders.
  40  *
  41  * $Id: oparse.y,v 1.25 2005/02/17 17:21:24 kattemat Exp $
  42  */
  43
  44
  45 #include <stddef.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <sys/types.h>
  49 #include <sys/socket.h>
  50 #include <netinet/in.h>
  51 #include <arpa/inet.h>
  52 #include <string.h>
  53
  54 #include "olsrd_conf.h"
  55
  56 #define PARSER_DEBUG 0
  57
  58 #define YYSTYPE struct conf_token *
  59
  60 void yyerror(char *);
  61 int yylex(void);
  62
  63 static int ifs_in_curr_cfg = 0;
  64
  65 static int lq_mult_helper(YYSTYPE ip_addr_arg, YYSTYPE mult_arg);
  66
  67 static int lq_mult_helper(YYSTYPE ip_addr_arg, YYSTYPE mult_arg)
  68 {
  69   union olsr_ip_addr addr;
  70   int i;
  71   struct olsr_if *walker;
  72   struct olsr_lq_mult *mult;
  73
  74 #if PARSER_DEBUG > 0
  75   printf("\tLinkQualityMult %s %0.2f\n",
  76          (ip_addr_arg != NULL) ? ip_addr_arg->string : "any",
  77          mult_arg->floating);
  78 #endif
  79
  80   memset(&addr, 0, sizeof (union olsr_ip_addr));
  81
  82   if(ip_addr_arg != NULL &&
  83      inet_pton(cnf->ip_version, ip_addr_arg->string, &addr) < 0)
  84   {
  85     fprintf(stderr, "Cannot parse IP address %s.\n", ip_addr_arg->string);
  86     return -1;
  87   }
  88
  89   walker = cnf->interfaces;
  90
  91   for (i = 0; i < ifs_in_curr_cfg; i++)
  92   {
  93     mult = malloc(sizeof (struct olsr_lq_mult));
  94
  95     if (mult == NULL)
  96     {
  97       fprintf(stderr, "Out of memory (LQ multiplier).\n");
  98       return -1;
  99     }
 100
 101     memcpy(&mult->addr, &addr, sizeof (union olsr_ip_addr));
 102     mult->val = mult_arg->floating;
 103
 104     mult->next = walker->cnf->lq_mult;
 105     walker->cnf->lq_mult = mult;
 106
 107     walker = walker->next;
 108   }
 109
 110   if (ip_addr_arg != NULL)
 111   {
 112     free(ip_addr_arg->string);
 113     free(ip_addr_arg);
 114   }
 115
 116   free(mult_arg);
 117
 118   return 0;
 119 }
 120 %}
 121
 122 %token TOK_OPEN
 123 %token TOK_CLOSE
 124 %token TOK_SEMI
 125
 126 %token TOK_STRING
 127 %token TOK_INTEGER
 128 %token TOK_FLOAT
 129 %token TOK_BOOLEAN
 130
 131 %token TOK_IP6TYPE
 132
 133 %token TOK_DEBUGLEVEL
 134 %token TOK_IPVERSION
 135 %token TOK_HNA4
 136 %token TOK_HNA6
 137 %token TOK_PLUGIN
 138 %token TOK_INTERFACE
 139 %token TOK_NOINT
 140 %token TOK_TOS
 141 %token TOK_WILLINGNESS
 142 %token TOK_IPCCON
 143 %token TOK_USEHYST
 144 %token TOK_HYSTSCALE
 145 %token TOK_HYSTUPPER
 146 %token TOK_HYSTLOWER
 147 %token TOK_POLLRATE
 148 %token TOK_TCREDUNDANCY
 149 %token TOK_MPRCOVERAGE
 150 %token TOK_LQ_LEVEL
 151 %token TOK_LQ_WSIZE
 152 %token TOK_LQ_MULT
 153 %token TOK_CLEAR_SCREEN
 154 %token TOK_PLNAME
 155 %token TOK_PLPARAM
 156
 157 %token TOK_HOSTLABEL
 158 %token TOK_NETLABEL
 159 %token TOK_MAXIPC
 160
 161 %token TOK_IP4BROADCAST
 162 %token TOK_IP6ADDRTYPE
 163 %token TOK_IP6MULTISITE
 164 %token TOK_IP6MULTIGLOBAL
 165 %token TOK_IFWEIGHT
 166 %token TOK_HELLOINT
 167 %token TOK_HELLOVAL
 168 %token TOK_TCINT
 169 %token TOK_TCVAL
 170 %token TOK_MIDINT
 171 %token TOK_MIDVAL
 172 %token TOK_HNAINT
 173 %token TOK_HNAVAL
 174
 175 %token TOK_IP4_ADDR
 176 %token TOK_IP6_ADDR
 177 %token TOK_DEFAULT
 178
 179 %token TOK_COMMENT
 180
 181 %%
 182
 183 conf:
 184           | conf block
 185           | conf stmt
 186 ;
 187
 188 stmt:       idebug
 189           | iipversion
 190           | bnoint
 191           | atos
 192           | awillingness
 193           | busehyst
 194           | fhystscale
 195           | fhystupper
 196           | fhystlower
 197           | fpollrate
 198           | atcredundancy
 199           | amprcoverage
 200           | alq_level
 201           | alq_wsize
 202           | bclear_screen
 203           | vcomment
 204 ;
 205
 206 block:      TOK_HNA4 hna4body
 207           | TOK_HNA6 hna6body
 208           | TOK_IPCCON ipcbody
 209           | ifblock ifbody
 210           | plblock plbody
 211 ;
 212
 213 hna4body:       TOK_OPEN hna4stmts TOK_CLOSE
 214 ;
 215
 216 hna4stmts: | hna4stmts hna4stmt
 217 ;
 218
 219 hna4stmt:  vcomment
 220          | ihna4entry
 221 ;
 222
 223 hna6body:       TOK_OPEN hna6stmts TOK_CLOSE
 224 ;
 225
 226 hna6stmts: | hna6stmts hna6stmt
 227 ;
 228
 229 hna6stmt:  vcomment
 230          | ihna6entry
 231 ;
 232
 233 ipcbody:    TOK_OPEN ipcstmts TOK_CLOSE
 234 ;
 235
 236 ipcstmts: | ipcstmts ipcstmt
 237 ;
 238
 239 ipcstmt:  vcomment
 240           | imaxipc
 241           | ipchost
 242           | ipcnet
 243 ;
 244
 245 ifblock:   ifstart ifnicks
 246 ;
 247
 248 ifnicks:   | ifnicks ifnick
 249 ;
 250
 251 ifbody:     TOK_OPEN ifstmts TOK_CLOSE
 252 ;
 253
 254 ifstmts:   | ifstmts ifstmt
 255 ;
 256
 257 ifstmt:      vcomment
 258              | iifweight
 259              | isetip4br
 260              | isetip6addrt
 261              | isetip6mults
 262              | isetip6multg
 263              | isethelloint
 264              | isethelloval
 265              | isettcint
 266              | isettcval
 267              | isetmidint
 268              | isetmidval
 269              | isethnaint
 270              | isethnaval
 271              | isetlqmult
 272 ;
 273
 274 plbody:     TOK_OPEN plstmts TOK_CLOSE
 275 ;
 276
 277 plstmts:   | plstmts plstmt
 278 ;
 279
 280 plstmt:     plparam
 281           | vcomment
 282 ;
 283
 284
 285 imaxipc: TOK_MAXIPC TOK_INTEGER
 286 {
 287   cnf->ipc_connections = $2->integer;
 288
 289   cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
 290
 291   free($2);
 292 }
 293 ;
 294
 295 ipchost: TOK_HOSTLABEL TOK_IP4_ADDR
 296 {
 297   struct in_addr in;
 298   struct ipc_host *ipch;
 299
 300   if(PARSER_DEBUG) printf("\tIPC host: %s\n", $2->string);
 301
 302   if(inet_aton($2->string, &in) == 0)
 303     {
 304       fprintf(stderr, "Failed converting IP address IPC %s\n", $2->string);
 305       return -1;
 306     }
 307
 308   ipch = malloc(sizeof(struct ipc_host));
 309   ipch->host.v4 = in.s_addr;
 310
 311   ipch->next = cnf->ipc_hosts;
 312   cnf->ipc_hosts = ipch;
 313
 314   free($2->string);
 315   free($2);
 316
 317 }
 318 ;
 319
 320 ipcnet: TOK_NETLABEL TOK_IP4_ADDR TOK_IP4_ADDR
 321 {
 322   struct in_addr in1, in2;
 323   struct ipc_net *ipcn;
 324
 325   if(PARSER_DEBUG) printf("\tIPC net: %s/%s\n", $2->string, $3->string);
 326
 327   if(inet_aton($2->string, &in1) == 0)
 328     {
 329       fprintf(stderr, "Failed converting IP net IPC %s\n", $2->string);
 330       return -1;
 331     }
 332
 333   if(inet_aton($3->string, &in2) == 0)
 334     {
 335       fprintf(stderr, "Failed converting IP mask IPC %s\n", $3->string);
 336       return -1;
 337     }
 338
 339   ipcn = malloc(sizeof(struct ipc_net));
 340   ipcn->net.v4 = in1.s_addr;
 341   ipcn->mask.v4 = in2.s_addr;
 342
 343   ipcn->next = cnf->ipc_nets;
 344   cnf->ipc_nets = ipcn;
 345
 346   free($2->string);
 347   free($2);
 348   free($3->string);
 349   free($3);
 350
 351 }
 352 ;
 353
 354 iifweight:       TOK_IFWEIGHT TOK_INTEGER
 355 {
 356   int ifcnt = ifs_in_curr_cfg;
 357   struct olsr_if *ifs = cnf->interfaces;
 358
 359   if(PARSER_DEBUG) printf("Fixed willingness: %d\n", $2->integer);
 360
 361   while(ifcnt)
 362     {
 363       ifs->cnf->weight.value = $2->integer;
 364       ifs->cnf->weight.fixed = OLSR_TRUE;
 365
 366       ifs = ifs->next;
 367       ifcnt--;
 368     }
 369
 370   free($2);
 371 }
 372 ;
 373
 374 isetip4br: TOK_IP4BROADCAST TOK_IP4_ADDR
 375 {
 376   struct in_addr in;
 377   int ifcnt = ifs_in_curr_cfg;
 378   struct olsr_if *ifs = cnf->interfaces;
 379
 380   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", $2->string);
 381
 382   if(inet_aton($2->string, &in) == 0)
 383     {
 384       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 385       return -1;
 386     }
 387
 388   while(ifcnt)
 389     {
 390       ifs->cnf->ipv4_broadcast.v4 = in.s_addr;
 391
 392       ifs = ifs->next;
 393       ifcnt--;
 394     }
 395
 396   free($2->string);
 397   free($2);
 398 }
 399 ;
 400
 401 isetip6addrt: TOK_IP6ADDRTYPE TOK_IP6TYPE
 402 {
 403   int ifcnt = ifs_in_curr_cfg;
 404   struct olsr_if *ifs = cnf->interfaces;
 405
 406   if($2->boolean)
 407     {
 408       while(ifcnt)
 409         {
 410           ifs->cnf->ipv6_addrtype = IPV6_ADDR_SITELOCAL;
 411
 412           ifs = ifs->next;
 413           ifcnt--;
 414         }
 415     }
 416   else
 417     {
 418       while(ifcnt)
 419         {
 420           ifs->cnf->ipv6_addrtype = 0;
 421
 422           ifs = ifs->next;
 423           ifcnt--;
 424         }
 425     }
 426
 427   free($2);
 428 }
 429 ;
 430
 431 isetip6mults: TOK_IP6MULTISITE TOK_IP6_ADDR
 432 {
 433   struct in6_addr in6;
 434   int ifcnt = ifs_in_curr_cfg;
 435   struct olsr_if *ifs = cnf->interfaces;
 436
 437   if(PARSER_DEBUG) printf("\tIPv6 site-local multicast: %s\n", $2->string);
 438
 439   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
 440     {
 441       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 442       return -1;
 443     }
 444
 445   while(ifcnt)
 446     {
 447       memcpy(&ifs->cnf->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
 448
 449       ifs = ifs->next;
 450       ifcnt--;
 451     }
 452
 453
 454   free($2->string);
 455   free($2);
 456 }
 457 ;
 458
 459
 460 isetip6multg: TOK_IP6MULTIGLOBAL TOK_IP6_ADDR
 461 {
 462   struct in6_addr in6;
 463   int ifcnt = ifs_in_curr_cfg;
 464   struct olsr_if *ifs = cnf->interfaces;
 465
 466   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", $2->string);
 467
 468   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
 469     {
 470       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 471       return -1;
 472     }
 473
 474   while(ifcnt)
 475     {
 476       memcpy(&ifs->cnf->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
 477
 478       ifs = ifs->next;
 479       ifcnt--;
 480     }
 481
 482
 483   free($2->string);
 484   free($2);
 485 }
 486 ;
 487 isethelloint: TOK_HELLOINT TOK_FLOAT
 488 {
 489   int ifcnt = ifs_in_curr_cfg;
 490   struct olsr_if *ifs = cnf->interfaces;
 491
 492   if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", $2->floating);
 493
 494   while(ifcnt)
 495     {
 496       ifs->cnf->hello_params.emission_interval = $2->floating;
 497
 498       ifs = ifs->next;
 499       ifcnt--;
 500     }
 501
 502   free($2);
 503 }
 504 ;
 505 isethelloval: TOK_HELLOVAL TOK_FLOAT
 506 {
 507   int ifcnt = ifs_in_curr_cfg;
 508   struct olsr_if *ifs = cnf->interfaces;
 509
 510   if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", $2->floating);
 511
 512   while(ifcnt)
 513     {
 514       ifs->cnf->hello_params.validity_time = $2->floating;
 515
 516       ifs = ifs->next;
 517       ifcnt--;
 518     }
 519
 520   free($2);
 521 }
 522 ;
 523 isettcint: TOK_TCINT TOK_FLOAT
 524 {
 525   int ifcnt = ifs_in_curr_cfg;
 526   struct olsr_if *ifs = cnf->interfaces;
 527
 528   if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", $2->floating);
 529
 530   while(ifcnt)
 531     {
 532       ifs->cnf->tc_params.emission_interval = $2->floating;
 533
 534       ifs = ifs->next;
 535       ifcnt--;
 536     }
 537   free($2);
 538 }
 539 ;
 540 isettcval: TOK_TCVAL TOK_FLOAT
 541 {
 542   int ifcnt = ifs_in_curr_cfg;
 543   struct olsr_if *ifs = cnf->interfaces;
 544
 545   if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", $2->floating);
 546   while(ifcnt)
 547     {
 548       ifs->cnf->tc_params.validity_time = $2->floating;
 549
 550       ifs = ifs->next;
 551       ifcnt--;
 552     }
 553
 554   free($2);
 555 }
 556 ;
 557 isetmidint: TOK_MIDINT TOK_FLOAT
 558 {
 559   int ifcnt = ifs_in_curr_cfg;
 560   struct olsr_if *ifs = cnf->interfaces;
 561
 562
 563   if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", $2->floating);
 564   while(ifcnt)
 565     {
 566       ifs->cnf->mid_params.emission_interval = $2->floating;
 567
 568       ifs = ifs->next;
 569       ifcnt--;
 570     }
 571
 572   free($2);
 573 }
 574 ;
 575 isetmidval: TOK_MIDVAL TOK_FLOAT
 576 {
 577   int ifcnt = ifs_in_curr_cfg;
 578   struct olsr_if *ifs = cnf->interfaces;
 579
 580   if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", $2->floating);
 581   while(ifcnt)
 582     {
 583       ifs->cnf->mid_params.validity_time = $2->floating;
 584
 585       ifs = ifs->next;
 586       ifcnt--;
 587     }
 588
 589   free($2);
 590 }
 591 ;
 592 isethnaint: TOK_HNAINT TOK_FLOAT
 593 {
 594   int ifcnt = ifs_in_curr_cfg;
 595   struct olsr_if *ifs = cnf->interfaces;
 596
 597   if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", $2->floating);
 598   while(ifcnt)
 599     {
 600       ifs->cnf->hna_params.emission_interval = $2->floating;
 601
 602       ifs = ifs->next;
 603       ifcnt--;
 604     }
 605
 606   free($2);
 607 }
 608 ;
 609 isethnaval: TOK_HNAVAL TOK_FLOAT
 610 {
 611   int ifcnt = ifs_in_curr_cfg;
 612   struct olsr_if *ifs = cnf->interfaces;
 613
 614   if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", $2->floating);
 615   while(ifcnt)
 616     {
 617       ifs->cnf->hna_params.validity_time = $2->floating;
 618
 619       ifs = ifs->next;
 620       ifcnt--;
 621     }
 622
 623   free($2);
 624 }
 625 ;
 626
 627 isetlqmult: TOK_LQ_MULT TOK_DEFAULT TOK_FLOAT
 628 {
 629   if (lq_mult_helper($2, $3) < 0)
 630     YYABORT;
 631 }
 632
 633           | TOK_LQ_MULT TOK_IP4_ADDR TOK_FLOAT
 634 {
 635   if (lq_mult_helper($2, $3) < 0)
 636     YYABORT;
 637 }
 638
 639           | TOK_LQ_MULT TOK_IP6_ADDR TOK_FLOAT
 640 {
 641   if (lq_mult_helper($2, $3) < 0)
 642     YYABORT;
 643 }
 644
 645           ;
 646
 647 idebug:       TOK_DEBUGLEVEL TOK_INTEGER
 648 {
 649
 650   cnf->debug_level = $2->integer;
 651   if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
 652   free($2);
 653 }
 654 ;
 655
 656
 657 iipversion:    TOK_IPVERSION TOK_INTEGER
 658 {
 659   if($2->integer == 4)
 660     cnf->ip_version = AF_INET;
 661   else if($2->integer == 6)
 662     cnf->ip_version = AF_INET6;
 663   else
 664     {
 665       fprintf(stderr, "IPversion must be 4 or 6!\n");
 666       YYABORT;
 667     }
 668
 669   if(PARSER_DEBUG) printf("IpVersion: %d\n", $2->integer);
 670   free($2);
 671 }
 672 ;
 673
 674
 675 ihna4entry:     TOK_IP4_ADDR TOK_IP4_ADDR
 676 {
 677   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
 678   struct in_addr in;
 679
 680   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
 681
 682   if(h == NULL)
 683     {
 684       fprintf(stderr, "Out of memory(HNA4)\n");
 685       YYABORT;
 686     }
 687
 688   if(inet_aton($1->string, &in) == 0)
 689     {
 690       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 691       return -1;
 692     }
 693   h->net.v4 = in.s_addr;
 694   if(inet_aton($2->string, &in) == 0)
 695     {
 696       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 697       return -1;
 698     }
 699   h->netmask.v4 = in.s_addr;
 700   /* Queue */
 701   h->next = cnf->hna4_entries;
 702   cnf->hna4_entries = h;
 703
 704   free($1->string);
 705   free($1);
 706   free($2->string);
 707   free($2);
 708
 709 }
 710 ;
 711
 712 ihna6entry:     TOK_IP6_ADDR TOK_INTEGER
 713 {
 714   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
 715   struct in6_addr in6;
 716
 717   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", $1->string, $2->integer);
 718
 719   if(h == NULL)
 720     {
 721       fprintf(stderr, "Out of memory(HNA6)\n");
 722       YYABORT;
 723     }
 724
 725   if(inet_pton(AF_INET6, $1->string, &in6) < 0)
 726     {
 727       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 728       return -1;
 729     }
 730   memcpy(&h->net, &in6, sizeof(struct in6_addr));
 731
 732   if(($2->integer < 0) || ($2->integer > 128))
 733     {
 734       fprintf(stderr, "Illegal IPv6 prefix length %d\n", $2->integer);
 735       return -1;
 736     }
 737
 738   h->prefix_len = $2->integer;
 739   /* Queue */
 740   h->next = cnf->hna6_entries;
 741   cnf->hna6_entries = h;
 742
 743   free($1->string);
 744   free($1);
 745   free($2);
 746
 747 }
 748 ;
 749
 750 ifstart: TOK_INTERFACE
 751 {
 752   printf("setting ifs_in_curr_cfg = 0\n");
 753   ifs_in_curr_cfg = 0;
 754
 755 }
 756 ;
 757
 758 ifnick: TOK_STRING
 759 {
 760   struct olsr_if *in = malloc(sizeof(struct olsr_if));
 761
 762   if(in == NULL)
 763     {
 764       fprintf(stderr, "Out of memory(ADD IF)\n");
 765       YYABORT;
 766     }
 767
 768   in->cnf = get_default_if_config();
 769
 770   if(in->cnf == NULL)
 771     {
 772       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
 773       YYABORT;
 774     }
 775
 776   in->name = $1->string;
 777
 778   /* Queue */
 779   in->next = cnf->interfaces;
 780   cnf->interfaces = in;
 781
 782   ifs_in_curr_cfg++;
 783
 784   free($1);
 785 }
 786 ;
 787
 788 bnoint: TOK_NOINT TOK_BOOLEAN
 789 {
 790   if(PARSER_DEBUG) printf("Noint set to %d\n", $2->boolean);
 791
 792   cnf->allow_no_interfaces = $2->boolean;
 793
 794   free($2);
 795 }
 796 ;
 797
 798 atos: TOK_TOS TOK_INTEGER
 799 {
 800   if(PARSER_DEBUG) printf("TOS: %d\n", $2->integer);
 801   cnf->tos = $2->integer;
 802
 803   free($2);
 804
 805 }
 806 ;
 807
 808 awillingness: TOK_WILLINGNESS TOK_INTEGER
 809 {
 810   cnf->willingness_auto = OLSR_FALSE;
 811
 812   if(PARSER_DEBUG) printf("Willingness: %d\n", $2->integer);
 813   cnf->willingness = $2->integer;
 814
 815   free($2);
 816
 817 }
 818 ;
 819
 820
 821
 822 busehyst: TOK_USEHYST TOK_BOOLEAN
 823 {
 824   cnf->use_hysteresis = $2->boolean;
 825   if(cnf->use_hysteresis)
 826     {
 827       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
 828     }
 829   else
 830     {
 831       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
 832     }
 833   free($2);
 834
 835 }
 836 ;
 837
 838
 839 fhystscale: TOK_HYSTSCALE TOK_FLOAT
 840 {
 841   cnf->hysteresis_param.scaling = $2->floating;
 842   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", $2->floating);
 843   free($2);
 844 }
 845 ;
 846
 847
 848 fhystupper: TOK_HYSTUPPER TOK_FLOAT
 849 {
 850   cnf->hysteresis_param.thr_high = $2->floating;
 851   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", $2->floating);
 852   free($2);
 853 }
 854 ;
 855
 856
 857 fhystlower: TOK_HYSTLOWER TOK_FLOAT
 858 {
 859   cnf->hysteresis_param.thr_low = $2->floating;
 860   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", $2->floating);
 861   free($2);
 862 }
 863 ;
 864
 865 fpollrate: TOK_POLLRATE TOK_FLOAT
 866 {
 867   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", $2->floating);
 868   cnf->pollrate = $2->floating;
 869
 870   free($2);
 871 }
 872 ;
 873
 874
 875 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
 876 {
 877   if(PARSER_DEBUG) printf("TC redundancy %d\n", $2->integer);
 878   cnf->tc_redundancy = $2->integer;
 879   free($2);
 880 }
 881 ;
 882
 883 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
 884 {
 885   if(PARSER_DEBUG) printf("MPR coverage %d\n", $2->integer);
 886   cnf->mpr_coverage = $2->integer;
 887   free($2);
 888 }
 889 ;
 890
 891 alq_level: TOK_LQ_LEVEL TOK_INTEGER
 892 {
 893   if(PARSER_DEBUG) printf("Link quality level %d\n", $2->integer);
 894   cnf->lq_level = $2->integer;
 895   free($2);
 896 }
 897 ;
 898
 899 alq_wsize: TOK_LQ_WSIZE TOK_INTEGER
 900 {
 901   if(PARSER_DEBUG) printf("Link quality window size %d\n", $2->integer);
 902   cnf->lq_wsize = $2->integer;
 903   free($2);
 904 }
 905 ;
 906
 907 bclear_screen: TOK_CLEAR_SCREEN TOK_BOOLEAN
 908 {
 909   cnf->clear_screen = $2->boolean;
 910
 911   if (PARSER_DEBUG)
 912     printf("Clear screen %s\n", cnf->clear_screen ? "enabled" : "disabled");
 913
 914   free($2);
 915 }
 916 ;
 917
 918 plblock: TOK_PLUGIN TOK_STRING
 919 {
 920   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
 921
 922   if(pe == NULL)
 923     {
 924       fprintf(stderr, "Out of memory(ADD PL)\n");
 925       YYABORT;
 926     }
 927
 928   pe->name = $2->string;
 929
 930   pe->params = NULL;
 931
 932   if(PARSER_DEBUG) printf("Plugin: %s\n", $2->string);
 933
 934   /* Queue */
 935   pe->next = cnf->plugins;
 936   cnf->plugins = pe;
 937
 938   free($2);
 939 }
 940 ;
 941
 942 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
 943 {
 944   struct plugin_param *pp = malloc(sizeof(struct plugin_param));
 945
 946   if(pp == NULL)
 947     {
 948       fprintf(stderr, "Out of memory(ADD PP)\n");
 949       YYABORT;
 950     }
 951
 952   if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
 953
 954   pp->key = $2->string;
 955   pp->value = $3->string;
 956
 957   /* Queue */
 958   pp->next = cnf->plugins->params;
 959   cnf->plugins->params = pp;
 960
 961   free($2);
 962   free($3);
 963 }
 964 ;
 965
 966 vcomment:       TOK_COMMENT
 967 {
 968     //if(PARSER_DEBUG) printf("Comment\n");
 969 }
 970 ;
 971
 972
 973
 974 %%
 975
 976 void yyerror (char *string)
 977 {
 978   fprintf(stderr, "Config line %d: %s\n", current_line, string);
 979 }