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