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