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