Fix parser error for ipv6src interface parameter
[olsrd.git] / src / cfgparser / oparse.y
1 %{
2
3 /*
4  * The olsr.org Optimized Link-State Routing daemon(olsrd)
5  * Copyright (c) 2004, Andreas Tonnesen(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  */
42
43
44 #include "olsrd_conf.h"
45 #include "../defs.h"
46 #include "../ipcalc.h"
47 #include "../net_olsr.h"
48 #include "../link_set.h"
49 #include "../olsr.h"
50
51 #include <stddef.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <sys/types.h>
55 #include <sys/socket.h>
56 #include <netinet/in.h>
57 #include <arpa/inet.h>
58 #include <string.h>
59
60 #define PARSER_DEBUG 1
61
62 #if PARSER_DEBUG
63 #define PARSER_DEBUG_PRINTF(x, args...)   printf(x, ##args)
64 #else
65 #define PARSER_DEBUG_PRINTF(x, args...)   do { } while (0)
66 #endif
67
68 #define SET_IFS_CONF(ifs, ifcnt, field, value) do { \
69         for (; ifcnt>0; ifs=ifs->next, ifcnt--) { \
70     ifs->cnfi->field = (value); \
71     ifs->cnf->field = (value); \
72         } \
73 } while (0)
74
75 #define YYSTYPE struct conf_token *
76
77 void yyerror(const char *);
78 int yylex(void);
79
80 static int ifs_in_curr_cfg = 0;
81
82 static int add_ipv6_addr(YYSTYPE ipaddr_arg, YYSTYPE prefixlen_arg);
83
84 static int lq_mult_helper(YYSTYPE ip_addr_arg, YYSTYPE mult_arg)
85 {
86   union olsr_ip_addr addr;
87   int i;
88   struct olsr_if *walker;
89
90 #if PARSER_DEBUG > 0
91   printf("\tLinkQualityMult %s %0.2f\n",
92          (ip_addr_arg != NULL) ? ip_addr_arg->string : "any",
93          mult_arg->floating);
94 #endif
95
96   memset(&addr, 0, sizeof(addr));
97
98   if (ip_addr_arg != NULL &&
99      inet_pton(olsr_cnf->ip_version, ip_addr_arg->string, &addr) <= 0) {
100     fprintf(stderr, "Cannot parse IP address %s.\n", ip_addr_arg->string);
101     return -1;
102   }
103
104   walker = olsr_cnf->interfaces;
105
106   for (i = 0; i < ifs_in_curr_cfg; i++) {
107     struct olsr_lq_mult *mult = malloc(sizeof(*mult));
108     if (mult == NULL) {
109       fprintf(stderr, "Out of memory (LQ multiplier).\n");
110       return -1;
111     }
112
113     mult->addr = addr;
114     mult->value = (uint32_t)(mult_arg->floating * LINK_LOSS_MULTIPLIER);
115
116     mult->next = walker->cnf->lq_mult;
117     walker->cnfi->lq_mult = walker->cnf->lq_mult = mult;
118     walker->cnf->orig_lq_mult_cnt++;
119     walker->cnfi->orig_lq_mult_cnt=walker->cnf->orig_lq_mult_cnt;
120
121     walker = walker->next;
122   }
123
124   if (ip_addr_arg != NULL) {
125     free(ip_addr_arg->string);
126     free(ip_addr_arg);
127   }
128
129   free(mult_arg);
130
131   return 0;
132 }
133
134 static int add_ipv6_addr(YYSTYPE ipaddr_arg, YYSTYPE prefixlen_arg)
135 {
136   union olsr_ip_addr ipaddr;
137   PARSER_DEBUG_PRINTF("HNA IPv6 entry: %s/%d\n", ipaddr_arg->string, prefixlen_arg->integer);
138
139   if (olsr_cnf->ip_version != AF_INET6) {
140     fprintf(stderr, "IPv6 addresses can only be used if \"IpVersion\" == 6, skipping HNA6.\n");
141     olsr_startup_sleep(3);
142   }
143         else {
144           if(inet_pton(AF_INET6, ipaddr_arg->string, &ipaddr) <= 0) {
145       fprintf(stderr, "ihna6entry: Failed converting IP address %s\n", ipaddr_arg->string);
146       return 1;
147     }
148
149                 if (prefixlen_arg->integer > 128) {
150                         fprintf(stderr, "ihna6entry: Illegal IPv6 prefix length %d\n", prefixlen_arg->integer);
151                         return 1;
152                 }
153
154                 /* Queue */
155                 ip_prefix_list_add(&olsr_cnf->hna_entries, &ipaddr, prefixlen_arg->integer);
156         }
157   free(ipaddr_arg->string);
158   free(ipaddr_arg);
159   free(prefixlen_arg);
160
161   return 0;
162 }
163
164 %}
165
166 %token TOK_SLASH
167 %token TOK_OPEN
168 %token TOK_CLOSE
169
170 %token TOK_STRING
171 %token TOK_INTEGER
172 %token TOK_FLOAT
173 %token TOK_BOOLEAN
174
175 %token TOK_IPV6TYPE
176
177 %token TOK_DEBUGLEVEL
178 %token TOK_IPVERSION
179 %token TOK_HNA4
180 %token TOK_HNA6
181 %token TOK_PLUGIN
182 %token TOK_INTERFACE_DEFAULTS
183 %token TOK_INTERFACE
184 %token TOK_NOINT
185 %token TOK_TOS
186 %token TOK_OLSRPORT
187 %token TOK_RTPROTO
188 %token TOK_RTTABLE
189 %token TOK_RTTABLE_DEFAULT
190 %token TOK_RTTABLE_TUNNEL
191 %token TOK_RTTABLE_PRIORITY
192 %token TOK_RTTABLE_DEFAULTOLSR_PRIORITY
193 %token TOK_RTTABLE_TUNNEL_PRIORITY
194 %token TOK_RTTABLE_DEFAULT_PRIORITY
195 %token TOK_WILLINGNESS
196 %token TOK_IPCCON
197 %token TOK_FIBMETRIC
198 %token TOK_USEHYST
199 %token TOK_HYSTSCALE
200 %token TOK_HYSTUPPER
201 %token TOK_HYSTLOWER
202 %token TOK_POLLRATE
203 %token TOK_NICCHGSPOLLRT
204 %token TOK_TCREDUNDANCY
205 %token TOK_MPRCOVERAGE
206 %token TOK_LQ_LEVEL
207 %token TOK_LQ_FISH
208 %token TOK_LQ_AGING
209 %token TOK_LQ_PLUGIN
210 %token TOK_LQ_NAT_THRESH
211 %token TOK_LQ_MULT
212 %token TOK_CLEAR_SCREEN
213 %token TOK_PLPARAM
214 %token TOK_MIN_TC_VTIME
215 %token TOK_LOCK_FILE
216 %token TOK_USE_NIIT
217 %token TOK_SMART_GW
218 %token TOK_SMART_GW_ALLOW_NAT
219 %token TOK_SMART_GW_UPLINK
220 %token TOK_SMART_GW_UPLINK_NAT
221 %token TOK_SMART_GW_SPEED
222 %token TOK_SMART_GW_PREFIX
223 %token TOK_SRC_IP_ROUTES
224 %token TOK_MAIN_IP
225
226 %token TOK_HOSTLABEL
227 %token TOK_NETLABEL
228 %token TOK_MAXIPC
229
230 %token TOK_IFMODE
231 %token TOK_IPV4MULTICAST
232 %token TOK_IP4BROADCAST
233 %token TOK_IPV4BROADCAST
234 %token TOK_IPV6MULTICAST
235 %token TOK_IPV4SRC
236 %token TOK_IPV6SRC
237 %token TOK_IFWEIGHT
238 %token TOK_HELLOINT
239 %token TOK_HELLOVAL
240 %token TOK_TCINT
241 %token TOK_TCVAL
242 %token TOK_MIDINT
243 %token TOK_MIDVAL
244 %token TOK_HNAINT
245 %token TOK_HNAVAL
246 %token TOK_AUTODETCHG
247
248 %token TOK_IPV4_ADDR
249 %token TOK_IPV6_ADDR
250 %token TOK_DEFAULT
251 %token TOK_AUTO
252 %token TOK_NONE
253
254 %token TOK_COMMENT
255
256 %%
257
258 conf:
259           | conf block
260           | conf stmt
261 ;
262
263 stmt:       idebug
264           | iipversion
265           | fibmetric
266           | bnoint
267           | atos
268           | aolsrport
269           | irtproto
270           | irttable
271           | irttable_default
272           | irttable_tunnel
273           | irttable_priority
274           | irttable_defaultolsr_priority
275           | irttable_tunnel_priority
276           | irttable_default_priority
277           | awillingness
278           | busehyst
279           | fhystscale
280           | fhystupper
281           | fhystlower
282           | fpollrate
283           | fnicchgspollrt
284           | atcredundancy
285           | amprcoverage
286           | alq_level
287           | alq_plugin
288           | alq_fish
289           | anat_thresh
290           | alq_aging
291           | bclear_screen
292           | vcomment
293           | amin_tc_vtime
294           | alock_file
295           | suse_niit
296           | bsmart_gw
297           | bsmart_gw_allow_nat
298           | ssmart_gw_uplink
299           | bsmart_gw_uplink_nat
300           | ismart_gw_speed
301           | ismart_gw_prefix
302           | bsrc_ip_routes
303           | amain_ip
304 ;
305
306 block:      TOK_HNA4 hna4body
307           | TOK_HNA6 hna6body
308           | TOK_IPCCON ipcbody
309           | ifdblock ifdbody
310           | ifblock ifbody
311           | plblock plbody
312 ;
313
314 hna4body:       TOK_OPEN hna4stmts TOK_CLOSE
315 ;
316
317 hna4stmts: | hna4stmts hna4stmt
318 ;
319
320 hna4stmt:  vcomment
321          | ihna4entry
322 ;
323
324 hna6body:       TOK_OPEN hna6stmts TOK_CLOSE
325 ;
326
327 hna6stmts: | hna6stmts hna6stmt
328 ;
329
330 hna6stmt:  vcomment
331          | ihna6entry
332 ;
333
334 ipcbody:    TOK_OPEN ipcstmts TOK_CLOSE
335 ;
336
337 ipcstmts: | ipcstmts ipcstmt
338 ;
339
340 ipcstmt:  vcomment
341           | imaxipc
342           | ipchost
343           | ipcnet
344 ;
345
346 ifblock:   ifstart ifnicks
347 ;
348
349 ifnicks:   | ifnicks ifnick
350 ;
351
352 ifbody:     TOK_OPEN ifstmts TOK_CLOSE
353 ;
354
355 ifdbody:     TOK_OPEN ifstmts TOK_CLOSE
356 {
357   struct olsr_if *in = olsr_cnf->interfaces;
358   printf("\nInterface Defaults");
359   /*remove Interface Defaults from Interface list as they are no interface!*/
360   olsr_cnf->interfaces = in->next;
361   ifs_in_curr_cfg=0;
362   /*free interface but keep its config intact?*/
363   free(in->cnfi);
364   free(in);
365
366 }
367 ;
368
369 ifstmts:   | ifstmts ifstmt
370 ;
371
372 ifstmt:      vcomment
373              | iifweight
374              | isetifmode
375              | TOK_IP4BROADCAST isetipv4mc
376              | TOK_IPV4BROADCAST isetipv4mc
377              | TOK_IPV4MULTICAST isetipv4mc
378              | isetipv6mc
379              | isetipv4src
380              | isetipv6src
381              | isethelloint
382              | isethelloval
383              | isettcint
384              | isettcval
385              | isetmidint
386              | isetmidval
387              | isethnaint
388              | isethnaval
389              | isetautodetchg
390              | isetlqmult
391 ;
392
393 plbody:     TOK_OPEN plstmts TOK_CLOSE
394 ;
395
396 plstmts:   | plstmts plstmt
397 ;
398
399 plstmt:     plparam
400           | vcomment
401 ;
402
403 ifdblock: TOK_INTERFACE_DEFAULTS
404 {
405   struct olsr_if *in = malloc(sizeof(*in));
406
407   if (in == NULL) {
408     fprintf(stderr, "Out of memory(ADD IF)\n");
409     YYABORT;
410   }
411
412   in->cnf = get_default_if_config();
413   in->cnfi = get_default_if_config();
414
415   if (in->cnf == NULL || in->cnfi == NULL) {
416     fprintf(stderr, "Out of memory(ADD DEFIFRULE)\n");
417     YYABORT;
418   }
419
420   //should not need a name any more, as we free it on "}" again
421   //in->name = strdup(interface_defaults_name);
422
423   olsr_cnf->interface_defaults = in->cnf;
424
425   /* Queue */
426   in->next = olsr_cnf->interfaces;
427   olsr_cnf->interfaces = in;
428   ifs_in_curr_cfg=1;
429   
430   fflush(stdout);
431 }
432 ;
433
434 imaxipc: TOK_MAXIPC TOK_INTEGER
435 {
436   olsr_cnf->ipc_connections = $2->integer;
437   free($2);
438 }
439 ;
440
441 ipchost: TOK_HOSTLABEL TOK_IPV4_ADDR
442 {
443   union olsr_ip_addr ipaddr;
444   PARSER_DEBUG_PRINTF("\tIPC host: %s\n", $2->string);
445   
446   if (inet_aton($2->string, &ipaddr.v4) == 0) {
447     fprintf(stderr, "Failed converting IP address IPC %s\n", $2->string);
448     YYABORT;
449   }
450
451   ip_prefix_list_add(&olsr_cnf->ipc_nets, &ipaddr, olsr_cnf->maxplen);
452
453   free($2->string);
454   free($2);
455 }
456 ;
457
458 ipcnet: TOK_NETLABEL TOK_IPV4_ADDR TOK_IPV4_ADDR
459 {
460   union olsr_ip_addr ipaddr, netmask;
461
462   PARSER_DEBUG_PRINTF("\tIPC net: %s/%s\n", $2->string, $3->string);
463   
464   if (inet_pton(AF_INET, $2->string, &ipaddr.v4) == 0) {
465     fprintf(stderr, "Failed converting IP net IPC %s\n", $2->string);
466     YYABORT;
467   }
468
469   if (inet_pton(AF_INET, $3->string, &netmask.v4) == 0) {
470     fprintf(stderr, "Failed converting IP mask IPC %s\n", $3->string);
471     YYABORT;
472   }
473
474   ip_prefix_list_add(&olsr_cnf->ipc_nets, &ipaddr, olsr_netmask_to_prefix(&netmask));
475
476   free($2->string);
477   free($2);
478   free($3->string);
479   free($3);
480 }
481         |       TOK_NETLABEL TOK_IPV4_ADDR TOK_SLASH TOK_INTEGER
482 {
483   union olsr_ip_addr ipaddr;
484
485   PARSER_DEBUG_PRINTF("\tIPC net: %s/%s\n", $2->string, $3->string);
486   
487   if (inet_pton(AF_INET, $2->string, &ipaddr.v4) == 0) {
488     fprintf(stderr, "Failed converting IP net IPC %s\n", $2->string);
489     YYABORT;
490   }
491
492   if ($4->integer > olsr_cnf->maxplen) {
493     fprintf(stderr, "ipcnet: Prefix len %u > %d is not allowed!\n", $4->integer, olsr_cnf->maxplen);
494     YYABORT;
495   }
496
497   ip_prefix_list_add(&olsr_cnf->ipc_nets, &ipaddr, $4->integer);
498
499   free($2->string);
500   free($2);
501   free($4);
502 }
503 ;
504
505 iifweight:       TOK_IFWEIGHT TOK_INTEGER
506 {
507   int ifcnt = ifs_in_curr_cfg;
508   struct olsr_if *ifs = olsr_cnf->interfaces;
509
510   PARSER_DEBUG_PRINTF("Fixed willingness: %d\n", $2->integer);
511
512   while (ifcnt) {
513     ifs->cnf->weight.value = $2->integer;
514     ifs->cnf->weight.fixed = true;
515     ifs->cnfi->weight.value = $2->integer;
516     ifs->cnfi->weight.fixed = true;
517
518     ifs = ifs->next;
519     ifcnt--;
520   }
521
522   free($2);
523 }
524 ;
525
526 isetifmode: TOK_IFMODE TOK_STRING
527 {
528   int ifcnt = ifs_in_curr_cfg;
529   struct olsr_if *ifs = olsr_cnf->interfaces;
530         int mode = (strcmp($2->string, "ether") == 0)?IF_MODE_ETHER:IF_MODE_MESH;
531
532   PARSER_DEBUG_PRINTF("\tMode: %s\n", $2->string);
533
534         SET_IFS_CONF(ifs, ifcnt, mode, mode);
535         
536   free($2->string);
537   free($2);
538 }
539 ;
540
541 /* called if prepended with TOK_IPV4MULTICAST TOK_IP4BROADCAST TOK_IPV4BROADCAST */
542 isetipv4mc: TOK_IPV4_ADDR
543 {
544   struct in_addr in;
545   int ifcnt = ifs_in_curr_cfg;
546   struct olsr_if *ifs = olsr_cnf->interfaces;
547
548   PARSER_DEBUG_PRINTF("\tIPv4 broadcast: %s\n", $1->string);
549
550   if (inet_aton($1->string, &in) == 0) {
551     fprintf(stderr, "isetipv4br: Failed converting IP address %s\n", $1->string);
552     YYABORT;
553   }
554
555         SET_IFS_CONF(ifs, ifcnt, ipv4_multicast.v4, in);
556
557   free($1->string);
558   free($1);
559 }
560 ;
561
562 isetipv6mc: TOK_IPV6MULTICAST TOK_IPV6_ADDR
563 {
564   struct in6_addr in6;
565   int ifcnt = ifs_in_curr_cfg;
566   struct olsr_if *ifs = olsr_cnf->interfaces;
567
568   PARSER_DEBUG_PRINTF("\tIPv6 multicast: %s\n", $2->string);
569
570   if (inet_pton(AF_INET6, $2->string, &in6) <= 0) {
571     fprintf(stderr, "isetipv6mc: Failed converting IP address %s\n", $2->string);
572     YYABORT;
573   }
574
575         SET_IFS_CONF(ifs, ifcnt, ipv6_multicast.v6, in6);
576
577   free($2->string);
578   free($2);
579 }
580 ;
581
582 isetipv4src: TOK_IPV4SRC TOK_IPV4_ADDR
583 {
584   struct in_addr in;
585   int ifcnt = ifs_in_curr_cfg;
586   struct olsr_if *ifs = olsr_cnf->interfaces;
587
588   PARSER_DEBUG_PRINTF("\tIPv4 src: %s\n", $2->string);
589
590   if (inet_aton($2->string, &in) == 0) {
591     fprintf(stderr, "isetipv4src: Failed converting IP address %s\n", $2->string);
592     YYABORT;
593   }
594
595         SET_IFS_CONF(ifs, ifcnt, ipv4_src.v4, in);
596
597   free($2->string);
598   free($2);
599 }
600 ;
601
602 isetipv6src: TOK_IPV6SRC TOK_IPV6_ADDR TOK_SLASH TOK_INTEGER
603 {
604   struct olsr_ip_prefix pr6;
605   int ifcnt = ifs_in_curr_cfg;
606   struct olsr_if *ifs = olsr_cnf->interfaces;
607
608   PARSER_DEBUG_PRINTF("\tIPv6 src prefix: %s/%d\n", $2->string, $4->integer);
609
610   if (inet_pton(AF_INET6, $2->string, &pr6.prefix.v6) <= 0) {
611     fprintf(stderr, "isetipv6src: Failed converting IP address %s\n", $2->string);
612     YYABORT;
613   }
614   if ($4->integer > 128) {
615     fprintf(stderr, "isetipv6src: Illegal Prefixlength %d\n", $4->integer);
616     YYABORT;
617   }
618   pr6.prefix_len = $4->integer;
619
620         SET_IFS_CONF(ifs, ifcnt, ipv6_src, pr6);
621
622   free($2->string);
623   free($2);
624 }
625         | TOK_IPV6SRC TOK_IPV6_ADDR
626 {
627   struct olsr_ip_prefix pr6;
628   int ifcnt = ifs_in_curr_cfg;
629   struct olsr_if *ifs = olsr_cnf->interfaces;
630
631   PARSER_DEBUG_PRINTF("\tIPv6 src prefix: %s/%d\n", $2->string, 128);
632
633   if (inet_pton(AF_INET6, $2->string, &pr6.prefix.v6) <= 0) {
634     fprintf(stderr, "isetipv6src: Failed converting IP address %s\n", $2->string);
635     YYABORT;
636   }
637   pr6.prefix_len = 128;
638
639   SET_IFS_CONF(ifs, ifcnt, ipv6_src, pr6);
640
641   free($2->string);
642   free($2);
643 }
644 ;
645
646 isethelloint: TOK_HELLOINT TOK_FLOAT
647 {
648   int ifcnt = ifs_in_curr_cfg;
649   struct olsr_if *ifs = olsr_cnf->interfaces;
650
651   PARSER_DEBUG_PRINTF("\tHELLO interval: %0.2f\n", $2->floating);
652
653         SET_IFS_CONF(ifs, ifcnt, hello_params.emission_interval, $2->floating);
654
655   free($2);
656 }
657 ;
658 isethelloval: TOK_HELLOVAL TOK_FLOAT
659 {
660   int ifcnt = ifs_in_curr_cfg;
661   struct olsr_if *ifs = olsr_cnf->interfaces;
662
663   PARSER_DEBUG_PRINTF("\tHELLO validity: %0.2f\n", $2->floating);
664
665         SET_IFS_CONF(ifs, ifcnt, hello_params.validity_time, $2->floating);
666
667   free($2);
668 }
669 ;
670 isettcint: TOK_TCINT TOK_FLOAT
671 {
672   int ifcnt = ifs_in_curr_cfg;
673   struct olsr_if *ifs = olsr_cnf->interfaces;
674
675   PARSER_DEBUG_PRINTF("\tTC interval: %0.2f\n", $2->floating);
676
677         SET_IFS_CONF(ifs, ifcnt, tc_params.emission_interval, $2->floating);
678
679   free($2);
680 }
681 ;
682 isettcval: TOK_TCVAL TOK_FLOAT
683 {
684   int ifcnt = ifs_in_curr_cfg;
685   struct olsr_if *ifs = olsr_cnf->interfaces;
686   
687   PARSER_DEBUG_PRINTF("\tTC validity: %0.2f\n", $2->floating);
688   
689  SET_IFS_CONF(ifs, ifcnt, tc_params.validity_time, $2->floating);
690
691   free($2);
692 }
693 ;
694 isetmidint: TOK_MIDINT TOK_FLOAT
695 {
696   int ifcnt = ifs_in_curr_cfg;
697   struct olsr_if *ifs = olsr_cnf->interfaces;
698
699
700   PARSER_DEBUG_PRINTF("\tMID interval: %0.2f\n", $2->floating);
701   
702   SET_IFS_CONF(ifs, ifcnt, mid_params.emission_interval, $2->floating);
703
704   free($2);
705 }
706 ;
707 isetmidval: TOK_MIDVAL TOK_FLOAT
708 {
709   int ifcnt = ifs_in_curr_cfg;
710   struct olsr_if *ifs = olsr_cnf->interfaces;
711
712   PARSER_DEBUG_PRINTF("\tMID validity: %0.2f\n", $2->floating);
713   
714   SET_IFS_CONF(ifs, ifcnt, mid_params.validity_time, $2->floating);
715
716   free($2);
717 }
718 ;
719 isethnaint: TOK_HNAINT TOK_FLOAT
720 {
721   int ifcnt = ifs_in_curr_cfg;
722   struct olsr_if *ifs = olsr_cnf->interfaces;
723   
724   PARSER_DEBUG_PRINTF("\tHNA interval: %0.2f\n", $2->floating);
725
726   SET_IFS_CONF(ifs, ifcnt, hna_params.emission_interval, $2->floating);
727
728   free($2);
729 }
730 ;
731 isethnaval: TOK_HNAVAL TOK_FLOAT
732 {
733   int ifcnt = ifs_in_curr_cfg;
734   struct olsr_if *ifs = olsr_cnf->interfaces;
735
736   PARSER_DEBUG_PRINTF("\tHNA validity: %0.2f\n", $2->floating);
737
738   SET_IFS_CONF(ifs, ifcnt, hna_params.validity_time, $2->floating);
739
740   free($2);
741 }
742 ;
743 isetautodetchg: TOK_AUTODETCHG TOK_BOOLEAN
744 {
745   int ifcnt = ifs_in_curr_cfg;
746   struct olsr_if *ifs = olsr_cnf->interfaces;
747
748   PARSER_DEBUG_PRINTF("\tAutodetect changes: %s\n", $2->boolean ? "YES" : "NO");
749
750   SET_IFS_CONF(ifs, ifcnt, autodetect_chg, $2->boolean);
751
752   free($2);
753 }
754 ;
755
756 isetlqmult: TOK_LQ_MULT TOK_DEFAULT TOK_FLOAT
757 {
758   if (lq_mult_helper($2, $3) < 0) {
759     YYABORT;
760   }
761 }
762
763           | TOK_LQ_MULT TOK_IPV4_ADDR TOK_FLOAT
764 {
765   if (lq_mult_helper($2, $3) < 0) {
766     YYABORT;
767   }
768 }
769
770           | TOK_LQ_MULT TOK_IPV6_ADDR TOK_FLOAT
771 {
772   if (lq_mult_helper($2, $3) < 0) {
773     YYABORT;
774   }
775 }
776 ;
777
778 idebug:       TOK_DEBUGLEVEL TOK_INTEGER
779 {
780   olsr_cnf->debug_level = $2->integer;
781   PARSER_DEBUG_PRINTF("Debug level: %d\n", olsr_cnf->debug_level);
782   free($2);
783 }
784 ;
785
786
787 iipversion:    TOK_IPVERSION TOK_INTEGER
788 {
789   if ($2->integer == 4) {
790     olsr_cnf->ip_version = AF_INET;
791     olsr_cnf->ipsize = sizeof(struct in_addr);
792     olsr_cnf->maxplen = 32;
793   } else if ($2->integer == 6) {
794     olsr_cnf->ip_version = AF_INET6;
795     olsr_cnf->ipsize = sizeof(struct in6_addr);
796     olsr_cnf->maxplen = 128;
797   } else {
798     fprintf(stderr, "IPversion must be 4 or 6!\n");
799     YYABORT;
800   }
801
802   PARSER_DEBUG_PRINTF("IpVersion: %d\n", $2->integer);
803   free($2);
804 }
805 ;
806
807 fibmetric:    TOK_FIBMETRIC TOK_STRING
808 {
809   int i;
810   PARSER_DEBUG_PRINTF("FIBMetric: %s\n", $2->string);
811   for (i=0; i<FIBM_CNT; i++) {
812     if (strcmp($2->string, FIB_METRIC_TXT[i]) == 0) {
813       olsr_cnf->fib_metric = i;
814       break;
815     }
816   }
817   if (i == FIBM_CNT) {
818     fprintf(stderr, "Bad FIBMetric value: %s\n", $2->string);
819     YYABORT;
820   }
821   free($1);
822   free($2->string);
823   free($2);
824 }
825 ;
826
827 ihna4entry:     TOK_IPV4_ADDR TOK_IPV4_ADDR
828 {
829   union olsr_ip_addr ipaddr, netmask;
830
831   if (olsr_cnf->ip_version == AF_INET6) {
832     fprintf(stderr, "IPv4 addresses can only be used if \"IpVersion\" == 4, skipping HNA.\n");
833     olsr_startup_sleep(3);
834   }
835   else {
836     PARSER_DEBUG_PRINTF("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
837
838     if (inet_pton(AF_INET, $1->string, &ipaddr.v4) <= 0) {
839       fprintf(stderr, "ihna4entry: Failed converting IP address %s\n", $1->string);
840       YYABORT;
841     }
842     if (inet_pton(AF_INET, $2->string, &netmask.v4) <= 0) {
843       fprintf(stderr, "ihna4entry: Failed converting IP address %s\n", $1->string);
844       YYABORT;
845     }
846
847     /* check that the given IP address is actually a network address */
848     if ((ipaddr.v4.s_addr & ~netmask.v4.s_addr) != 0) {
849       fprintf(stderr, "ihna4entry: The ipaddress \"%s\" is not a network address!\n", $1->string);
850       YYABORT;
851     }
852
853     /* Queue */
854     ip_prefix_list_add(&olsr_cnf->hna_entries, &ipaddr, olsr_netmask_to_prefix(&netmask));
855   }
856   free($1->string);
857   free($1);
858   free($2->string);
859   free($2);
860 }
861         |       TOK_IPV4_ADDR TOK_SLASH TOK_INTEGER
862 {
863   union olsr_ip_addr ipaddr, netmask;
864
865   if (olsr_cnf->ip_version == AF_INET6) {
866     fprintf(stderr, "IPv4 addresses can only be used if \"IpVersion\" == 4, skipping HNA.\n");
867     olsr_startup_sleep(3);
868   }
869   else {
870     PARSER_DEBUG_PRINTF("HNA IPv4 entry: %s/%d\n", $1->string, $3->integer);
871
872     if (inet_pton(AF_INET, $1->string, &ipaddr.v4) <= 0) {
873       fprintf(stderr, "ihna4entry: Failed converting IP address %s\n", $1->string);
874       YYABORT;
875     }
876     if ($3->integer > olsr_cnf->maxplen) {
877       fprintf(stderr, "ihna4entry: Prefix len %u > %d is not allowed!\n", $3->integer, olsr_cnf->maxplen);
878       YYABORT;
879     }
880
881     /* check that the given IP address is actually a network address */
882     olsr_prefix_to_netmask(&netmask, $3->integer);
883     if ((ipaddr.v4.s_addr & ~netmask.v4.s_addr) != 0) {
884       fprintf(stderr, "ihna4entry: The ipaddress \"%s\" is not a network address!\n", $1->string);
885       YYABORT;
886     }
887
888     /* Queue */
889     ip_prefix_list_add(&olsr_cnf->hna_entries, &ipaddr, $3->integer);
890   }
891   free($1->string);
892   free($1);
893   free($3);
894 }
895 ;
896
897 ihna6entry:     TOK_IPV6_ADDR TOK_INTEGER
898 {
899   if (add_ipv6_addr($1, $2)) {
900     YYABORT;
901   }
902 }
903         |       TOK_IPV6_ADDR TOK_SLASH TOK_INTEGER
904 {
905   if (add_ipv6_addr($1, $3)) {
906     YYABORT;
907   }
908 }
909 ;
910
911 ifstart: TOK_INTERFACE
912 {
913   PARSER_DEBUG_PRINTF("setting ifs_in_curr_cfg = 0\n");
914   ifs_in_curr_cfg = 0;
915 }
916 ;
917
918 ifnick: TOK_STRING
919 {
920   struct olsr_if *in, *last;
921   in = olsr_cnf->interfaces;
922   last = NULL;
923   while (in != NULL) {
924     if (strcmp(in->name, $1->string) == 0) {
925       free ($1->string);
926       break;
927     }
928     last = in;
929     in = in->next;
930   }
931
932   if (in != NULL) {
933     /* remove old interface from list to add it later at the beginning */
934     if (last) {
935       last->next = in->next;
936     }
937     else {
938       olsr_cnf->interfaces = in->next;
939     }
940   }
941   else {
942     in = malloc(sizeof(*in));
943     if (in == NULL) {
944       fprintf(stderr, "Out of memory(ADD IF)\n");
945       YYABORT;
946     }
947     memset(in, 0, sizeof(*in));
948
949     in->cnf = malloc(sizeof(*in->cnf));
950     if (in->cnf == NULL) {
951       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
952       YYABORT;
953     }
954     memset(in->cnf, 0x00, sizeof(*in->cnf));
955
956     in->cnfi = malloc(sizeof(*in->cnfi));
957     if (in->cnf == NULL) {
958       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
959       YYABORT;
960     }
961     memset(in->cnfi, 0xFF, sizeof(*in->cnfi));
962     in->cnfi->orig_lq_mult_cnt=0;
963
964     in->name = $1->string;
965   }
966   /* Queue */
967   in->next = olsr_cnf->interfaces;
968   olsr_cnf->interfaces = in;
969   ifs_in_curr_cfg++;
970   free($1);
971 }
972 ;
973
974 bnoint: TOK_NOINT TOK_BOOLEAN
975 {
976   PARSER_DEBUG_PRINTF("Noint set to %d\n", $2->boolean);
977   olsr_cnf->allow_no_interfaces = $2->boolean;
978   free($2);
979 }
980 ;
981
982 atos: TOK_TOS TOK_INTEGER
983 {
984   PARSER_DEBUG_PRINTF("TOS: %d\n", $2->integer);
985   olsr_cnf->tos = $2->integer;
986   free($2);
987
988 }
989 ;
990
991 aolsrport: TOK_OLSRPORT TOK_INTEGER
992 {
993   PARSER_DEBUG_PRINTF("OlsrPort: %d\n", $2->integer);
994   olsr_cnf->olsrport = $2->integer;
995   free($2);
996 }
997 ;
998
999 irtproto: TOK_RTPROTO TOK_INTEGER
1000 {
1001   PARSER_DEBUG_PRINTF("RtProto: %d\n", $2->integer);
1002   olsr_cnf->rt_proto = $2->integer;
1003   free($2);
1004 }
1005 ;
1006
1007 irttable: TOK_RTTABLE TOK_INTEGER
1008 {
1009   PARSER_DEBUG_PRINTF("RtTable: %d\n", $2->integer);
1010   olsr_cnf->rt_table = $2->integer;
1011   free($2);
1012 }
1013        | TOK_RTTABLE TOK_AUTO
1014 {
1015   PARSER_DEBUG_PRINTF("RtTable: auto\n");
1016   olsr_cnf->rt_table = DEF_RT_AUTO;
1017   free($2);
1018 }
1019 ;
1020
1021 irttable_default: TOK_RTTABLE_DEFAULT TOK_INTEGER
1022 {
1023   PARSER_DEBUG_PRINTF("RtTableDefault: %d\n", $2->integer);
1024   olsr_cnf->rt_table_default = $2->integer;
1025   free($2);
1026 }
1027        | TOK_RTTABLE_DEFAULT TOK_AUTO
1028 {
1029   PARSER_DEBUG_PRINTF("RtTableDefault: auto\n");
1030   olsr_cnf->rt_table_default = DEF_RT_AUTO;
1031   free($2);
1032 }
1033 ;
1034
1035 irttable_tunnel: TOK_RTTABLE_TUNNEL TOK_INTEGER
1036 {
1037   PARSER_DEBUG_PRINTF("RtTableTunnel: %d\n", $2->integer);
1038   olsr_cnf->rt_table_tunnel = $2->integer;
1039   free($2);
1040 }
1041        | TOK_RTTABLE_TUNNEL TOK_AUTO
1042 {
1043   PARSER_DEBUG_PRINTF("RtTableTunnel: auto\n");
1044   olsr_cnf->rt_table_tunnel = DEF_RT_AUTO;
1045   free($2);
1046 }
1047 ;
1048
1049 irttable_priority: TOK_RTTABLE_PRIORITY TOK_INTEGER
1050 {
1051   PARSER_DEBUG_PRINTF("RtTablePriority: %d\n", $2->integer);
1052   olsr_cnf->rt_table_pri = $2->integer;
1053   free($2);
1054 }
1055         | TOK_RTTABLE_PRIORITY TOK_AUTO
1056 {
1057   PARSER_DEBUG_PRINTF("RtTablePriority: auto\n");
1058   olsr_cnf->rt_table_pri = DEF_RT_AUTO;
1059   free($2);
1060 }
1061         | TOK_RTTABLE_PRIORITY TOK_NONE
1062 {
1063   PARSER_DEBUG_PRINTF("RtTablePriority: none\n");
1064   olsr_cnf->rt_table_pri = DEF_RT_NONE;
1065   free($2);
1066 }
1067 ;
1068
1069 irttable_default_priority: TOK_RTTABLE_DEFAULT_PRIORITY TOK_INTEGER
1070 {
1071   PARSER_DEBUG_PRINTF("RtTableDefaultPriority: %d\n", $2->integer);
1072   olsr_cnf->rt_table_default_pri = $2->integer;
1073   free($2);
1074 }
1075         | TOK_RTTABLE_DEFAULT_PRIORITY TOK_AUTO
1076 {
1077   PARSER_DEBUG_PRINTF("RtTableDefaultPriority: auto\n");
1078   olsr_cnf->rt_table_default_pri = DEF_RT_AUTO;
1079   free($2);
1080 }
1081         | TOK_RTTABLE_DEFAULT_PRIORITY TOK_NONE
1082 {
1083   PARSER_DEBUG_PRINTF("RtTableDefaultPriority: none\n");
1084   olsr_cnf->rt_table_default_pri = DEF_RT_NONE;
1085   free($2);
1086 }
1087 ;
1088
1089 irttable_tunnel_priority: TOK_RTTABLE_TUNNEL_PRIORITY TOK_INTEGER
1090 {
1091   PARSER_DEBUG_PRINTF("RtTableTunnelPriority: %d\n", $2->integer);
1092   olsr_cnf->rt_table_tunnel_pri = $2->integer;
1093   free($2);
1094 }
1095         | TOK_RTTABLE_TUNNEL_PRIORITY TOK_AUTO
1096 {
1097   PARSER_DEBUG_PRINTF("RtTableTunnelPriority: auto\n");
1098   olsr_cnf->rt_table_tunnel_pri = DEF_RT_AUTO;
1099   free($2);
1100 }
1101         | TOK_RTTABLE_TUNNEL_PRIORITY TOK_NONE
1102 {
1103   PARSER_DEBUG_PRINTF("RtTableTunnelPriority: none\n");
1104   olsr_cnf->rt_table_tunnel_pri = DEF_RT_NONE;
1105   free($2);
1106 }
1107 ;
1108
1109 irttable_defaultolsr_priority: TOK_RTTABLE_DEFAULTOLSR_PRIORITY TOK_INTEGER
1110 {
1111   PARSER_DEBUG_PRINTF("RtTableDefaultOlsrPriority: %d\n", $2->integer);
1112   olsr_cnf->rt_table_defaultolsr_pri = $2->integer;
1113   free($2);
1114 }
1115         | TOK_RTTABLE_DEFAULTOLSR_PRIORITY TOK_AUTO
1116 {
1117   PARSER_DEBUG_PRINTF("RtTableDefaultOlsrPriority: auto\n");
1118   olsr_cnf->rt_table_defaultolsr_pri = DEF_RT_AUTO;
1119   free($2);
1120 }
1121         | TOK_RTTABLE_DEFAULTOLSR_PRIORITY TOK_NONE
1122 {
1123   PARSER_DEBUG_PRINTF("RtTableDefaultOlsrPriority: none\n");
1124   olsr_cnf->rt_table_defaultolsr_pri = DEF_RT_NONE;
1125   free($2);
1126 }
1127 ;
1128
1129 awillingness: TOK_WILLINGNESS TOK_INTEGER
1130 {
1131   PARSER_DEBUG_PRINTF("Willingness: %d\n", $2->integer);
1132   olsr_cnf->willingness_auto = false;
1133   olsr_cnf->willingness = $2->integer;
1134   free($2);
1135 }
1136 ;
1137
1138 busehyst: TOK_USEHYST TOK_BOOLEAN
1139 {
1140   olsr_cnf->use_hysteresis = $2->boolean;
1141   PARSER_DEBUG_PRINTF("Hysteresis %s\n", olsr_cnf->use_hysteresis ? "enabled" : "disabled");
1142   free($2);
1143 }
1144 ;
1145
1146 fhystscale: TOK_HYSTSCALE TOK_FLOAT
1147 {
1148   olsr_cnf->hysteresis_param.scaling = $2->floating;
1149   PARSER_DEBUG_PRINTF("Hysteresis Scaling: %0.2f\n", $2->floating);
1150   free($2);
1151 }
1152 ;
1153
1154 fhystupper: TOK_HYSTUPPER TOK_FLOAT
1155 {
1156   olsr_cnf->hysteresis_param.thr_high = $2->floating;
1157   PARSER_DEBUG_PRINTF("Hysteresis UpperThr: %0.2f\n", $2->floating);
1158   free($2);
1159 }
1160 ;
1161
1162 fhystlower: TOK_HYSTLOWER TOK_FLOAT
1163 {
1164   olsr_cnf->hysteresis_param.thr_low = $2->floating;
1165   PARSER_DEBUG_PRINTF("Hysteresis LowerThr: %0.2f\n", $2->floating);
1166   free($2);
1167 }
1168 ;
1169
1170 fpollrate: TOK_POLLRATE TOK_FLOAT
1171 {
1172   PARSER_DEBUG_PRINTF("Pollrate %0.2f\n", $2->floating);
1173   olsr_cnf->pollrate = $2->floating;
1174   free($2);
1175 }
1176 ;
1177
1178 fnicchgspollrt: TOK_NICCHGSPOLLRT TOK_FLOAT
1179 {
1180   PARSER_DEBUG_PRINTF("NIC Changes Pollrate %0.2f\n", $2->floating);
1181   olsr_cnf->nic_chgs_pollrate = $2->floating;
1182   free($2);
1183 }
1184 ;
1185
1186 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
1187 {
1188   PARSER_DEBUG_PRINTF("TC redundancy %d\n", $2->integer);
1189   olsr_cnf->tc_redundancy = $2->integer;
1190   free($2);
1191 }
1192 ;
1193
1194 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
1195 {
1196   PARSER_DEBUG_PRINTF("MPR coverage %d\n", $2->integer);
1197   olsr_cnf->mpr_coverage = $2->integer;
1198   free($2);
1199 }
1200 ;
1201
1202 alq_level: TOK_LQ_LEVEL TOK_INTEGER
1203 {
1204   PARSER_DEBUG_PRINTF("Link quality level %d\n", $2->integer);
1205   olsr_cnf->lq_level = $2->integer;
1206   free($2);
1207 }
1208 ;
1209
1210 alq_fish: TOK_LQ_FISH TOK_INTEGER
1211 {
1212   PARSER_DEBUG_PRINTF("Link quality fish eye %d\n", $2->integer);
1213   olsr_cnf->lq_fish = $2->integer;
1214   free($2);
1215 }
1216 ;
1217
1218 alq_aging: TOK_LQ_AGING TOK_FLOAT
1219 {
1220   PARSER_DEBUG_PRINTF("Link quality aging factor %f\n", $2->floating);
1221   olsr_cnf->lq_aging = $2->floating;
1222   free($2);
1223 }
1224 ;
1225
1226 amin_tc_vtime: TOK_MIN_TC_VTIME TOK_FLOAT
1227 {
1228   PARSER_DEBUG_PRINTF("Minimum TC validity time %f\n", $2->floating);
1229   olsr_cnf->min_tc_vtime = $2->floating;
1230   free($2);
1231 }
1232 ;
1233
1234 alock_file: TOK_LOCK_FILE TOK_STRING
1235 {
1236   PARSER_DEBUG_PRINTF("Lock file %s\n", $2->string);
1237   olsr_cnf->lock_file = $2->string;
1238   free($2);
1239 }
1240 ;
1241 alq_plugin: TOK_LQ_PLUGIN TOK_STRING
1242 {
1243   olsr_cnf->lq_algorithm = $2->string;
1244   PARSER_DEBUG_PRINTF("LQ Algorithm: %s\n", $2->string);
1245   free($2);
1246 }
1247 ;
1248
1249 anat_thresh: TOK_LQ_NAT_THRESH TOK_FLOAT
1250 {
1251   PARSER_DEBUG_PRINTF("NAT threshold %0.2f\n", $2->floating);
1252   olsr_cnf->lq_nat_thresh = $2->floating;
1253   free($2);
1254 }
1255 ;
1256
1257 bclear_screen: TOK_CLEAR_SCREEN TOK_BOOLEAN
1258 {
1259   PARSER_DEBUG_PRINTF("Clear screen %s\n", $2->boolean ? "enabled" : "disabled");
1260   olsr_cnf->clear_screen = $2->boolean;
1261   free($2);
1262 }
1263 ;
1264
1265 suse_niit: TOK_USE_NIIT TOK_BOOLEAN
1266 {
1267   PARSER_DEBUG_PRINTF("Use NIIT ip translation: %s\n", $2->boolean ? "enabled" : "disabled");
1268   olsr_cnf->use_niit = $2->boolean;
1269   free($2);
1270 }
1271 ;
1272
1273 bsmart_gw: TOK_SMART_GW TOK_BOOLEAN
1274 {
1275         PARSER_DEBUG_PRINTF("Smart gateway system: %s\n", $2->boolean ? "enabled" : "disabled");
1276         olsr_cnf->smart_gw_active = $2->boolean;
1277         free($2);
1278 }
1279 ;
1280
1281 bsmart_gw_allow_nat: TOK_SMART_GW_ALLOW_NAT TOK_BOOLEAN
1282 {
1283         PARSER_DEBUG_PRINTF("Smart gateway allow client nat: %s\n", $2->boolean ? "yes" : "no");
1284         olsr_cnf->smart_gw_allow_nat = $2->boolean;
1285         free($2);
1286 }
1287 ;
1288
1289 ssmart_gw_uplink: TOK_SMART_GW_UPLINK TOK_STRING
1290 {
1291         PARSER_DEBUG_PRINTF("Smart gateway uplink: %s\n", $2->string);
1292         if (strcasecmp($2->string, GW_UPLINK_TXT[GW_UPLINK_NONE]) == 0) {
1293                 olsr_cnf->smart_gw_type = GW_UPLINK_NONE;
1294         }
1295         if (strcasecmp($2->string, GW_UPLINK_TXT[GW_UPLINK_IPV4]) == 0) {
1296                 olsr_cnf->smart_gw_type = GW_UPLINK_IPV4;
1297         }
1298         else if (strcasecmp($2->string, GW_UPLINK_TXT[GW_UPLINK_IPV6]) == 0) {
1299                 olsr_cnf->smart_gw_type = GW_UPLINK_IPV6;
1300         }
1301         else if (strcasecmp($2->string, GW_UPLINK_TXT[GW_UPLINK_IPV46]) == 0) {
1302                 olsr_cnf->smart_gw_type = GW_UPLINK_IPV46;
1303         }
1304         else {
1305                 fprintf(stderr, "Bad gateway uplink type: %s\n", $2->string);
1306                 YYABORT;
1307         }
1308         free($2);
1309 }
1310 ;
1311
1312 ismart_gw_speed: TOK_SMART_GW_SPEED TOK_INTEGER TOK_INTEGER
1313 {
1314         PARSER_DEBUG_PRINTF("Smart gateway speed: %u uplink/%u downlink kbit/s\n", $2->integer, $3->integer);
1315         olsr_cnf->smart_gw_uplink = $2->integer;
1316         olsr_cnf->smart_gw_downlink = $3->integer;
1317         free($2);
1318         free($3);
1319 }
1320 ;
1321
1322 bsmart_gw_uplink_nat: TOK_SMART_GW_UPLINK_NAT TOK_BOOLEAN
1323 {
1324         PARSER_DEBUG_PRINTF("Smart gateway uplink nat: %s\n", $2->boolean ? "yes" : "no");
1325         olsr_cnf->smart_gw_uplink_nat = $2->boolean;
1326         free($2);
1327 }
1328 ;
1329
1330 ismart_gw_prefix: TOK_SMART_GW_PREFIX TOK_IPV6_ADDR TOK_INTEGER
1331 {
1332   PARSER_DEBUG_PRINTF("Smart gateway prefix: %s %u\n", $2->string, $3->integer);
1333         if (inet_pton(olsr_cnf->ip_version, $2->string, &olsr_cnf->smart_gw_prefix.prefix) == 0) {
1334           fprintf(stderr, "Bad IP part of gateway prefix: %s\n", $2->string);
1335     YYABORT;
1336   }
1337         olsr_cnf->smart_gw_prefix.prefix_len = (uint8_t)$3->integer;
1338         
1339         free($2);
1340         free($3);
1341 }
1342         |       TOK_SMART_GW_PREFIX TOK_IPV6_ADDR TOK_SLASH TOK_INTEGER
1343 {
1344         PARSER_DEBUG_PRINTF("Smart gateway prefix: %s %u\n", $2->string, $4->integer);
1345         if (inet_pton(olsr_cnf->ip_version, $2->string, &olsr_cnf->smart_gw_prefix.prefix) == 0) {
1346           fprintf(stderr, "Bad IP part of gateway prefix: %s\n", $2->string);
1347     YYABORT;
1348   }
1349         olsr_cnf->smart_gw_prefix.prefix_len = (uint8_t)$4->integer;
1350         
1351         free($2);
1352         free($4);
1353 }
1354 ;
1355
1356 bsrc_ip_routes: TOK_SRC_IP_ROUTES TOK_BOOLEAN
1357 {
1358         PARSER_DEBUG_PRINTF("Use originator for routes src-ip: %s\n", $2->boolean ? "yes" : "no");
1359         if (olsr_cnf->ip_version != AF_INET) {
1360           fprintf(stderr, "Source ip routes not possible with IPV6\n");
1361           YYABORT;
1362         }
1363         else olsr_cnf->use_src_ip_routes = $2->boolean;
1364         free($2);
1365 }
1366 ;
1367
1368 amain_ip: TOK_MAIN_IP TOK_IPV4_ADDR
1369 {
1370   PARSER_DEBUG_PRINTF("Fixed Main IP: %s\n", $2->string);
1371   
1372   if (olsr_cnf->ip_version != AF_INET
1373       || inet_pton(olsr_cnf->ip_version, $2->string, &olsr_cnf->main_addr) != 1) {
1374     fprintf(stderr, "Bad main IP: %s\n", $2->string);
1375     YYABORT;
1376   }
1377   else olsr_cnf->unicast_src_ip = olsr_cnf->main_addr;
1378   free($2);
1379 }
1380         |       TOK_MAIN_IP TOK_IPV6_ADDR
1381 {
1382   PARSER_DEBUG_PRINTF("Fixed Main IP: %s\n", $2->string);
1383   
1384   if (olsr_cnf->ip_version != AF_INET6
1385       || inet_pton(olsr_cnf->ip_version, $2->string, &olsr_cnf->main_addr) != 1) {
1386     fprintf(stderr, "Bad main IP: %s\n", $2->string);
1387     YYABORT;
1388   }
1389   free($2);
1390 }
1391
1392 plblock: TOK_PLUGIN TOK_STRING
1393 {
1394   struct plugin_entry *pe, *last;
1395   
1396   pe = olsr_cnf->plugins;
1397   last = NULL;
1398   while (pe != NULL) {
1399     if (strcmp(pe->name, $2->string) == 0) {
1400       free ($2->string);
1401       break;
1402     }
1403     last = pe;
1404     pe = pe->next;
1405   }
1406
1407   if (pe != NULL) {
1408     /* remove old plugin from list to add it later at the beginning */
1409     if (last) {
1410       last->next = pe->next;
1411     }
1412     else {
1413       olsr_cnf->plugins = pe->next;
1414     }
1415   }
1416   else {
1417     pe = malloc(sizeof(*pe));
1418
1419     if (pe == NULL) {
1420       fprintf(stderr, "Out of memory(ADD PL)\n");
1421       YYABORT;
1422     }
1423
1424     pe->name = $2->string;
1425     pe->params = NULL;
1426
1427     PARSER_DEBUG_PRINTF("Plugin: %s\n", $2->string);
1428   }
1429   
1430   /* Queue */
1431   pe->next = olsr_cnf->plugins;
1432   olsr_cnf->plugins = pe;
1433
1434   free($2);
1435 }
1436 ;
1437
1438 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
1439 {
1440   struct plugin_param *pp = malloc(sizeof(*pp));
1441   
1442   if (pp == NULL) {
1443     fprintf(stderr, "Out of memory(ADD PP)\n");
1444     YYABORT;
1445   }
1446   
1447   PARSER_DEBUG_PRINTF("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
1448   
1449   pp->key = $2->string;
1450   pp->value = $3->string;
1451
1452   /* Queue */
1453   pp->next = olsr_cnf->plugins->params;
1454   olsr_cnf->plugins->params = pp;
1455
1456   free($2);
1457   free($3);
1458 }
1459 ;
1460
1461 vcomment:       TOK_COMMENT
1462 {
1463     //PARSER_DEBUG_PRINTF("Comment\n");
1464 }
1465 ;
1466
1467
1468
1469 %%
1470
1471 void yyerror (const char *string)
1472 {
1473   fprintf(stderr, "Config line %d: %s\n", current_line, string);
1474 }