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