Fixed IPv6 addrtpe initialization
[olsrd.git] / src / cfgparser / olsrd_conf.c
1 /*
2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
3  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met:
9  *
10  * * Redistributions of source code must retain the above copyright 
11  *   notice, this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above copyright 
13  *   notice, this list of conditions and the following disclaimer in 
14  *   the documentation and/or other materials provided with the 
15  *   distribution.
16  * * Neither the name of olsr.org, olsrd nor the names of its 
17  *   contributors may be used to endorse or promote products derived 
18  *   from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
24  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Visit http://www.olsr.org for more information.
34  *
35  * If you find this software useful feel free to make a donation
36  * to the project. For more information see the website or contact
37  * the copyright holders.
38  *
39  * $Id: olsrd_conf.c,v 1.42 2005/09/17 20:48:50 kattemat Exp $
40  */
41
42
43 #include <stdio.h>
44 #include <string.h>
45 #include <errno.h>
46 #include <stdlib.h>
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <netinet/in.h>
50 #include <arpa/inet.h>
51
52 #include "olsrd_conf.h"
53
54
55 extern FILE *yyin;
56 extern int yyparse(void);
57
58 static char copyright_string[] = "The olsr.org Optimized Link-State Routing daemon(olsrd) Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org) All rights reserved.";
59
60 #ifdef MAKEBIN
61
62 /* Build as standalone binary */
63 int 
64 main(int argc, char *argv[])
65 {
66   struct olsrd_config *cnf;
67
68   if(argc == 1)
69     {
70       fprintf(stderr, "Usage: olsrd_cfgparser [filename] -print\n\n");
71       exit(EXIT_FAILURE);
72     }
73
74   if((cnf = olsrd_parse_cnf(argv[1])) != NULL)
75     {
76       if((argc > 2) && (!strcmp(argv[2], "-print")))
77         {
78           olsrd_print_cnf(cnf);  
79           olsrd_write_cnf(cnf, "./out.conf");
80         }
81       else
82         printf("Use -print to view parsed values\n");
83       printf("Configfile parsed OK\n");
84     }
85   else
86     {
87       printf("Failed parsing \"%s\"\n", argv[1]);
88     }
89
90   return 0;
91 }
92
93 #else
94
95 /* Build as part of olsrd */
96
97
98 #endif
99
100 struct olsrd_config *
101 olsrd_parse_cnf(const char *filename)
102 {
103   struct olsr_if *in, *new_ifqueue, *in_tmp;
104
105   /* Stop the compiler from complaining */
106   strlen(copyright_string);
107
108   cnf = malloc(sizeof(struct olsrd_config));
109   if (cnf == NULL)
110     {
111       fprintf(stderr, "Out of memory %s\n", __func__);
112       return NULL;
113   }
114
115   set_default_cnf(cnf);
116
117   printf("Parsing file: \"%s\"\n", filename);
118
119   yyin = fopen(filename, "r");
120   
121   if (yyin == NULL)
122     {
123       fprintf(stderr, "Cannot open configuration file '%s': %s.\n",
124               filename, strerror(errno));
125       free(cnf);
126       return NULL;
127   }
128
129   current_line = 1;
130
131   if (yyparse() != 0)
132     {
133       fclose(yyin);
134       olsrd_free_cnf(cnf);
135       return NULL;
136     }
137   
138   fclose(yyin);
139
140   /* Reverse the queue (added by user request) */
141   in = cnf->interfaces;
142   new_ifqueue = NULL;
143
144   while(in)
145     {
146       in_tmp = in; 
147       in = in->next;
148
149       in_tmp->next = new_ifqueue;
150       new_ifqueue = in_tmp;
151     }
152
153   cnf->interfaces = new_ifqueue;
154
155   in = cnf->interfaces;
156
157   while(in)
158     {
159       /* set various stuff */
160       in->index = cnf->ifcnt++;
161       in->configured = OLSR_FALSE;
162       in->interf = NULL;
163       in->host_emul = OLSR_FALSE;
164       in = in->next;
165     }
166
167
168   return cnf;
169 }
170
171
172 int
173 olsrd_sanity_check_cnf(struct olsrd_config *cnf)
174 {
175   struct olsr_if           *in = cnf->interfaces;
176   struct if_config_options *io;
177
178   /* Debug level */
179   if(cnf->debug_level < MIN_DEBUGLVL ||
180      cnf->debug_level > MAX_DEBUGLVL)
181     {
182       fprintf(stderr, "Debuglevel %d is not allowed\n", cnf->debug_level);
183       return -1;
184     }
185
186   /* IP version */
187   if(cnf->ip_version != AF_INET &&
188      cnf->ip_version != AF_INET6)
189     {
190       fprintf(stderr, "Ipversion %d not allowed!\n", cnf->ip_version);
191       return -1;
192     }
193
194   /* TOS */
195   if(//cnf->tos < MIN_TOS ||
196      cnf->tos > MAX_TOS)
197     {
198       fprintf(stderr, "TOS %d is not allowed\n", cnf->tos);
199       return -1;
200     }
201
202   if(cnf->willingness_auto == OLSR_FALSE &&
203      (cnf->willingness > MAX_WILLINGNESS))
204     {
205       fprintf(stderr, "Willingness %d is not allowed\n", cnf->willingness);
206       return -1;
207     }
208
209   /* Hysteresis */
210   if(cnf->use_hysteresis == OLSR_TRUE)
211     {
212       if(cnf->hysteresis_param.scaling < MIN_HYST_PARAM ||
213          cnf->hysteresis_param.scaling > MAX_HYST_PARAM)
214         {
215           fprintf(stderr, "Hyst scaling %0.2f is not allowed\n", cnf->hysteresis_param.scaling);
216           return -1;
217         }
218
219       if(cnf->hysteresis_param.thr_high <= cnf->hysteresis_param.thr_low)
220         {
221           fprintf(stderr, "Hyst upper(%0.2f) thr must be bigger than lower(%0.2f) threshold!\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
222           return -1;
223         }
224
225       if(cnf->hysteresis_param.thr_high < MIN_HYST_PARAM ||
226          cnf->hysteresis_param.thr_high > MAX_HYST_PARAM)
227         {
228           fprintf(stderr, "Hyst upper thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_high);
229           return -1;
230         }
231
232       if(cnf->hysteresis_param.thr_low < MIN_HYST_PARAM ||
233          cnf->hysteresis_param.thr_low > MAX_HYST_PARAM)
234         {
235           fprintf(stderr, "Hyst lower thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_low);
236           return -1;
237         }
238     }
239
240   /* Pollrate */
241
242   if(cnf->pollrate < MIN_POLLRATE ||
243      cnf->pollrate > MAX_POLLRATE)
244     {
245       fprintf(stderr, "Pollrate %0.2f is not allowed\n", cnf->pollrate);
246       return -1;
247     }
248
249   /* TC redundancy */
250
251   if(//cnf->tc_redundancy < MIN_TC_REDUNDANCY ||
252      cnf->tc_redundancy > MAX_TC_REDUNDANCY)
253     {
254       fprintf(stderr, "TC redundancy %d is not allowed\n", cnf->tc_redundancy);
255       return -1;
256     }
257
258   /* MPR coverage */
259   if(cnf->mpr_coverage < MIN_MPR_COVERAGE ||
260      cnf->mpr_coverage > MAX_MPR_COVERAGE)
261     {
262       fprintf(stderr, "MPR coverage %d is not allowed\n", cnf->mpr_coverage);
263       return -1;
264     }
265
266   /* Link Q and hysteresis cannot be activated at the same time */
267   if(cnf->use_hysteresis == OLSR_TRUE && cnf->lq_level)
268     {
269       fprintf(stderr, "Hysteresis and LinkQuality cannot both be active! Deactivate one of them.\n");
270       return -1;
271     }
272
273   /* Link quality level */
274
275   if(cnf->lq_level > MAX_LQ_LEVEL)
276     {
277       fprintf(stderr, "LQ level %d is not allowed\n", cnf->lq_level);
278       return -1;
279     }
280
281   /* Link quality window size */
282   if(cnf->lq_level && (cnf->lq_wsize < MIN_LQ_WSIZE || cnf->lq_wsize > MAX_LQ_WSIZE))
283     {
284       fprintf(stderr, "LQ window size %d is not allowed\n", cnf->lq_wsize);
285       return -1;
286     }
287
288   if(in == NULL)
289     {
290       fprintf(stderr, "No interfaces configured!\n");
291       return -1;
292     }
293
294   /* Interfaces */
295   while(in)
296     {
297       io = in->cnf;
298
299       if(in->name == NULL || !strlen(in->name))
300         {
301           fprintf(stderr, "Interface has no name!\n");
302           return -1;
303         }
304
305       if(io == NULL)
306         {
307           fprintf(stderr, "Interface %s has no configuration!\n", in->name);
308           return -1;
309         }
310         
311       /* HELLO interval */
312       if(io->hello_params.emission_interval < cnf->pollrate ||
313          io->hello_params.emission_interval > io->hello_params.validity_time)
314         {
315           fprintf(stderr, "Bad HELLO parameters! (em: %0.2f, vt: %0.2f)\n", io->hello_params.emission_interval, io->hello_params.validity_time);
316           return -1;
317         }
318
319       /* TC interval */
320       if(io->tc_params.emission_interval < cnf->pollrate ||
321          io->tc_params.emission_interval > io->tc_params.validity_time)
322         {
323           fprintf(stderr, "Bad TC parameters! (em: %0.2f, vt: %0.2f)\n", io->tc_params.emission_interval, io->tc_params.validity_time);
324           return -1;
325         }
326
327       /* MID interval */
328       if(io->mid_params.emission_interval < cnf->pollrate ||
329          io->mid_params.emission_interval > io->mid_params.validity_time)
330         {
331           fprintf(stderr, "Bad MID parameters! (em: %0.2f, vt: %0.2f)\n", io->mid_params.emission_interval, io->mid_params.validity_time);
332           return -1;
333         }
334
335       /* HNA interval */
336       if(io->hna_params.emission_interval < cnf->pollrate ||
337          io->hna_params.emission_interval > io->hna_params.validity_time)
338         {
339           fprintf(stderr, "Bad HNA parameters! (em: %0.2f, vt: %0.2f)\n", io->hna_params.emission_interval, io->hna_params.validity_time);
340           return -1;
341         }
342
343       in = in->next;
344     }
345
346   return 0;
347 }
348
349
350 void
351 olsrd_free_cnf(struct olsrd_config *cnf)
352 {
353   struct hna4_entry        *h4d, *h4 = cnf->hna4_entries;
354   struct hna6_entry        *h6d, *h6 = cnf->hna6_entries;
355   struct olsr_if           *ind, *in = cnf->interfaces;
356   struct plugin_entry      *ped, *pe = cnf->plugins;
357   struct olsr_lq_mult      *mult, *next_mult;
358   
359   while(h4)
360     {
361       h4d = h4;
362       h4 = h4->next;
363       free(h4d);
364     }
365
366   while(h6)
367     {
368       h6d = h6;
369       h6 = h6->next;
370       free(h6d);
371     }
372
373   while(in)
374     {
375       for (mult = in->cnf->lq_mult; mult != NULL; mult = next_mult)
376       {
377         next_mult = mult->next;
378         free(mult);
379       }
380
381       free(in->cnf);
382       ind = in;
383       in = in->next;
384       free(ind->name);
385       free(ind->config);
386       free(ind);
387     }
388
389   while(pe)
390     {
391       ped = pe;
392       pe = pe->next;
393       free(ped->name);
394       free(ped);
395     }
396
397   return;
398 }
399
400
401
402 struct olsrd_config *
403 olsrd_get_default_cnf()
404 {
405   cnf = malloc(sizeof(struct olsrd_config));
406   if (cnf == NULL)
407     {
408       fprintf(stderr, "Out of memory %s\n", __func__);
409       return NULL;
410   }
411
412   set_default_cnf(cnf);
413
414   return cnf;
415 }
416
417
418
419
420 void
421 set_default_cnf(struct olsrd_config *cnf)
422 {
423     memset(cnf, 0, sizeof(struct olsrd_config));
424     
425     cnf->debug_level = DEF_DEBUGLVL;
426     cnf->no_fork = OLSR_FALSE;
427     cnf->host_emul = OLSR_FALSE;
428     cnf->ip_version  = AF_INET;
429     cnf->allow_no_interfaces = DEF_ALLOW_NO_INTS;
430     cnf->tos = DEF_TOS;
431     cnf->willingness_auto = DEF_WILL_AUTO;
432     cnf->ipc_connections = DEF_IPC_CONNECTIONS;
433     cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
434
435     cnf->use_hysteresis = DEF_USE_HYST;
436     cnf->hysteresis_param.scaling = HYST_SCALING;
437     cnf->hysteresis_param.thr_high = HYST_THRESHOLD_HIGH;
438     cnf->hysteresis_param.thr_low = HYST_THRESHOLD_LOW;
439
440     cnf->pollrate = DEF_POLLRATE;
441
442     cnf->tc_redundancy = TC_REDUNDANCY;
443     cnf->mpr_coverage = MPR_COVERAGE;
444     cnf->lq_level = DEF_LQ_LEVEL;
445     cnf->lq_wsize = DEF_LQ_WSIZE;
446     cnf->clear_screen = DEF_CLEAR_SCREEN;
447 }
448
449
450
451
452 struct if_config_options *
453 get_default_if_config()
454 {
455   struct if_config_options *io = malloc(sizeof(struct if_config_options));
456   struct in6_addr in6;
457  
458   memset(io, 0, sizeof(struct if_config_options));
459
460   io->ipv6_addrtype = 1; /* XXX - FixMe */
461
462   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6) < 0)
463     {
464       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_SITE_LOCAL);
465       return NULL;
466     }
467   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
468
469   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6) < 0)
470     {
471       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_GLOBAL);
472       return NULL;
473     }
474   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
475
476   io->lq_mult = NULL;
477
478   io->weight.fixed = OLSR_FALSE;
479   io->weight.value = 0;
480
481   io->ipv6_addrtype = 0; /* global */
482
483   io->hello_params.emission_interval = HELLO_INTERVAL;
484   io->hello_params.validity_time = NEIGHB_HOLD_TIME;
485   io->tc_params.emission_interval = TC_INTERVAL;
486   io->tc_params.validity_time = TOP_HOLD_TIME;
487   io->mid_params.emission_interval = MID_INTERVAL;
488   io->mid_params.validity_time = MID_HOLD_TIME;
489   io->hna_params.emission_interval = HNA_INTERVAL;
490   io->hna_params.validity_time = HNA_HOLD_TIME;
491
492   return io;
493
494 }
495
496
497
498 void
499 olsrd_print_cnf(struct olsrd_config *cnf)
500 {
501   struct hna4_entry        *h4 = cnf->hna4_entries;
502   struct hna6_entry        *h6 = cnf->hna6_entries;
503   struct olsr_if           *in = cnf->interfaces;
504   struct plugin_entry      *pe = cnf->plugins;
505   struct ipc_host          *ih = cnf->ipc_hosts;
506   struct ipc_net           *ie = cnf->ipc_nets;
507   struct olsr_lq_mult      *mult;
508   char ipv6_buf[100];             /* buffer for IPv6 inet_htop */
509   struct in_addr in4;
510
511   printf(" *** olsrd configuration ***\n");
512
513   printf("Debug Level      : %d\n", cnf->debug_level);
514   if(cnf->ip_version == AF_INET6)
515     printf("IpVersion        : 6\n");
516   else
517     printf("IpVersion        : 4\n");
518   if(cnf->allow_no_interfaces)
519     printf("No interfaces    : ALLOWED\n");
520   else
521     printf("No interfaces    : NOT ALLOWED\n");
522   printf("TOS              : 0x%02x\n", cnf->tos);
523   if(cnf->willingness_auto)
524     printf("Willingness      : AUTO\n");
525   else
526     printf("Willingness      : %d\n", cnf->willingness);
527
528   printf("IPC connections  : %d\n", cnf->ipc_connections);
529
530   while(ih)
531     {
532       in4.s_addr = ih->host.v4;
533       printf("\tHost %s\n", inet_ntoa(in4));
534       ih = ih->next;
535     }
536   
537   while(ie)
538     {
539       in4.s_addr = ie->net.v4;
540       printf("\tNet %s/", inet_ntoa(in4));
541       in4.s_addr = ie->mask.v4;
542       printf("%s\n", inet_ntoa(in4));
543       ie = ie->next;
544     }
545
546
547   printf("Pollrate         : %0.2f\n", cnf->pollrate);
548
549   printf("TC redundancy    : %d\n", cnf->tc_redundancy);
550
551   printf("MPR coverage     : %d\n", cnf->mpr_coverage);
552    
553   printf("LQ level         : %d\n", cnf->lq_level);
554
555   printf("LQ window size   : %d\n", cnf->lq_wsize);
556
557   printf("Clear screen     : %s\n", cnf->clear_screen ? "yes" : "no");
558
559   /* Interfaces */
560   if(in)
561     {
562       printf("Interfaces:\n");
563       while(in)
564         {
565           printf(" dev: \"%s\"\n", in->name);
566           
567           if(in->cnf->ipv4_broadcast.v4)
568             {
569               in4.s_addr = in->cnf->ipv4_broadcast.v4;
570               printf("\tIPv4 broadcast           : %s\n", inet_ntoa(in4));
571             }
572           else
573             {
574               printf("\tIPv4 broadcast           : AUTO\n");
575             }
576           
577           printf("\tIPv6 addrtype            : %s\n", in->cnf->ipv6_addrtype ? "site-local" : "global");
578           
579           //union olsr_ip_addr       ipv6_multi_site;
580           //union olsr_ip_addr       ipv6_multi_glbl;
581           printf("\tIPv6 multicast site/glbl : %s", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_site.v6, ipv6_buf, sizeof(ipv6_buf)));
582           printf("/%s\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_glbl.v6, ipv6_buf, sizeof(ipv6_buf)));
583           
584           printf("\tHELLO emission/validity  : %0.2f/%0.2f\n", in->cnf->hello_params.emission_interval, in->cnf->hello_params.validity_time);
585           printf("\tTC emission/validity     : %0.2f/%0.2f\n", in->cnf->tc_params.emission_interval, in->cnf->tc_params.validity_time);
586           printf("\tMID emission/validity    : %0.2f/%0.2f\n", in->cnf->mid_params.emission_interval, in->cnf->mid_params.validity_time);
587           printf("\tHNA emission/validity    : %0.2f/%0.2f\n", in->cnf->hna_params.emission_interval, in->cnf->hna_params.validity_time);
588           
589           for (mult = in->cnf->lq_mult; mult != NULL; mult = mult->next)
590           {
591             inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf,
592                       sizeof (ipv6_buf));
593
594             printf("\tLinkQualityMult          : %s %0.2f\n",
595                    ipv6_buf, mult->val);
596           }
597           
598           in = in->next;
599         }
600     }
601
602
603
604
605   /* Plugins */
606   if(pe)
607     {
608       printf("Plugins:\n");
609
610       while(pe)
611         {
612           printf("\tName: \"%s\"\n", pe->name);
613           pe = pe->next;
614         }
615     }
616
617   /* Hysteresis */
618   if(cnf->use_hysteresis)
619     {
620       printf("Using hysteresis:\n");
621       printf("\tScaling      : %0.2f\n", cnf->hysteresis_param.scaling);
622       printf("\tThr high/low : %0.2f/%0.2f\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
623     }
624   else
625     printf("Not using hysteresis\n");
626
627   /* HNA IPv4 */
628   if(h4)
629     {
630
631       printf("HNA4 entries:\n");
632       while(h4)
633         {
634           in4.s_addr = h4->net.v4;
635           printf("\t%s/", inet_ntoa(in4));
636           in4.s_addr = h4->netmask.v4;
637           printf("%s\n", inet_ntoa(in4));
638
639           h4 = h4->next;
640         }
641     }
642
643   /* HNA IPv6 */
644   if(h6)
645     {
646       printf("HNA6 entries:\n");
647       while(h6)
648         {
649           printf("\t%s/%d\n", (char *)inet_ntop(AF_INET6, &h6->net.v6, ipv6_buf, sizeof(ipv6_buf)), h6->prefix_len);
650           h6 = h6->next;
651         }
652     }
653 }
654
655 void *olsrd_cnf_malloc(unsigned int len)
656 {
657   return malloc(len);
658 }
659
660 void olsrd_cnf_free(void *addr)
661 {
662   free(addr);
663 }
664
665 #if defined WIN32_STDIO_HACK
666 struct ioinfo
667 {
668         unsigned int handle;
669         unsigned char attr;
670         char buff;
671         int flag;
672         CRITICAL_SECTION lock;
673 };
674
675 void win32_stdio_hack(unsigned int handle)
676 {
677   HMODULE lib;
678   struct ioinfo **info;
679
680   lib = LoadLibrary("msvcrt.dll");
681
682   info = (struct ioinfo **)GetProcAddress(lib, "__pioinfo");
683
684   // (*info)[1].handle = handle;
685   // (*info)[1].attr = 0x89; // FOPEN | FTEXT | FPIPE;
686
687   (*info)[2].handle = handle;
688   (*info)[2].attr = 0x89;
689
690   // stdout->_file = 1;
691   stderr->_file = 2;
692
693   // setbuf(stdout, NULL);
694   setbuf(stderr, NULL);
695 }
696 #else
697 void win32_stdio_hack(unsigned int handle) {}
698 #endif