1b592901bf533ba450185f11352ab7f666fa2e25
[olsrd.git] / src / cfgparser / oparse.y
1 %{
2
3 /*
4  * OLSR ad-hoc routing table management protocol config parser
5  * Copyright (C) 2004 Andreas T√łnnesen (andreto@olsr.org)
6  *
7  * This file is part of the olsr.org OLSR daemon.
8  *
9  * olsr.org is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * olsr.org is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with olsr.org; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  * 
23  * 
24  * $Id: oparse.y,v 1.5 2004/10/17 13:24:28 kattemat Exp $
25  *
26  */
27
28
29 #include <stddef.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <sys/socket.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
35 #include <string.h>
36
37 #include "olsrd_conf.h"
38
39 #define PARSER_DEBUG 0
40
41 #define YYSTYPE struct conf_token *
42
43 void yyerror(char *);
44 int yylex(void);
45
46 struct if_config_options *
47 get_default_if_config(void);
48
49
50 struct if_config_options *
51 get_default_if_config()
52 {
53   struct if_config_options *io = malloc(sizeof(struct if_config_options));
54   struct in6_addr in6;
55  
56   memset(io, 0, sizeof(struct if_config_options));
57
58   io->ipv6_addrtype = 1;
59
60   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6) < 0)
61     {
62       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_SITE_LOCAL);
63       exit(EXIT_FAILURE);
64     }
65   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
66
67   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6) < 0)
68     {
69       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_GLOBAL);
70       exit(EXIT_FAILURE);
71     }
72   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
73
74
75   io->hello_params.emission_interval = HELLO_INTERVAL;
76   io->hello_params.validity_time = NEIGHB_HOLD_TIME;
77   io->tc_params.emission_interval = TC_INTERVAL;
78   io->tc_params.validity_time = TOP_HOLD_TIME;
79   io->mid_params.emission_interval = MID_INTERVAL;
80   io->mid_params.validity_time = MID_HOLD_TIME;
81   io->hna_params.emission_interval = HNA_INTERVAL;
82   io->hna_params.validity_time = HNA_HOLD_TIME;
83
84   return io;
85
86 }
87
88
89
90
91 %}
92
93 %token TOK_OPEN
94 %token TOK_CLOSE
95 %token TOK_SEMI
96
97 %token TOK_STRING
98 %token TOK_INTEGER
99 %token TOK_FLOAT
100 %token TOK_BOOLEAN
101
102 %token TOK_IP6TYPE
103
104 %token TOK_DEBUGLEVEL
105 %token TOK_IPVERSION
106 %token TOK_HNA4
107 %token TOK_HNA6
108 %token TOK_PLUGIN
109 %token TOK_INTERFACE
110 %token TOK_IFSETTING
111 %token TOK_IFSETUP
112 %token TOK_NOINT
113 %token TOK_TOS
114 %token TOK_WILLINGNESS
115 %token TOK_IPCCON
116 %token TOK_USEHYST
117 %token TOK_HYSTSCALE
118 %token TOK_HYSTUPPER
119 %token TOK_HYSTLOWER
120 %token TOK_POLLRATE
121 %token TOK_TCREDUNDANCY
122 %token TOK_MPRCOVERAGE
123 %token TOK_PLNAME
124 %token TOK_PLPARAM
125
126 %token TOK_IP4BROADCAST
127 %token TOK_IP6ADDRTYPE
128 %token TOK_IP6MULTISITE
129 %token TOK_IP6MULTIGLOBAL
130 %token TOK_HELLOINT
131 %token TOK_HELLOVAL
132 %token TOK_TCINT
133 %token TOK_TCVAL
134 %token TOK_MIDINT
135 %token TOK_MIDVAL
136 %token TOK_HNAINT
137 %token TOK_HNAVAL
138
139 %token TOK_IP4_ADDR
140 %token TOK_IP6_ADDR
141
142 %token TOK_COMMENT
143
144 %%
145
146 conf:
147           | conf block
148           | conf stmt
149 ;
150
151 stmt:       idebug
152           | iipversion
153           | bnoint
154           | atos
155           | awillingness
156           | bipccon
157           | busehyst
158           | fhystscale
159           | fhystupper
160           | fhystlower
161           | fpollrate
162           | atcredundancy
163           | amprcoverage
164           | vcomment
165 ;
166
167 block:      TOK_HNA4 hna4body
168           | TOK_HNA6 hna6body
169           | ifblock ifbody
170           | plblock plbody
171           | isetblock isetbody
172 ;
173
174 hna4body:       TOK_OPEN hna4stmts TOK_CLOSE
175 ;
176
177 hna4stmts: | hna4stmts ihna4entry
178 ;
179
180 hna6body:       TOK_OPEN hna6stmts TOK_CLOSE
181 ;
182
183 hna6stmts: | hna6stmts ihna6entry
184 ;
185
186 ifbody:     TOK_OPEN ifstmts TOK_CLOSE
187 ;
188
189 ifstmts:   | ifstmts ifstmt
190 ;
191
192 ifstmt:     ifsetting
193           | vcomment
194 ;
195
196 isetbody:   TOK_OPEN isetstmts TOK_CLOSE
197 ;
198
199 isetstmts:   | isetstmts isetstmt
200 ;
201
202 isetstmt:      vcomment
203              | isetip4br
204              | isetip6addrt
205              | isetip6mults
206              | isetip6multg
207              | isethelloint
208              | isethelloval
209              | isettcint
210              | isettcval
211              | isetmidint
212              | isetmidval
213              | isethnaint
214              | isethnaval
215 ;
216
217 plbody:     TOK_OPEN plstmts TOK_CLOSE
218 ;
219
220 plstmts:   | plstmts plstmt
221 ;
222
223 plstmt:     plparam
224           | vcomment
225 ;
226
227
228
229
230 isetblock:    TOK_IFSETUP TOK_STRING
231 {
232   struct if_config_options *io = get_default_if_config();
233   if(io == NULL)
234     {
235       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
236       YYABORT;
237     }
238
239   if(PARSER_DEBUG) printf("Interface setup: \"%s\"\n", $2->string);
240   
241   io->name = $2->string;
242   
243   
244   /* Queue */
245   io->next = cnf->if_options;
246   cnf->if_options = io;
247
248   free($2);
249 }
250 ;
251
252
253 isetip4br: TOK_IP4BROADCAST TOK_IP4_ADDR
254 {
255   struct in_addr in;
256
257   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", $2->string);
258
259   if(inet_aton($2->string, &in) == 0)
260     {
261       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
262       exit(EXIT_FAILURE);
263     }
264
265   cnf->if_options->ipv4_broadcast.v4 = in.s_addr;
266
267   free($2->string);
268   free($2);
269 }
270 ;
271
272 isetip6addrt: TOK_IP6ADDRTYPE TOK_IP6TYPE
273 {
274   cnf->if_options->ipv6_addrtype = $2->boolean;
275   
276   free($2);
277 }
278 ;
279
280 isetip6mults: TOK_IP6MULTISITE TOK_IP6_ADDR
281 {
282   struct in6_addr in6;
283
284   if(PARSER_DEBUG) printf("\tIPv6 site-local multicast: %s\n", $2->string);
285
286   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
287     {
288       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
289       exit(EXIT_FAILURE);
290     }
291   memcpy(&cnf->if_options->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
292
293
294   free($2->string);
295   free($2);
296 }
297 ;
298
299
300 isetip6multg: TOK_IP6MULTIGLOBAL TOK_IP6_ADDR
301 {
302   struct in6_addr in6;
303
304   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", $2->string);
305
306   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
307     {
308       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
309       exit(EXIT_FAILURE);
310     }
311   memcpy(&cnf->if_options->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
312
313
314   free($2->string);
315   free($2);
316 }
317 ;
318 isethelloint: TOK_HELLOINT TOK_FLOAT
319 {
320     if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", $2->floating);
321     cnf->if_options->hello_params.emission_interval = $2->floating;
322     free($2);
323 }
324 ;
325 isethelloval: TOK_HELLOVAL TOK_FLOAT
326 {
327     if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", $2->floating);
328     cnf->if_options->hello_params.validity_time = $2->floating;
329     free($2);
330 }
331 ;
332 isettcint: TOK_TCINT TOK_FLOAT
333 {
334     if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", $2->floating);
335     cnf->if_options->tc_params.emission_interval = $2->floating;
336     free($2);
337 }
338 ;
339 isettcval: TOK_TCVAL TOK_FLOAT
340 {
341     if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", $2->floating);
342     cnf->if_options->tc_params.validity_time = $2->floating;
343     free($2);
344 }
345 ;
346 isetmidint: TOK_MIDINT TOK_FLOAT
347 {
348     if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", $2->floating);
349     cnf->if_options->mid_params.emission_interval = $2->floating;
350     free($2);
351 }
352 ;
353 isetmidval: TOK_MIDVAL TOK_FLOAT
354 {
355     if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", $2->floating);
356     cnf->if_options->mid_params.validity_time = $2->floating;
357     free($2);
358 }
359 ;
360 isethnaint: TOK_HNAINT TOK_FLOAT
361 {
362     if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", $2->floating);
363     cnf->if_options->hna_params.emission_interval = $2->floating;
364     free($2);
365 }
366 ;
367 isethnaval: TOK_HNAVAL TOK_FLOAT
368 {
369     if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", $2->floating);
370     cnf->if_options->hna_params.validity_time = $2->floating;
371     free($2);
372 }
373 ;
374
375
376 idebug:       TOK_DEBUGLEVEL TOK_INTEGER
377 {
378
379   if($2->boolean == 1)
380     {
381       if(PARSER_DEBUG) printf("Debug levl AUTO\n");
382     }
383   else
384     {
385       cnf->debug_level = $2->integer;
386       if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
387     }
388
389   free($2);
390 }
391 ;
392
393
394 iipversion:    TOK_IPVERSION TOK_INTEGER
395 {
396   if(($2->integer != 4) && ($2->integer != 6))
397     {
398       fprintf(stderr, "IPversion must be 4 or 6!\n");
399       YYABORT;
400     }
401   cnf->ip_version = $2->integer;
402   if(PARSER_DEBUG) printf("IpVersion: %d\n", cnf->ip_version);
403   free($2);
404 }
405 ;
406
407
408 ihna4entry:     TOK_IP4_ADDR TOK_IP4_ADDR
409 {
410   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
411   struct in_addr in;
412
413   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
414
415   if(h == NULL)
416     {
417       fprintf(stderr, "Out of memory(HNA4)\n");
418       YYABORT;
419     }
420
421   if(inet_aton($1->string, &in) == 0)
422     {
423       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
424       exit(EXIT_FAILURE);
425     }
426   h->net = in.s_addr;
427   if(inet_aton($2->string, &in) == 0)
428     {
429       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
430       exit(EXIT_FAILURE);
431     }
432   h->netmask = in.s_addr;
433   /* Queue */
434   h->next = cnf->hna4_entries;
435   cnf->hna4_entries = h;
436
437   free($1->string);
438   free($1);
439   free($2->string);
440   free($2);
441
442 }
443
444 ihna6entry:     TOK_IP6_ADDR TOK_INTEGER
445 {
446   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
447   struct in6_addr in6;
448
449   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", $1->string, $2->integer);
450
451   if(h == NULL)
452     {
453       fprintf(stderr, "Out of memory(HNA6)\n");
454       YYABORT;
455     }
456
457   if(inet_pton(AF_INET6, $1->string, &in6) < 0)
458     {
459       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
460       exit(EXIT_FAILURE);
461     }
462   memcpy(&h->net, &in6, sizeof(struct in6_addr));
463
464   if(($2->integer < 0) || ($2->integer > 128))
465     {
466       fprintf(stderr, "Illegal IPv6 prefix length %d\n", $2->integer);
467       exit(EXIT_FAILURE);
468     }
469
470   h->prefix_len = $2->integer;
471   /* Queue */
472   h->next = cnf->hna6_entries;
473   cnf->hna6_entries = h;
474
475   free($1->string);
476   free($1);
477   free($2);
478
479 }
480
481 ifblock: TOK_INTERFACE TOK_STRING
482 {
483   struct olsr_if *in = malloc(sizeof(struct olsr_if));
484   
485   if(in == NULL)
486     {
487       fprintf(stderr, "Out of memory(ADD IF)\n");
488       YYABORT;
489     }
490
491   in->name = $2->string;
492
493   /* Queue */
494   in->next = cnf->interfaces;
495   cnf->interfaces = in;
496
497   free($2);
498 }
499
500
501 ifsetting: TOK_IFSETTING TOK_STRING
502 {
503
504   cnf->interfaces->config = $2->string;
505
506   if(PARSER_DEBUG) printf("Interface: %s Ruleset: %s\n", $1->string, $2->string);
507
508   free($2);
509 }
510 ;
511
512 bnoint: TOK_NOINT TOK_BOOLEAN
513 {
514   if(PARSER_DEBUG) printf("Noint set to %d\n", $2->boolean);
515   free($2);
516 }
517 ;
518
519 atos: TOK_TOS TOK_INTEGER
520 {
521   if($2->boolean == 1)
522     {
523       if(PARSER_DEBUG) printf("Tos AUTO\n");
524     }
525   else
526     {
527       if(PARSER_DEBUG) printf("TOS: %d\n", $2->integer);
528     }
529   free($2);
530
531 }
532 ;
533
534 awillingness: TOK_WILLINGNESS TOK_INTEGER
535 {
536   if($2->boolean == 1)
537     {
538       if(PARSER_DEBUG) printf("Willingness AUTO\n");
539     }
540   else
541     {
542       if(PARSER_DEBUG) printf("Willingness: %d\n", $2->integer);
543     }
544   free($2);
545
546 }
547 ;
548
549 bipccon: TOK_IPCCON TOK_BOOLEAN
550 {
551   if($2->boolean == 1)
552     {
553       if(PARSER_DEBUG) printf("IPC allowed\n");
554     }
555   else
556     {
557       if(PARSER_DEBUG) printf("IPC blocked\n");
558     }
559   free($2);
560
561 }
562 ;
563
564
565 busehyst: TOK_USEHYST TOK_BOOLEAN
566 {
567   if($2->boolean == 1)
568     {
569       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
570     }
571   else
572     {
573       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
574     }
575   free($2);
576
577 }
578 ;
579
580
581 fhystscale: TOK_HYSTSCALE TOK_FLOAT
582 {
583   cnf->hysteresis_param.scaling = $2->floating;
584   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", $2->floating);
585   free($2);
586 }
587 ;
588
589
590 fhystupper: TOK_HYSTUPPER TOK_FLOAT
591 {
592   cnf->hysteresis_param.thr_high = $2->floating;
593   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", $2->floating);
594   free($2);
595 }
596 ;
597
598
599 fhystlower: TOK_HYSTLOWER TOK_FLOAT
600 {
601   cnf->hysteresis_param.thr_low = $2->floating;
602   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", $2->floating);
603   free($2);
604 }
605 ;
606
607 fpollrate: TOK_POLLRATE TOK_FLOAT
608 {
609   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", $2->floating);
610   cnf->pollrate = $2->floating;
611
612   free($2);
613 }
614 ;
615
616
617 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
618 {
619   if($2->boolean == 1)
620     {
621       if(PARSER_DEBUG) printf("TC redundancy AUTO\n");
622     }
623   else
624     {
625       if(PARSER_DEBUG) printf("TC redundancy %d\n", $2->integer);
626       cnf->tc_redundancy = $2->integer;
627     }
628   free($2);
629
630 }
631 ;
632
633 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
634 {
635   if($2->boolean == 1)
636     {
637       if(PARSER_DEBUG) printf("MPR coverage AUTO\n");
638     }
639   else
640     {
641       if(PARSER_DEBUG) printf("MPR coverage %d\n", $2->integer);
642       cnf->mpr_coverage = $2->integer;
643     }
644   free($2);
645 }
646 ;
647
648
649 plblock: TOK_PLUGIN TOK_STRING
650 {
651   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
652   
653   if(pe == NULL)
654     {
655       fprintf(stderr, "Out of memory(ADD PL)\n");
656       YYABORT;
657     }
658
659   pe->name = $2->string;
660   
661   if(PARSER_DEBUG) printf("Plugin: %s\n", $2->string);
662
663   /* Queue */
664   pe->next = cnf->plugins;
665   cnf->plugins = pe;
666
667   free($2);
668 }
669 ;
670
671 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
672 {
673
674     if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
675
676     free($2->string);
677     free($2);
678     free($3->string);
679     free($3);
680 }
681 ;
682
683 vcomment:       TOK_COMMENT
684 {
685     //if(PARSER_DEBUG) printf("Comment\n");
686 }
687 ;
688
689
690
691 %%
692
693 void yyerror (char *string)
694 {
695   fprintf(stderr, "Config line %d: %s\n", current_line, string);
696 }