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