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