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