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