c16bc708b663ea57443ca7de70d9a3021f0ebbd7
[olsrd.git] / src / cfgparser / oparse.y
1 %{
2
3 /*
4  * The olsr.org Optimized Link-State Routing daemon(olsrd)
5  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without 
9  * modification, are permitted provided that the following conditions 
10  * are met:
11  *
12  * * Redistributions of source code must retain the above copyright 
13  *   notice, this list of conditions and the following disclaimer.
14  * * Redistributions in binary form must reproduce the above copyright 
15  *   notice, this list of conditions and the following disclaimer in 
16  *   the documentation and/or other materials provided with the 
17  *   distribution.
18  * * Neither the name of olsr.org, olsrd nor the names of its 
19  *   contributors may be used to endorse or promote products derived 
20  *   from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
26  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
30  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
32  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
33  * POSSIBILITY OF SUCH DAMAGE.
34  *
35  * Visit http://www.olsr.org for more information.
36  *
37  * If you find this software useful feel free to make a donation
38  * to the project. For more information see the website or contact
39  * the copyright holders.
40  *
41  * $Id: oparse.y,v 1.21 2004/11/21 17:10:28 tlopatic Exp $
42  */
43
44
45 #include <stddef.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <sys/types.h>
49 #include <sys/socket.h>
50 #include <netinet/in.h>
51 #include <arpa/inet.h>
52 #include <string.h>
53
54 #include "olsrd_conf.h"
55
56 #define PARSER_DEBUG 0
57
58 #define YYSTYPE struct conf_token *
59
60 void yyerror(char *);
61 int yylex(void);
62
63
64
65
66
67 %}
68
69 %token TOK_OPEN
70 %token TOK_CLOSE
71 %token TOK_SEMI
72
73 %token TOK_STRING
74 %token TOK_INTEGER
75 %token TOK_FLOAT
76 %token TOK_BOOLEAN
77
78 %token TOK_IP6TYPE
79
80 %token TOK_DEBUGLEVEL
81 %token TOK_IPVERSION
82 %token TOK_HNA4
83 %token TOK_HNA6
84 %token TOK_PLUGIN
85 %token TOK_INTERFACE
86 %token TOK_NOINT
87 %token TOK_TOS
88 %token TOK_WILLINGNESS
89 %token TOK_IPCCON
90 %token TOK_USEHYST
91 %token TOK_HYSTSCALE
92 %token TOK_HYSTUPPER
93 %token TOK_HYSTLOWER
94 %token TOK_POLLRATE
95 %token TOK_TCREDUNDANCY
96 %token TOK_MPRCOVERAGE
97 %token TOK_LQ_LEVEL
98 %token TOK_LQ_WSIZE
99 %token TOK_CLEAR_SCREEN
100 %token TOK_PLNAME
101 %token TOK_PLPARAM
102
103 %token TOK_HOSTLABEL
104 %token TOK_NETLABEL
105 %token TOK_MAXIPC
106
107 %token TOK_IP4BROADCAST
108 %token TOK_IP6ADDRTYPE
109 %token TOK_IP6MULTISITE
110 %token TOK_IP6MULTIGLOBAL
111 %token TOK_HELLOINT
112 %token TOK_HELLOVAL
113 %token TOK_TCINT
114 %token TOK_TCVAL
115 %token TOK_MIDINT
116 %token TOK_MIDVAL
117 %token TOK_HNAINT
118 %token TOK_HNAVAL
119
120 %token TOK_IP4_ADDR
121 %token TOK_IP6_ADDR
122
123 %token TOK_COMMENT
124
125 %%
126
127 conf:
128           | conf block
129           | conf stmt
130 ;
131
132 stmt:       idebug
133           | iipversion
134           | bnoint
135           | atos
136           | awillingness
137           | busehyst
138           | fhystscale
139           | fhystupper
140           | fhystlower
141           | fpollrate
142           | atcredundancy
143           | amprcoverage
144           | alq_level
145           | alq_wsize
146           | bclear_screen
147           | vcomment
148 ;
149
150 block:      TOK_HNA4 hna4body
151           | TOK_HNA6 hna6body
152           | TOK_IPCCON ipcbody
153           | ifblock ifbody
154           | plblock plbody
155 ;
156
157 hna4body:       TOK_OPEN hna4stmts TOK_CLOSE
158 ;
159
160 hna4stmts: | hna4stmts hna4stmt
161 ;
162
163 hna4stmt:  vcomment
164          | ihna4entry
165 ;
166
167 hna6body:       TOK_OPEN hna6stmts TOK_CLOSE
168 ;
169
170 hna6stmts: | hna6stmts hna6stmt
171 ;
172
173 hna6stmt:  vcomment
174          | ihna6entry
175 ;
176
177 ipcbody:    TOK_OPEN ipcstmts TOK_CLOSE
178 ;
179
180 ipcstmts: | ipcstmts ipcstmt
181 ;
182
183 ipcstmt:  vcomment
184           | imaxipc
185           | ipchost
186           | ipcnet
187 ;
188
189 ifbody:     TOK_OPEN ifstmts TOK_CLOSE
190 ;
191
192 ifstmts:   | ifstmts ifstmt
193 ;
194
195 ifstmt:      vcomment
196              | isetip4br
197              | isetip6addrt
198              | isetip6mults
199              | isetip6multg
200              | isethelloint
201              | isethelloval
202              | isettcint
203              | isettcval
204              | isetmidint
205              | isetmidval
206              | isethnaint
207              | isethnaval
208 ;
209
210 plbody:     TOK_OPEN plstmts TOK_CLOSE
211 ;
212
213 plstmts:   | plstmts plstmt
214 ;
215
216 plstmt:     plparam
217           | vcomment
218 ;
219
220
221 imaxipc: TOK_MAXIPC TOK_INTEGER
222 {
223   cnf->ipc_connections = $2->integer;
224
225   cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
226
227   free($2);
228 }
229 ;
230
231
232 ipchost: TOK_HOSTLABEL TOK_IP4_ADDR
233 {
234   struct in_addr in;
235   struct ipc_host *ipch;
236
237   if(PARSER_DEBUG) printf("\tIPC host: %s\n", $2->string);
238   
239   if(inet_aton($2->string, &in) == 0)
240     {
241       fprintf(stderr, "Failed converting IP address IPC %s\n", $2->string);
242       return -1;
243     }
244
245   ipch = malloc(sizeof(struct ipc_host));
246   ipch->host.v4 = in.s_addr;
247
248   ipch->next = cnf->ipc_hosts;
249   cnf->ipc_hosts = ipch;
250
251   free($2->string);
252   free($2);
253
254 }
255 ;
256
257 ipcnet: TOK_NETLABEL TOK_IP4_ADDR TOK_IP4_ADDR
258 {
259   struct in_addr in1, in2;
260   struct ipc_net *ipcn;
261
262   if(PARSER_DEBUG) printf("\tIPC net: %s/%s\n", $2->string, $3->string);
263   
264   if(inet_aton($2->string, &in1) == 0)
265     {
266       fprintf(stderr, "Failed converting IP net IPC %s\n", $2->string);
267       return -1;
268     }
269
270   if(inet_aton($3->string, &in2) == 0)
271     {
272       fprintf(stderr, "Failed converting IP mask IPC %s\n", $3->string);
273       return -1;
274     }
275
276   ipcn = malloc(sizeof(struct ipc_net));
277   ipcn->net.v4 = in1.s_addr;
278   ipcn->mask.v4 = in2.s_addr;
279
280   ipcn->next = cnf->ipc_nets;
281   cnf->ipc_nets = ipcn;
282
283   free($2->string);
284   free($2);
285   free($3->string);
286   free($3);
287
288 }
289 ;
290
291 isetip4br: TOK_IP4BROADCAST TOK_IP4_ADDR
292 {
293   struct in_addr in;
294
295   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", $2->string);
296
297   if(inet_aton($2->string, &in) == 0)
298     {
299       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
300       return -1;
301     }
302
303   cnf->interfaces->cnf->ipv4_broadcast.v4 = in.s_addr;
304
305   free($2->string);
306   free($2);
307 }
308 ;
309
310 isetip6addrt: TOK_IP6ADDRTYPE TOK_IP6TYPE
311 {
312   if($2->boolean)
313     cnf->interfaces->cnf->ipv6_addrtype = IPV6_ADDR_SITELOCAL;
314   else
315     cnf->interfaces->cnf->ipv6_addrtype = 0;
316
317   free($2);
318 }
319 ;
320
321 isetip6mults: TOK_IP6MULTISITE TOK_IP6_ADDR
322 {
323   struct in6_addr in6;
324
325   if(PARSER_DEBUG) printf("\tIPv6 site-local 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       return -1;
331     }
332   memcpy(&cnf->interfaces->cnf->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
333
334
335   free($2->string);
336   free($2);
337 }
338 ;
339
340
341 isetip6multg: TOK_IP6MULTIGLOBAL TOK_IP6_ADDR
342 {
343   struct in6_addr in6;
344
345   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", $2->string);
346
347   if(inet_pton(AF_INET6, $2->string, &in6) < 0)
348     {
349       fprintf(stderr, "Failed converting IP address %s\n", $2->string);
350       return -1;
351     }
352   memcpy(&cnf->interfaces->cnf->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
353
354
355   free($2->string);
356   free($2);
357 }
358 ;
359 isethelloint: TOK_HELLOINT TOK_FLOAT
360 {
361     if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", $2->floating);
362     cnf->interfaces->cnf->hello_params.emission_interval = $2->floating;
363     free($2);
364 }
365 ;
366 isethelloval: TOK_HELLOVAL TOK_FLOAT
367 {
368     if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", $2->floating);
369     cnf->interfaces->cnf->hello_params.validity_time = $2->floating;
370     free($2);
371 }
372 ;
373 isettcint: TOK_TCINT TOK_FLOAT
374 {
375     if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", $2->floating);
376     cnf->interfaces->cnf->tc_params.emission_interval = $2->floating;
377     free($2);
378 }
379 ;
380 isettcval: TOK_TCVAL TOK_FLOAT
381 {
382     if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", $2->floating);
383     cnf->interfaces->cnf->tc_params.validity_time = $2->floating;
384     free($2);
385 }
386 ;
387 isetmidint: TOK_MIDINT TOK_FLOAT
388 {
389     if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", $2->floating);
390     cnf->interfaces->cnf->mid_params.emission_interval = $2->floating;
391     free($2);
392 }
393 ;
394 isetmidval: TOK_MIDVAL TOK_FLOAT
395 {
396     if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", $2->floating);
397     cnf->interfaces->cnf->mid_params.validity_time = $2->floating;
398     free($2);
399 }
400 ;
401 isethnaint: TOK_HNAINT TOK_FLOAT
402 {
403     if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", $2->floating);
404     cnf->interfaces->cnf->hna_params.emission_interval = $2->floating;
405     free($2);
406 }
407 ;
408 isethnaval: TOK_HNAVAL TOK_FLOAT
409 {
410     if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", $2->floating);
411     cnf->interfaces->cnf->hna_params.validity_time = $2->floating;
412     free($2);
413 }
414 ;
415
416
417 idebug:       TOK_DEBUGLEVEL TOK_INTEGER
418 {
419
420   cnf->debug_level = $2->integer;
421   if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
422   free($2);
423 }
424 ;
425
426
427 iipversion:    TOK_IPVERSION TOK_INTEGER
428 {
429   if($2->integer == 4)
430     cnf->ip_version = AF_INET;
431   else if($2->integer == 6)
432     cnf->ip_version = AF_INET6;
433   else
434     {
435       fprintf(stderr, "IPversion must be 4 or 6!\n");
436       YYABORT;
437     }
438
439   if(PARSER_DEBUG) printf("IpVersion: %d\n", $2->integer);
440   free($2);
441 }
442 ;
443
444
445 ihna4entry:     TOK_IP4_ADDR TOK_IP4_ADDR
446 {
447   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
448   struct in_addr in;
449
450   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", $1->string, $2->string);
451
452   if(h == NULL)
453     {
454       fprintf(stderr, "Out of memory(HNA4)\n");
455       YYABORT;
456     }
457
458   if(inet_aton($1->string, &in) == 0)
459     {
460       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
461       return -1;
462     }
463   h->net.v4 = in.s_addr;
464   if(inet_aton($2->string, &in) == 0)
465     {
466       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
467       return -1;
468     }
469   h->netmask.v4 = in.s_addr;
470   /* Queue */
471   h->next = cnf->hna4_entries;
472   cnf->hna4_entries = h;
473
474   free($1->string);
475   free($1);
476   free($2->string);
477   free($2);
478
479 }
480
481 ihna6entry:     TOK_IP6_ADDR TOK_INTEGER
482 {
483   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
484   struct in6_addr in6;
485
486   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", $1->string, $2->integer);
487
488   if(h == NULL)
489     {
490       fprintf(stderr, "Out of memory(HNA6)\n");
491       YYABORT;
492     }
493
494   if(inet_pton(AF_INET6, $1->string, &in6) < 0)
495     {
496       fprintf(stderr, "Failed converting IP address %s\n", $1->string);
497       return -1;
498     }
499   memcpy(&h->net, &in6, sizeof(struct in6_addr));
500
501   if(($2->integer < 0) || ($2->integer > 128))
502     {
503       fprintf(stderr, "Illegal IPv6 prefix length %d\n", $2->integer);
504       return -1;
505     }
506
507   h->prefix_len = $2->integer;
508   /* Queue */
509   h->next = cnf->hna6_entries;
510   cnf->hna6_entries = h;
511
512   free($1->string);
513   free($1);
514   free($2);
515
516 }
517
518 ifblock: TOK_INTERFACE TOK_STRING
519 {
520   struct olsr_if *in = malloc(sizeof(struct olsr_if));
521   
522   if(in == NULL)
523     {
524       fprintf(stderr, "Out of memory(ADD IF)\n");
525       YYABORT;
526     }
527
528   in->cnf = get_default_if_config();
529
530   if(in->cnf == NULL)
531     {
532       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
533       YYABORT;
534     }
535
536   in->name = $2->string;
537
538   /* Queue */
539   in->next = cnf->interfaces;
540   cnf->interfaces = in;
541
542   free($2);
543 }
544
545 bnoint: TOK_NOINT TOK_BOOLEAN
546 {
547   if(PARSER_DEBUG) printf("Noint set to %d\n", $2->boolean);
548
549   cnf->allow_no_interfaces = $2->boolean;
550
551   free($2);
552 }
553 ;
554
555 atos: TOK_TOS TOK_INTEGER
556 {
557   if(PARSER_DEBUG) printf("TOS: %d\n", $2->integer);
558   cnf->tos = $2->integer;
559
560   free($2);
561
562 }
563 ;
564
565 awillingness: TOK_WILLINGNESS TOK_INTEGER
566 {
567   cnf->willingness_auto = OLSR_FALSE;
568
569   if(PARSER_DEBUG) printf("Willingness: %d\n", $2->integer);
570   cnf->willingness = $2->integer;
571
572   free($2);
573
574 }
575 ;
576
577
578
579 busehyst: TOK_USEHYST TOK_BOOLEAN
580 {
581   cnf->use_hysteresis = $2->boolean;
582   if(cnf->use_hysteresis)
583     {
584       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
585     }
586   else
587     {
588       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
589     }
590   free($2);
591
592 }
593 ;
594
595
596 fhystscale: TOK_HYSTSCALE TOK_FLOAT
597 {
598   cnf->hysteresis_param.scaling = $2->floating;
599   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", $2->floating);
600   free($2);
601 }
602 ;
603
604
605 fhystupper: TOK_HYSTUPPER TOK_FLOAT
606 {
607   cnf->hysteresis_param.thr_high = $2->floating;
608   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", $2->floating);
609   free($2);
610 }
611 ;
612
613
614 fhystlower: TOK_HYSTLOWER TOK_FLOAT
615 {
616   cnf->hysteresis_param.thr_low = $2->floating;
617   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", $2->floating);
618   free($2);
619 }
620 ;
621
622 fpollrate: TOK_POLLRATE TOK_FLOAT
623 {
624   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", $2->floating);
625   cnf->pollrate = $2->floating;
626
627   free($2);
628 }
629 ;
630
631
632 atcredundancy: TOK_TCREDUNDANCY TOK_INTEGER
633 {
634   if(PARSER_DEBUG) printf("TC redundancy %d\n", $2->integer);
635   cnf->tc_redundancy = $2->integer;
636   free($2);
637 }
638 ;
639
640 amprcoverage: TOK_MPRCOVERAGE TOK_INTEGER
641 {
642   if(PARSER_DEBUG) printf("MPR coverage %d\n", $2->integer);
643   cnf->mpr_coverage = $2->integer;
644   free($2);
645 }
646 ;
647
648 alq_level: TOK_LQ_LEVEL TOK_INTEGER
649 {
650   if(PARSER_DEBUG) printf("Link quality level %d\n", $2->integer);
651   cnf->lq_level = $2->integer;
652   free($2);
653 }
654 ;
655
656 alq_wsize: TOK_LQ_WSIZE TOK_INTEGER
657 {
658   if(PARSER_DEBUG) printf("Link quality window size %d\n", $2->integer);
659   cnf->lq_wsize = $2->integer;
660   free($2);
661 }
662 ;
663
664 bclear_screen: TOK_CLEAR_SCREEN TOK_BOOLEAN
665 {
666   cnf->clear_screen = $2->boolean;
667
668   if (PARSER_DEBUG)
669     printf("Clear screen %s\n", cnf->clear_screen ? "enabled" : "disabled");
670
671   free($2);
672 }
673 ;
674
675 plblock: TOK_PLUGIN TOK_STRING
676 {
677   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
678   
679   if(pe == NULL)
680     {
681       fprintf(stderr, "Out of memory(ADD PL)\n");
682       YYABORT;
683     }
684
685   pe->name = $2->string;
686
687   pe->params = NULL;
688   
689   if(PARSER_DEBUG) printf("Plugin: %s\n", $2->string);
690
691   /* Queue */
692   pe->next = cnf->plugins;
693   cnf->plugins = pe;
694
695   free($2);
696 }
697 ;
698
699 plparam: TOK_PLPARAM TOK_STRING TOK_STRING
700 {
701   struct plugin_param *pp = malloc(sizeof(struct plugin_param));
702   
703   if(pp == NULL)
704     {
705       fprintf(stderr, "Out of memory(ADD PP)\n");
706       YYABORT;
707     }
708   
709   if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", $2->string, $3->string);
710   
711   pp->key = $2->string;
712   pp->value = $3->string;
713
714   /* Queue */
715   pp->next = cnf->plugins->params;
716   cnf->plugins->params = pp;
717
718   free($2);
719   free($3);
720 }
721 ;
722
723 vcomment:       TOK_COMMENT
724 {
725     //if(PARSER_DEBUG) printf("Comment\n");
726 }
727 ;
728
729
730
731 %%
732
733 void yyerror (char *string)
734 {
735   fprintf(stderr, "Config line %d: %s\n", current_line, string);
736 }