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