cf60d789fa2d6585c4ffcc988ba1fad85fe1d436
[olsrd.git] / 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 }