Better boolean handling and more
[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.10 2004/11/03 09:22:18 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   cnf->debug_level = $2->integer;
305   if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
306
307   free($2);
308 }
309 ;
310
311
312 iipversion:    TOK_IPVERSION TOK_INTEGER
313 {
314   if($2->integer == 4)
315     cnf->ip_version = AF_INET;
316   else if($2->integer == 6)
317     cnf->ip_version = AF_INET6;
318   else
319     {
320       fprintf(stderr, "IPversion must be 4 or 6!\n");
321       YYABORT;
322     }
323
324   if(PARSER_DEBUG) printf("IpVersion: %d\n", $2->integer);
325   free($2);
326 }
327 ;
328
329
330 ihna4entry:     TOK_IP4_ADDR TOK_IP4_ADDR
331 {
332   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
333   struct in_addr in;
334
335   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
336
337   if(h == NULL)
338     {
339       fprintf(stderr, "Out of memory(HNA4)\n");
340       YYABORT;
341     }
342
343   if(inet_aton($1->string, &in) == 0)
344     {
345       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
346       exit(EXIT_FAILURE);
347     }
348   h->net.v4 = in.s_addr;
349   if(inet_aton($2->string, &in) == 0)
350     {
351       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
352       exit(EXIT_FAILURE);
353     }
354   h->netmask.v4 = in.s_addr;
355   /* Queue */
356   h->next = cnf->hna4_entries;
357   cnf->hna4_entries = h;
358
359   free($1->string);
360   free($1);
361   free($2->string);
362   free($2);
363
364 }
365
366 ihna6entry:     TOK_IP6_ADDR TOK_INTEGER
367 {
368   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
369   struct in6_addr in6;
370
371   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", $1->string, $2->integer);
372
373   if(h == NULL)
374     {
375       fprintf(stderr, "Out of memory(HNA6)\n");
376       YYABORT;
377     }
378
379   if(inet_pton(AF_INET6, $1->string, &in6) < 0)
380     {
381       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
382       exit(EXIT_FAILURE);
383     }
384   memcpy(&h->net, &in6, sizeof(struct in6_addr));
385
386   if(($2->integer < 0) || ($2->integer > 128))
387     {
388       fprintf(stderr, "Illegal IPv6 prefix length %d\n", $2->integer);
389       exit(EXIT_FAILURE);
390     }
391
392   h->prefix_len = $2->integer;
393   /* Queue */
394   h->next = cnf->hna6_entries;
395   cnf->hna6_entries = h;
396
397   free($1->string);
398   free($1);
399   free($2);
400
401 }
402
403 ifblock: TOK_INTERFACE TOK_STRING
404 {
405   struct olsr_if *in = malloc(sizeof(struct olsr_if));
406   
407   if(in == NULL)
408     {
409       fprintf(stderr, "Out of memory(ADD IF)\n");
410       YYABORT;
411     }
412
413   in->cnf = get_default_if_config();
414
415   if(in->cnf == NULL)
416     {
417       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
418       YYABORT;
419     }
420
421   in->name = $2->string;
422
423   /* Queue */
424   in->next = cnf->interfaces;
425   cnf->interfaces = in;
426
427   free($2);
428 }
429
430 bnoint: TOK_NOINT TOK_BOOLEAN
431 {
432   if(PARSER_DEBUG) printf("Noint set to %d\n", $2->boolean);
433
434   cnf->allow_no_interfaces = $2->boolean;
435
436   free($2);
437 }
438 ;
439
440 atos: TOK_TOS TOK_INTEGER
441 {
442   if(PARSER_DEBUG) printf("TOS: %d\n", $2->integer);
443   cnf->tos = $2->integer;
444
445   free($2);
446
447 }
448 ;
449
450 awillingness: TOK_WILLINGNESS TOK_INTEGER
451 {
452   cnf->willingness_auto = FALSE;
453
454   if(PARSER_DEBUG) printf("Willingness: %d\n", $2->integer);
455   cnf->willingness = $2->integer;
456
457   free($2);
458
459 }
460 ;
461
462 bipccon: TOK_IPCCON TOK_BOOLEAN
463 {
464   cnf->open_ipc = $2->boolean;
465
466   if(cnf->open_ipc)
467     {
468       if(PARSER_DEBUG) printf("IPC allowed\n");
469     }
470   else
471     {
472       if(PARSER_DEBUG) printf("IPC blocked\n");
473     }
474   free($2);
475
476 }
477 ;
478
479
480 busehyst: TOK_USEHYST TOK_BOOLEAN
481 {
482   cnf->use_hysteresis = $2->boolean;
483   if(cnf->use_hysteresis)
484     {
485       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
486     }
487   else
488     {
489       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
490     }
491   free($2);
492
493 }
494 ;
495
496
497 fhystscale: TOK_HYSTSCALE TOK_FLOAT
498 {
499   cnf->hysteresis_param.scaling = $2->floating;
500   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", $2->floating);
501   free($2);
502 }
503 ;
504
505
506 fhystupper: TOK_HYSTUPPER TOK_FLOAT
507 {
508   cnf->hysteresis_param.thr_high = $2->floating;
509   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", $2->floating);
510   free($2);
511 }
512 ;
513
514
515 fhystlower: TOK_HYSTLOWER TOK_FLOAT
516 {
517   cnf->hysteresis_param.thr_low = $2->floating;
518   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", $2->floating);
519   free($2);
520 }
521 ;
522
523 fpollrate: TOK_POLLRATE TOK_FLOAT
524 {
525   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", $2->floating);
526   cnf->pollrate = $2->floating;
527
528   free($2);
529 }
530 ;
531
532
533 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
534 {
535   if(PARSER_DEBUG) printf("TC redundancy %d\n", $2->integer);
536   cnf->tc_redundancy = $2->integer;
537
538   free($2);
539
540 }
541 ;
542
543 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
544 {
545   if(PARSER_DEBUG) printf("MPR coverage %d\n", $2->integer);
546   cnf->mpr_coverage = $2->integer;
547
548   free($2);
549 }
550 ;
551
552
553 plblock: TOK_PLUGIN TOK_STRING
554 {
555   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
556   
557   if(pe == NULL)
558     {
559       fprintf(stderr, "Out of memory(ADD PL)\n");
560       YYABORT;
561     }
562
563   pe->name = $2->string;
564
565   pe->params = NULL;
566   
567   if(PARSER_DEBUG) printf("Plugin: %s\n", $2->string);
568
569   /* Queue */
570   pe->next = cnf->plugins;
571   cnf->plugins = pe;
572
573   free($2);
574 }
575 ;
576
577 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
578 {
579   struct plugin_param *pp = malloc(sizeof(struct plugin_param));
580   
581   if(pp == NULL)
582     {
583       fprintf(stderr, "Out of memory(ADD PP)\n");
584       YYABORT;
585     }
586   
587   if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
588   
589   pp->key = $2->string;
590   pp->value = $3->string;
591
592   /* Queue */
593   pp->next = cnf->plugins->params;
594   cnf->plugins->params = pp;
595
596   free($2);
597   free($3);
598 }
599 ;
600
601 vcomment:       TOK_COMMENT
602 {
603     //if(PARSER_DEBUG) printf("Comment\n");
604 }
605 ;
606
607
608
609 %%
610
611 void yyerror (char *string)
612 {
613   fprintf(stderr, "Config line %d: %s\n", current_line, string);
614 }