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