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