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.22 2004/11/29 20:10:35 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
  64
  65
  66
  67 %}
  68
  69 %token TOK_OPEN
  70 %token TOK_CLOSE
  71 %token TOK_SEMI
  72
  73 %token TOK_STRING
  74 %token TOK_INTEGER
  75 %token TOK_FLOAT
  76 %token TOK_BOOLEAN
  77
  78 %token TOK_IP6TYPE
  79
  80 %token TOK_DEBUGLEVEL
  81 %token TOK_IPVERSION
  82 %token TOK_HNA4
  83 %token TOK_HNA6
  84 %token TOK_PLUGIN
  85 %token TOK_INTERFACE
  86 %token TOK_NOINT
  87 %token TOK_TOS
  88 %token TOK_WILLINGNESS
  89 %token TOK_IPCCON
  90 %token TOK_USEHYST
  91 %token TOK_HYSTSCALE
  92 %token TOK_HYSTUPPER
  93 %token TOK_HYSTLOWER
  94 %token TOK_POLLRATE
  95 %token TOK_TCREDUNDANCY
  96 %token TOK_MPRCOVERAGE
  97 %token TOK_LQ_LEVEL
  98 %token TOK_LQ_WSIZE
  99 %token TOK_CLEAR_SCREEN
 100 %token TOK_PLNAME
 101 %token TOK_PLPARAM
 102
 103 %token TOK_HOSTLABEL
 104 %token TOK_NETLABEL
 105 %token TOK_MAXIPC
 106
 107 %token TOK_IP4BROADCAST
 108 %token TOK_IP6ADDRTYPE
 109 %token TOK_IP6MULTISITE
 110 %token TOK_IP6MULTIGLOBAL
 111 %token TOK_HELLOINT
 112 %token TOK_HELLOVAL
 113 %token TOK_TCINT
 114 %token TOK_TCVAL
 115 %token TOK_MIDINT
 116 %token TOK_MIDVAL
 117 %token TOK_HNAINT
 118 %token TOK_HNAVAL
 119
 120 %token TOK_IP4_ADDR
 121 %token TOK_IP6_ADDR
 122
 123 %token TOK_COMMENT
 124
 125 %%
 126
 127 conf:
 128           | conf block
 129           | conf stmt
 130 ;
 131
 132 stmt:       idebug
 133           | iipversion
 134           | bnoint
 135           | atos
 136           | awillingness
 137           | busehyst
 138           | fhystscale
 139           | fhystupper
 140           | fhystlower
 141           | fpollrate
 142           | atcredundancy
 143           | amprcoverage
 144           | alq_level
 145           | alq_wsize
 146           | bclear_screen
 147           | vcomment
 148 ;
 149
 150 block:      TOK_HNA4 hna4body
 151           | TOK_HNA6 hna6body
 152           | TOK_IPCCON ipcbody
 153           | ifblock ifbody
 154           | plblock plbody
 155 ;
 156
 157 hna4body:       TOK_OPEN hna4stmts TOK_CLOSE
 158 ;
 159
 160 hna4stmts: | hna4stmts hna4stmt
 161 ;
 162
 163 hna4stmt:  vcomment
 164          | ihna4entry
 165 ;
 166
 167 hna6body:       TOK_OPEN hna6stmts TOK_CLOSE
 168 ;
 169
 170 hna6stmts: | hna6stmts hna6stmt
 171 ;
 172
 173 hna6stmt:  vcomment
 174          | ihna6entry
 175 ;
 176
 177 ipcbody:    TOK_OPEN ipcstmts TOK_CLOSE
 178 ;
 179
 180 ipcstmts: | ipcstmts ipcstmt
 181 ;
 182
 183 ipcstmt:  vcomment
 184           | imaxipc
 185           | ipchost
 186           | ipcnet
 187 ;
 188
 189 ifbody:     TOK_OPEN ifstmts TOK_CLOSE
 190 ;
 191
 192 ifstmts:   | ifstmts ifstmt
 193 ;
 194
 195 ifstmt:      vcomment
 196              | isetip4br
 197              | isetip6addrt
 198              | isetip6mults
 199              | isetip6multg
 200              | isethelloint
 201              | isethelloval
 202              | isettcint
 203              | isettcval
 204              | isetmidint
 205              | isetmidval
 206              | isethnaint
 207              | isethnaval
 208 ;
 209
 210 plbody:     TOK_OPEN plstmts TOK_CLOSE
 211 ;
 212
 213 plstmts:   | plstmts plstmt
 214 ;
 215
 216 plstmt:     plparam
 217           | vcomment
 218 ;
 219
 220
 221 imaxipc: TOK_MAXIPC TOK_INTEGER
 222 {
 223   cnf->ipc_connections = $2->integer;
 224
 225   cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
 226
 227   free($2);
 228 }
 229 ;
 230
 231
 232 ipchost: TOK_HOSTLABEL TOK_IP4_ADDR
 233 {
 234   struct in_addr in;
 235   struct ipc_host *ipch;
 236
 237   if(PARSER_DEBUG) printf("\tIPC host: %s\n", $2->string);
 238
 239   if(inet_aton($2->string, &in) == 0)
 240     {
 241       fprintf(stderr, "Failed converting IP address IPC %s\n", $2->string);
 242       return -1;
 243     }
 244
 245   ipch = malloc(sizeof(struct ipc_host));
 246   ipch->host.v4 = in.s_addr;
 247
 248   ipch->next = cnf->ipc_hosts;
 249   cnf->ipc_hosts = ipch;
 250
 251   free($2->string);
 252   free($2);
 253
 254 }
 255 ;
 256
 257 ipcnet: TOK_NETLABEL TOK_IP4_ADDR TOK_IP4_ADDR
 258 {
 259   struct in_addr in1, in2;
 260   struct ipc_net *ipcn;
 261
 262   if(PARSER_DEBUG) printf("\tIPC net: %s/%s\n", $2->string, $3->string);
 263
 264   if(inet_aton($2->string, &in1) == 0)
 265     {
 266       fprintf(stderr, "Failed converting IP net IPC %s\n", $2->string);
 267       return -1;
 268     }
 269
 270   if(inet_aton($3->string, &in2) == 0)
 271     {
 272       fprintf(stderr, "Failed converting IP mask IPC %s\n", $3->string);
 273       return -1;
 274     }
 275
 276   ipcn = malloc(sizeof(struct ipc_net));
 277   ipcn->net.v4 = in1.s_addr;
 278   ipcn->mask.v4 = in2.s_addr;
 279
 280   ipcn->next = cnf->ipc_nets;
 281   cnf->ipc_nets = ipcn;
 282
 283   free($2->string);
 284   free($2);
 285   free($3->string);
 286   free($3);
 287
 288 }
 289 ;
 290
 291 isetip4br: TOK_IP4BROADCAST TOK_IP4_ADDR
 292 {
 293   struct in_addr in;
 294
 295   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", $2->string);
 296
 297   if(inet_aton($2->string, &in) == 0)
 298     {
 299       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 300       return -1;
 301     }
 302
 303   cnf->interfaces->cnf->ipv4_broadcast.v4 = in.s_addr;
 304
 305   free($2->string);
 306   free($2);
 307 }
 308 ;
 309
 310 isetip6addrt: TOK_IP6ADDRTYPE TOK_IP6TYPE
 311 {
 312   if($2->boolean)
 313     cnf->interfaces->cnf->ipv6_addrtype = IPV6_ADDR_SITELOCAL;
 314   else
 315     cnf->interfaces->cnf->ipv6_addrtype = 0;
 316
 317   free($2);
 318 }
 319 ;
 320
 321 isetip6mults: TOK_IP6MULTISITE TOK_IP6_ADDR
 322 {
 323   struct in6_addr in6;
 324
 325   if(PARSER_DEBUG) printf("\tIPv6 site-local multicast: %s\n", $2->string);
 326
 327   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
 328     {
 329       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 330       return -1;
 331     }
 332   memcpy(&cnf->interfaces->cnf->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
 333
 334
 335   free($2->string);
 336   free($2);
 337 }
 338 ;
 339
 340
 341 isetip6multg: TOK_IP6MULTIGLOBAL TOK_IP6_ADDR
 342 {
 343   struct in6_addr in6;
 344
 345   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", $2->string);
 346
 347   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
 348     {
 349       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
 350       return -1;
 351     }
 352   memcpy(&cnf->interfaces->cnf->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
 353
 354
 355   free($2->string);
 356   free($2);
 357 }
 358 ;
 359 isethelloint: TOK_HELLOINT TOK_FLOAT
 360 {
 361     if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", $2->floating);
 362     cnf->interfaces->cnf->hello_params.emission_interval = $2->floating;
 363     free($2);
 364 }
 365 ;
 366 isethelloval: TOK_HELLOVAL TOK_FLOAT
 367 {
 368     if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", $2->floating);
 369     cnf->interfaces->cnf->hello_params.validity_time = $2->floating;
 370     free($2);
 371 }
 372 ;
 373 isettcint: TOK_TCINT TOK_FLOAT
 374 {
 375     if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", $2->floating);
 376     cnf->interfaces->cnf->tc_params.emission_interval = $2->floating;
 377     free($2);
 378 }
 379 ;
 380 isettcval: TOK_TCVAL TOK_FLOAT
 381 {
 382     if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", $2->floating);
 383     cnf->interfaces->cnf->tc_params.validity_time = $2->floating;
 384     free($2);
 385 }
 386 ;
 387 isetmidint: TOK_MIDINT TOK_FLOAT
 388 {
 389     if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", $2->floating);
 390     cnf->interfaces->cnf->mid_params.emission_interval = $2->floating;
 391     free($2);
 392 }
 393 ;
 394 isetmidval: TOK_MIDVAL TOK_FLOAT
 395 {
 396     if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", $2->floating);
 397     cnf->interfaces->cnf->mid_params.validity_time = $2->floating;
 398     free($2);
 399 }
 400 ;
 401 isethnaint: TOK_HNAINT TOK_FLOAT
 402 {
 403     if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", $2->floating);
 404     cnf->interfaces->cnf->hna_params.emission_interval = $2->floating;
 405     free($2);
 406 }
 407 ;
 408 isethnaval: TOK_HNAVAL TOK_FLOAT
 409 {
 410     if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", $2->floating);
 411     cnf->interfaces->cnf->hna_params.validity_time = $2->floating;
 412     free($2);
 413 }
 414 ;
 415
 416
 417 idebug:       TOK_DEBUGLEVEL TOK_INTEGER
 418 {
 419
 420   cnf->debug_level = $2->integer;
 421   if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
 422   free($2);
 423 }
 424 ;
 425
 426
 427 iipversion:    TOK_IPVERSION TOK_INTEGER
 428 {
 429   if($2->integer == 4)
 430     cnf->ip_version = AF_INET;
 431   else if($2->integer == 6)
 432     cnf->ip_version = AF_INET6;
 433   else
 434     {
 435       fprintf(stderr, "IPversion must be 4 or 6!\n");
 436       YYABORT;
 437     }
 438
 439   if(PARSER_DEBUG) printf("IpVersion: %d\n", $2->integer);
 440   free($2);
 441 }
 442 ;
 443
 444
 445 ihna4entry:     TOK_IP4_ADDR TOK_IP4_ADDR
 446 {
 447   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
 448   struct in_addr in;
 449
 450   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
 451
 452   if(h == NULL)
 453     {
 454       fprintf(stderr, "Out of memory(HNA4)\n");
 455       YYABORT;
 456     }
 457
 458   if(inet_aton($1->string, &in) == 0)
 459     {
 460       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 461       return -1;
 462     }
 463   h->net.v4 = in.s_addr;
 464   if(inet_aton($2->string, &in) == 0)
 465     {
 466       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 467       return -1;
 468     }
 469   h->netmask.v4 = in.s_addr;
 470   /* Queue */
 471   h->next = cnf->hna4_entries;
 472   cnf->hna4_entries = h;
 473
 474   free($1->string);
 475   free($1);
 476   free($2->string);
 477   free($2);
 478
 479 }
 480 ;
 481
 482 ihna6entry:     TOK_IP6_ADDR TOK_INTEGER
 483 {
 484   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
 485   struct in6_addr in6;
 486
 487   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", $1->string, $2->integer);
 488
 489   if(h == NULL)
 490     {
 491       fprintf(stderr, "Out of memory(HNA6)\n");
 492       YYABORT;
 493     }
 494
 495   if(inet_pton(AF_INET6, $1->string, &in6) < 0)
 496     {
 497       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
 498       return -1;
 499     }
 500   memcpy(&h->net, &in6, sizeof(struct in6_addr));
 501
 502   if(($2->integer < 0) || ($2->integer > 128))
 503     {
 504       fprintf(stderr, "Illegal IPv6 prefix length %d\n", $2->integer);
 505       return -1;
 506     }
 507
 508   h->prefix_len = $2->integer;
 509   /* Queue */
 510   h->next = cnf->hna6_entries;
 511   cnf->hna6_entries = h;
 512
 513   free($1->string);
 514   free($1);
 515   free($2);
 516
 517 }
 518 ;
 519
 520 ifblock: TOK_INTERFACE TOK_STRING
 521 {
 522   struct olsr_if *in = malloc(sizeof(struct olsr_if));
 523
 524   if(in == NULL)
 525     {
 526       fprintf(stderr, "Out of memory(ADD IF)\n");
 527       YYABORT;
 528     }
 529
 530   in->cnf = get_default_if_config();
 531
 532   if(in->cnf == NULL)
 533     {
 534       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
 535       YYABORT;
 536     }
 537
 538   in->name = $2->string;
 539
 540   /* Queue */
 541   in->next = cnf->interfaces;
 542   cnf->interfaces = in;
 543
 544   free($2);
 545 }
 546 ;
 547
 548 bnoint: TOK_NOINT TOK_BOOLEAN
 549 {
 550   if(PARSER_DEBUG) printf("Noint set to %d\n", $2->boolean);
 551
 552   cnf->allow_no_interfaces = $2->boolean;
 553
 554   free($2);
 555 }
 556 ;
 557
 558 atos: TOK_TOS TOK_INTEGER
 559 {
 560   if(PARSER_DEBUG) printf("TOS: %d\n", $2->integer);
 561   cnf->tos = $2->integer;
 562
 563   free($2);
 564
 565 }
 566 ;
 567
 568 awillingness: TOK_WILLINGNESS TOK_INTEGER
 569 {
 570   cnf->willingness_auto = OLSR_FALSE;
 571
 572   if(PARSER_DEBUG) printf("Willingness: %d\n", $2->integer);
 573   cnf->willingness = $2->integer;
 574
 575   free($2);
 576
 577 }
 578 ;
 579
 580
 581
 582 busehyst: TOK_USEHYST TOK_BOOLEAN
 583 {
 584   cnf->use_hysteresis = $2->boolean;
 585   if(cnf->use_hysteresis)
 586     {
 587       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
 588     }
 589   else
 590     {
 591       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
 592     }
 593   free($2);
 594
 595 }
 596 ;
 597
 598
 599 fhystscale: TOK_HYSTSCALE TOK_FLOAT
 600 {
 601   cnf->hysteresis_param.scaling = $2->floating;
 602   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", $2->floating);
 603   free($2);
 604 }
 605 ;
 606
 607
 608 fhystupper: TOK_HYSTUPPER TOK_FLOAT
 609 {
 610   cnf->hysteresis_param.thr_high = $2->floating;
 611   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", $2->floating);
 612   free($2);
 613 }
 614 ;
 615
 616
 617 fhystlower: TOK_HYSTLOWER TOK_FLOAT
 618 {
 619   cnf->hysteresis_param.thr_low = $2->floating;
 620   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", $2->floating);
 621   free($2);
 622 }
 623 ;
 624
 625 fpollrate: TOK_POLLRATE TOK_FLOAT
 626 {
 627   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", $2->floating);
 628   cnf->pollrate = $2->floating;
 629
 630   free($2);
 631 }
 632 ;
 633
 634
 635 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
 636 {
 637   if(PARSER_DEBUG) printf("TC redundancy %d\n", $2->integer);
 638   cnf->tc_redundancy = $2->integer;
 639   free($2);
 640 }
 641 ;
 642
 643 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
 644 {
 645   if(PARSER_DEBUG) printf("MPR coverage %d\n", $2->integer);
 646   cnf->mpr_coverage = $2->integer;
 647   free($2);
 648 }
 649 ;
 650
 651 alq_level: TOK_LQ_LEVEL TOK_INTEGER
 652 {
 653   if(PARSER_DEBUG) printf("Link quality level %d\n", $2->integer);
 654   cnf->lq_level = $2->integer;
 655   free($2);
 656 }
 657 ;
 658
 659 alq_wsize: TOK_LQ_WSIZE TOK_INTEGER
 660 {
 661   if(PARSER_DEBUG) printf("Link quality window size %d\n", $2->integer);
 662   cnf->lq_wsize = $2->integer;
 663   free($2);
 664 }
 665 ;
 666
 667 bclear_screen: TOK_CLEAR_SCREEN TOK_BOOLEAN
 668 {
 669   cnf->clear_screen = $2->boolean;
 670
 671   if (PARSER_DEBUG)
 672     printf("Clear screen %s\n", cnf->clear_screen ? "enabled" : "disabled");
 673
 674   free($2);
 675 }
 676 ;
 677
 678 plblock: TOK_PLUGIN TOK_STRING
 679 {
 680   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
 681
 682   if(pe == NULL)
 683     {
 684       fprintf(stderr, "Out of memory(ADD PL)\n");
 685       YYABORT;
 686     }
 687
 688   pe->name = $2->string;
 689
 690   pe->params = NULL;
 691
 692   if(PARSER_DEBUG) printf("Plugin: %s\n", $2->string);
 693
 694   /* Queue */
 695   pe->next = cnf->plugins;
 696   cnf->plugins = pe;
 697
 698   free($2);
 699 }
 700 ;
 701
 702 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
 703 {
 704   struct plugin_param *pp = malloc(sizeof(struct plugin_param));
 705
 706   if(pp == NULL)
 707     {
 708       fprintf(stderr, "Out of memory(ADD PP)\n");
 709       YYABORT;
 710     }
 711
 712   if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
 713
 714   pp->key = $2->string;
 715   pp->value = $3->string;
 716
 717   /* Queue */
 718   pp->next = cnf->plugins->params;
 719   cnf->plugins->params = pp;
 720
 721   free($2);
 722   free($3);
 723 }
 724 ;
 725
 726 vcomment:       TOK_COMMENT
 727 {
 728     //if(PARSER_DEBUG) printf("Comment\n");
 729 }
 730 ;
 731
 732
 733
 734 %%
 735
 736 void yyerror (char *string)
 737 {
 738   fprintf(stderr, "Config line %d: %s\n", current_line, string);
 739 }