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.33 2005/02/17 17:21:24 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 MAKELIB
  61
  62 /* Build as DLL */
  63
  64 void __attribute__ ((constructor))
  65 my_init(void);
  66
  67 void __attribute__ ((destructor))
  68 my_fini(void);
  69
  70
  71 /**
  72  *Constructor
  73  */
  74 void
  75 my_init()
  76 {
  77   /* Print plugin info to stdout */
  78   printf("olsrd config file parser %s loaded\n", PARSER_VERSION);
  79
  80   return;
  81 }
  82
  83 /**
  84  *Destructor
  85  */
  86 void
  87 my_fini()
  88 {
  89   printf("See you around!\n");
  90   return;
  91 }
  92
  93 #else
  94
  95 #ifdef MAKEBIN
  96
  97 /* Build as standalone binary */
  98 int
  99 main(int argc, char *argv[])
 100 {
 101   struct olsrd_config *cnf;
 102
 103   if(argc == 1)
 104     {
 105       fprintf(stderr, "Usage: olsrd_cfgparser [filename] -print\n\n");
 106       exit(EXIT_FAILURE);
 107     }
 108
 109   if((cnf = olsrd_parse_cnf(argv[1])) != NULL)
 110     {
 111       if((argc > 2) && (!strcmp(argv[2], "-print")))
 112         {
 113           olsrd_print_cnf(cnf);
 114           olsrd_write_cnf(cnf, "./out.conf");
 115         }
 116       else
 117         printf("Use -print to view parsed values\n");
 118       printf("Configfile parsed OK\n");
 119     }
 120   else
 121     {
 122       printf("Failed parsing \"%s\"\n", argv[1]);
 123     }
 124
 125   return 0;
 126 }
 127
 128 #else
 129
 130 /* Build as part of olsrd */
 131
 132
 133 #endif
 134
 135 #endif
 136
 137 struct olsrd_config *
 138 olsrd_parse_cnf(const char *filename)
 139 {
 140   struct olsr_if *in, *new_ifqueue, *in_tmp;
 141
 142   /* Stop the compiler from complaining */
 143   strlen(copyright_string);
 144
 145   cnf = malloc(sizeof(struct olsrd_config));
 146   if (cnf == NULL)
 147     {
 148       fprintf(stderr, "Out of memory %s\n", __func__);
 149       return NULL;
 150   }
 151
 152   set_default_cnf(cnf);
 153
 154   printf("Parsing file: \"%s\"\n", filename);
 155
 156   yyin = fopen(filename, "r");
 157
 158   if (yyin == NULL)
 159     {
 160       fprintf(stderr, "Cannot open configuration file '%s': %s.\n",
 161               filename, strerror(errno));
 162       free(cnf);
 163       return NULL;
 164   }
 165
 166   current_line = 1;
 167
 168   if (yyparse() != 0)
 169     {
 170       fclose(yyin);
 171       olsrd_free_cnf(cnf);
 172       return NULL;
 173     }
 174
 175   fclose(yyin);
 176
 177   /* Reverse the queue (added by user request) */
 178   in = cnf->interfaces;
 179   new_ifqueue = NULL;
 180
 181   while(in)
 182     {
 183       in_tmp = in;
 184       in = in->next;
 185
 186       in_tmp->next = new_ifqueue;
 187       new_ifqueue = in_tmp;
 188     }
 189
 190   cnf->interfaces = new_ifqueue;
 191
 192   in = cnf->interfaces;
 193
 194   while(in)
 195     {
 196       /* set various stuff */
 197       in->index = cnf->ifcnt++;
 198       in->configured = OLSR_FALSE;
 199       in->interf = NULL;
 200       in = in->next;
 201     }
 202
 203
 204   return cnf;
 205 }
 206
 207
 208 int
 209 olsrd_sanity_check_cnf(struct olsrd_config *cnf)
 210 {
 211   struct olsr_if           *in = cnf->interfaces;
 212   struct if_config_options *io;
 213
 214   /* Debug level */
 215   if(cnf->debug_level < MIN_DEBUGLVL ||
 216      cnf->debug_level > MAX_DEBUGLVL)
 217     {
 218       fprintf(stderr, "Debuglevel %d is not allowed\n", cnf->debug_level);
 219       return -1;
 220     }
 221
 222   /* IP version */
 223   if(cnf->ip_version != AF_INET &&
 224      cnf->ip_version != AF_INET6)
 225     {
 226       fprintf(stderr, "Ipversion %d not allowed!\n", cnf->ip_version);
 227       return -1;
 228     }
 229
 230   /* TOS */
 231   if(//cnf->tos < MIN_TOS ||
 232      cnf->tos > MAX_TOS)
 233     {
 234       fprintf(stderr, "TOS %d is not allowed\n", cnf->tos);
 235       return -1;
 236     }
 237
 238   if(cnf->willingness_auto == OLSR_FALSE &&
 239      (cnf->willingness < MIN_WILLINGNESS ||
 240       cnf->willingness > MAX_WILLINGNESS))
 241     {
 242       fprintf(stderr, "Willingness %d is not allowed\n", cnf->willingness);
 243       return -1;
 244     }
 245
 246   /* Hysteresis */
 247   if(cnf->use_hysteresis == OLSR_TRUE)
 248     {
 249       if(cnf->hysteresis_param.scaling < MIN_HYST_PARAM ||
 250          cnf->hysteresis_param.scaling > MAX_HYST_PARAM)
 251         {
 252           fprintf(stderr, "Hyst scaling %0.2f is not allowed\n", cnf->hysteresis_param.scaling);
 253           return -1;
 254         }
 255
 256       if(cnf->hysteresis_param.thr_high <= cnf->hysteresis_param.thr_low)
 257         {
 258           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);
 259           return -1;
 260         }
 261
 262       if(cnf->hysteresis_param.thr_high < MIN_HYST_PARAM ||
 263          cnf->hysteresis_param.thr_high > MAX_HYST_PARAM)
 264         {
 265           fprintf(stderr, "Hyst upper thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_high);
 266           return -1;
 267         }
 268
 269       if(cnf->hysteresis_param.thr_low < MIN_HYST_PARAM ||
 270          cnf->hysteresis_param.thr_low > MAX_HYST_PARAM)
 271         {
 272           fprintf(stderr, "Hyst lower thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_low);
 273           return -1;
 274         }
 275     }
 276
 277   /* Pollrate */
 278
 279   if(cnf->pollrate < MIN_POLLRATE ||
 280      cnf->pollrate > MAX_POLLRATE)
 281     {
 282       fprintf(stderr, "Pollrate %0.2f is not allowed\n", cnf->pollrate);
 283       return -1;
 284     }
 285
 286   /* TC redundancy */
 287
 288   if(//cnf->tc_redundancy < MIN_TC_REDUNDANCY ||
 289      cnf->tc_redundancy > MAX_TC_REDUNDANCY)
 290     {
 291       fprintf(stderr, "TC redundancy %d is not allowed\n", cnf->tc_redundancy);
 292       return -1;
 293     }
 294
 295   /* MPR coverage */
 296   if(cnf->mpr_coverage < MIN_MPR_COVERAGE ||
 297      cnf->mpr_coverage > MAX_MPR_COVERAGE)
 298     {
 299       fprintf(stderr, "MPR coverage %d is not allowed\n", cnf->mpr_coverage);
 300       return -1;
 301     }
 302
 303   /* Link Q and hysteresis cannot be activated at the same time */
 304   if(cnf->use_hysteresis == OLSR_TRUE && cnf->lq_level)
 305     {
 306       fprintf(stderr, "Hysteresis and LinkQuality cannot both be active! Deactivate one of them.\n");
 307       return -1;
 308     }
 309
 310   /* Link quality level */
 311
 312   if(cnf->lq_level > MAX_LQ_LEVEL)
 313     {
 314       fprintf(stderr, "LQ level %d is not allowed\n", cnf->lq_level);
 315       return -1;
 316     }
 317
 318   /* Link quality window size */
 319   if(cnf->lq_level && (cnf->lq_wsize < MIN_LQ_WSIZE || cnf->lq_wsize > MAX_LQ_WSIZE))
 320     {
 321       fprintf(stderr, "LQ window size %d is not allowed\n", cnf->lq_wsize);
 322       return -1;
 323     }
 324
 325   if(in == NULL)
 326     {
 327       fprintf(stderr, "No interfaces configured!\n");
 328       return -1;
 329     }
 330
 331   /* Interfaces */
 332   while(in)
 333     {
 334       io = in->cnf;
 335
 336       if(in->name == NULL || !strlen(in->name))
 337         {
 338           fprintf(stderr, "Interface has no name!\n");
 339           return -1;
 340         }
 341
 342       if(io == NULL)
 343         {
 344           fprintf(stderr, "Interface %s has no configuration!\n", in->name);
 345           return -1;
 346         }
 347
 348       /* HELLO interval */
 349       if(io->hello_params.emission_interval < cnf->pollrate ||
 350          io->hello_params.emission_interval > io->hello_params.validity_time)
 351         {
 352           fprintf(stderr, "Bad HELLO parameters! (em: %0.2f, vt: %0.2f)\n", io->hello_params.emission_interval, io->hello_params.validity_time);
 353           return -1;
 354         }
 355
 356       /* TC interval */
 357       if(io->tc_params.emission_interval < cnf->pollrate ||
 358          io->tc_params.emission_interval > io->tc_params.validity_time)
 359         {
 360           fprintf(stderr, "Bad TC parameters! (em: %0.2f, vt: %0.2f)\n", io->tc_params.emission_interval, io->tc_params.validity_time);
 361           return -1;
 362         }
 363
 364       /* MID interval */
 365       if(io->mid_params.emission_interval < cnf->pollrate ||
 366          io->mid_params.emission_interval > io->mid_params.validity_time)
 367         {
 368           fprintf(stderr, "Bad MID parameters! (em: %0.2f, vt: %0.2f)\n", io->mid_params.emission_interval, io->mid_params.validity_time);
 369           return -1;
 370         }
 371
 372       /* HNA interval */
 373       if(io->hna_params.emission_interval < cnf->pollrate ||
 374          io->hna_params.emission_interval > io->hna_params.validity_time)
 375         {
 376           fprintf(stderr, "Bad HNA parameters! (em: %0.2f, vt: %0.2f)\n", io->hna_params.emission_interval, io->hna_params.validity_time);
 377           return -1;
 378         }
 379
 380       in = in->next;
 381     }
 382
 383   return 0;
 384 }
 385
 386
 387 void
 388 olsrd_free_cnf(struct olsrd_config *cnf)
 389 {
 390   struct hna4_entry        *h4d, *h4 = cnf->hna4_entries;
 391   struct hna6_entry        *h6d, *h6 = cnf->hna6_entries;
 392   struct olsr_if           *ind, *in = cnf->interfaces;
 393   struct plugin_entry      *ped, *pe = cnf->plugins;
 394   struct olsr_lq_mult      *mult, *next_mult;
 395
 396   while(h4)
 397     {
 398       h4d = h4;
 399       h4 = h4->next;
 400       free(h4d);
 401     }
 402
 403   while(h6)
 404     {
 405       h6d = h6;
 406       h6 = h6->next;
 407       free(h6d);
 408     }
 409
 410   while(in)
 411     {
 412       for (mult = in->cnf->lq_mult; mult != NULL; mult = next_mult)
 413       {
 414         next_mult = mult->next;
 415         free(mult);
 416       }
 417
 418       free(in->cnf);
 419       ind = in;
 420       in = in->next;
 421       free(ind->name);
 422       free(ind->config);
 423       free(ind);
 424     }
 425
 426   while(pe)
 427     {
 428       ped = pe;
 429       pe = pe->next;
 430       free(ped->name);
 431       free(ped);
 432     }
 433
 434   return;
 435 }
 436
 437
 438
 439 struct olsrd_config *
 440 olsrd_get_default_cnf()
 441 {
 442   cnf = malloc(sizeof(struct olsrd_config));
 443   if (cnf == NULL)
 444     {
 445       fprintf(stderr, "Out of memory %s\n", __func__);
 446       return NULL;
 447   }
 448
 449   set_default_cnf(cnf);
 450
 451   return cnf;
 452 }
 453
 454
 455
 456
 457 void
 458 set_default_cnf(struct olsrd_config *cnf)
 459 {
 460     memset(cnf, 0, sizeof(struct olsrd_config));
 461
 462     cnf->debug_level = DEF_DEBUGLVL;
 463     cnf->ip_version  = AF_INET;
 464     cnf->allow_no_interfaces = DEF_ALLOW_NO_INTS;
 465     cnf->tos = DEF_TOS;
 466     cnf->willingness_auto = DEF_WILL_AUTO;
 467     cnf->ipc_connections = DEF_IPC_CONNECTIONS;
 468     cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
 469
 470     cnf->use_hysteresis = DEF_USE_HYST;
 471     cnf->hysteresis_param.scaling = HYST_SCALING;
 472     cnf->hysteresis_param.thr_high = HYST_THRESHOLD_HIGH;
 473     cnf->hysteresis_param.thr_low = HYST_THRESHOLD_LOW;
 474
 475     cnf->pollrate = DEF_POLLRATE;
 476
 477     cnf->tc_redundancy = TC_REDUNDANCY;
 478     cnf->mpr_coverage = MPR_COVERAGE;
 479     cnf->lq_level = DEF_LQ_LEVEL;
 480     cnf->lq_wsize = DEF_LQ_WSIZE;
 481     cnf->clear_screen = DEF_CLEAR_SCREEN;
 482 }
 483
 484
 485
 486
 487 struct if_config_options *
 488 get_default_if_config()
 489 {
 490   struct if_config_options *io = malloc(sizeof(struct if_config_options));
 491   struct in6_addr in6;
 492
 493   memset(io, 0, sizeof(struct if_config_options));
 494
 495   io->ipv6_addrtype = 1; /* XXX - FixMe */
 496
 497   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6) < 0)
 498     {
 499       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_SITE_LOCAL);
 500       return NULL;
 501     }
 502   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
 503
 504   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6) < 0)
 505     {
 506       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_GLOBAL);
 507       return NULL;
 508     }
 509   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
 510
 511   io->lq_mult = NULL;
 512
 513   io->weight.fixed = OLSR_FALSE;
 514   io->weight.value = 0;
 515
 516   io->hello_params.emission_interval = HELLO_INTERVAL;
 517   io->hello_params.validity_time = NEIGHB_HOLD_TIME;
 518   io->tc_params.emission_interval = TC_INTERVAL;
 519   io->tc_params.validity_time = TOP_HOLD_TIME;
 520   io->mid_params.emission_interval = MID_INTERVAL;
 521   io->mid_params.validity_time = MID_HOLD_TIME;
 522   io->hna_params.emission_interval = HNA_INTERVAL;
 523   io->hna_params.validity_time = HNA_HOLD_TIME;
 524
 525   return io;
 526
 527 }
 528
 529
 530
 531
 532
 533 int
 534 olsrd_write_cnf(struct olsrd_config *cnf, const char *fname)
 535 {
 536   struct hna4_entry        *h4 = cnf->hna4_entries;
 537   struct hna6_entry        *h6 = cnf->hna6_entries;
 538   struct olsr_if           *in = cnf->interfaces;
 539   struct plugin_entry      *pe = cnf->plugins;
 540   struct plugin_param      *pp;
 541   struct ipc_host          *ih = cnf->ipc_hosts;
 542   struct ipc_net           *ie = cnf->ipc_nets;
 543   struct olsr_lq_mult      *mult;
 544
 545   char ipv6_buf[100];             /* buffer for IPv6 inet_htop */
 546   struct in_addr in4;
 547
 548   FILE *fd;
 549
 550   fd = fopen(fname, "w");
 551
 552   if(fd == NULL)
 553     {
 554       fprintf(stderr, "Could not open file %s for writing\n%s\n", fname, strerror(errno));
 555       return -1;
 556     }
 557
 558   printf("Writing config to file \"%s\".... ", fname);
 559
 560   fprintf(fd, "#\n# Configuration file for olsr.org olsrd\n# automatically generated by olsrd-cnf %s\n#\n\n\n", PARSER_VERSION);
 561
 562   /* Debug level */
 563   fprintf(fd, "# Debug level(0-9)\n# If set to 0 the daemon runs in the background\n\nDebugLevel\t%d\n\n", cnf->debug_level);
 564
 565   /* IP version */
 566   if(cnf->ip_version == AF_INET6)
 567     fprintf(fd, "# IP version to use (4 or 6)\n\nIpVersion\t6\n\n");
 568   else
 569     fprintf(fd, "# IP version to use (4 or 6)\n\nIpVersion\t4\n\n");
 570
 571
 572   /* HNA IPv4 */
 573   fprintf(fd, "# HNA IPv4 routes\n# syntax: netaddr netmask\n# Example Internet gateway:\n# 0.0.0.0 0.0.0.0\n\nHna4\n{\n");
 574   while(h4)
 575     {
 576       in4.s_addr = h4->net.v4;
 577       fprintf(fd, "    %s ", inet_ntoa(in4));
 578       in4.s_addr = h4->netmask.v4;
 579       fprintf(fd, "%s\n", inet_ntoa(in4));
 580       h4 = h4->next;
 581     }
 582   fprintf(fd, "}\n\n");
 583
 584
 585   /* HNA IPv6 */
 586   fprintf(fd, "# HNA IPv6 routes\n# syntax: netaddr prefix\n# Example Internet gateway:\nHna6\n{\n");
 587   while(h6)
 588     {
 589       fprintf(fd, "    %s/%d\n", (char *)inet_ntop(AF_INET6, &h6->net.v6, ipv6_buf, sizeof(ipv6_buf)), h6->prefix_len);
 590       h6 = h6->next;
 591     }
 592
 593   fprintf(fd, "}\n\n");
 594
 595   /* No interfaces */
 596   fprintf(fd, "# Should olsrd keep on running even if there are\n# no interfaces available? This is a good idea\n# for a PCMCIA/USB hotswap environment.\n# \"yes\" OR \"no\"\n\nAllowNoInt\t");
 597   if(cnf->allow_no_interfaces)
 598     fprintf(fd, "yes\n\n");
 599   else
 600     fprintf(fd, "no\n\n");
 601
 602   /* TOS */
 603   fprintf(fd, "# TOS(type of service) value for\n# the IP header of control traffic.\n# default is 16\n\n");
 604   fprintf(fd, "TosValue\t%d\n\n", cnf->tos);
 605
 606   /* Willingness */
 607   fprintf(fd, "# The fixed willingness to use(0-7)\n# If not set willingness will be calculated\n# dynammically based on battery/power status\n\n");
 608   if(cnf->willingness_auto)
 609     fprintf(fd, "#Willingness\t4\n\n");
 610   else
 611     fprintf(fd, "Willingness%d\n\n", cnf->willingness);
 612
 613   /* IPC */
 614   fprintf(fd, "# Allow processes like the GUI front-end\n# to connect to the daemon.\n\n");
 615   fprintf(fd, "IpcConnect\n{\n");
 616   fprintf(fd, "   MaxConnections  %d\n\n", cnf->ipc_connections);
 617
 618   while(ih)
 619     {
 620       in4.s_addr = ih->host.v4;
 621       fprintf(fd, "   Host          %s\n", inet_ntoa(in4));
 622       ih = ih->next;
 623     }
 624   fprintf(fd, "\n");
 625   while(ie)
 626     {
 627       in4.s_addr = ie->net.v4;
 628       fprintf(fd, "   Net           %s ", inet_ntoa(in4));
 629       in4.s_addr = ie->mask.v4;
 630       fprintf(fd, "%s\n", inet_ntoa(in4));
 631       ie = ie->next;
 632     }
 633
 634   fprintf(fd, "}\n\n");
 635
 636
 637
 638   /* Hysteresis */
 639   fprintf(fd, "# Wether to use hysteresis or not\n# Hysteresis adds more robustness to the\n# link sensing but delays neighbor registration.\n# Used by default. 'yes' or 'no'\n\n");
 640
 641   if(cnf->use_hysteresis)
 642     {
 643       fprintf(fd, "UseHysteresis\tyes\n\n");
 644       fprintf(fd, "# Hysteresis parameters\n# Do not alter these unless you know \n# what you are doing!\n# Set to auto by default. Allowed\n# values are floating point values\n# in the interval 0,1\n# THR_LOW must always be lower than\n# THR_HIGH!!\n\n");
 645       fprintf(fd, "HystScaling\t%0.2f\n", cnf->hysteresis_param.scaling);
 646       fprintf(fd, "HystThrHigh\t%0.2f\n", cnf->hysteresis_param.thr_high);
 647       fprintf(fd, "HystThrLow\t%0.2f\n", cnf->hysteresis_param.thr_low);
 648     }
 649   else
 650     fprintf(fd, "UseHysteresis\tno\n\n");
 651
 652   fprintf(fd, "\n\n");
 653
 654   /* Pollrate */
 655   fprintf(fd, "# Polling rate in seconds(float).\n# Auto uses default value 0.05 sec\n\n");
 656   fprintf(fd, "Pollrate\t%0.2f\n", cnf->pollrate);
 657
 658   /* TC redundancy */
 659   fprintf(fd, "# TC redundancy\n# Specifies how much neighbor info should\n# be sent in TC messages\n# Possible values are:\n# 0 - only send MPR selectors\n# 1 - send MPR selectors and MPRs\n# 2 - send all neighbors\n#\n# defaults to 0\n\n");
 660   fprintf(fd, "TcRedundancy\t%d\n\n", cnf->tc_redundancy);
 661
 662   /* MPR coverage */
 663   fprintf(fd, "# MPR coverage\n# Specifies how many MPRs a node should\n# try select to reach every 2 hop neighbor\n# Can be set to any integer >0\n# defaults to 1\n\n");
 664
 665   fprintf(fd, "MprCoverage\t%d\n\n", cnf->mpr_coverage);
 666
 667   fprintf(fd, "# Link quality level\n# 0 = do not use link quality\n# 1 = use link quality for MPR selection\n# 2 = use link quality for MPR selection and routing\n\n");
 668   fprintf(fd, "LinkQualityLevel\t%d\n\n", cnf->lq_level);
 669
 670   fprintf(fd, "# Link quality window size\n\n");
 671   fprintf(fd, "LinkQualityWinSize\t%d\n\n", cnf->lq_wsize);
 672
 673   fprintf(fd, "# Clear screen when printing debug output?\n\n");
 674   fprintf(fd, "ClearScreen\t%s\n\n", cnf->clear_screen ? "yes" : "no");
 675
 676   /* Plugins */
 677   fprintf(fd, "# Olsrd plugins to load\n# This must be the absolute path to the file\n# or the loader will use the following scheme:\n# - Try the paths in the LD_LIBRARY_PATH \n#   environment variable.\n# - The list of libraries cached in /etc/ld.so.cache\n# - /lib, followed by /usr/lib\n\n");
 678   if(pe)
 679     {
 680       while(pe)
 681         {
 682           fprintf(fd, "LoadPlugin \"%s\"\n{\n", pe->name);
 683           pp = pe->params;
 684           while(pp)
 685             {
 686               fprintf(fd, "    PlParam \"%s\" \"%s\"\n", pp->key, pp->value);
 687               pp = pp->next;
 688             }
 689           fprintf(fd, "}\n");
 690           pe = pe->next;
 691         }
 692     }
 693   fprintf(fd, "\n");
 694
 695
 696
 697
 698   /* Interfaces */
 699   fprintf(fd, "# Interfaces\n\n");
 700   /* Interfaces */
 701   if(in)
 702     {
 703       while(in)
 704         {
 705           fprintf(fd, "Interface \"%s\"\n{\n", in->name);
 706           fprintf(fd, "\n");
 707
 708           fprintf(fd, "    # IPv4 broadcast address to use. The\n    # one usefull example would be 255.255.255.255\n    # If not defined the broadcastaddress\n    # every card is configured with is used\n\n");
 709
 710           if(in->cnf->ipv4_broadcast.v4)
 711             {
 712               in4.s_addr = in->cnf->ipv4_broadcast.v4;
 713               fprintf(fd, "    Ip4Broadcast\t %s\n\n", inet_ntoa(in4));
 714             }
 715           else
 716             {
 717               fprintf(fd, "    #Ip4Broadcast\t255.255.255.255\n\n");
 718             }
 719
 720
 721           fprintf(fd, "    # IPv6 address scope to use.\n    # Must be 'site-local' or 'global'\n\n");
 722           if(in->cnf->ipv6_addrtype)
 723             fprintf(fd, "    Ip6AddrType \tsite-local\n\n");
 724           else
 725             fprintf(fd, "    Ip6AddrType \tglobal\n\n");
 726
 727           fprintf(fd, "    # IPv6 multicast address to use when\n    # using site-local addresses.\n    # If not defined, ff05::15 is used\n");
 728           fprintf(fd, "    Ip6MulticastSite\t%s\n\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_site.v6, ipv6_buf, sizeof(ipv6_buf)));
 729           fprintf(fd, "    # IPv6 multicast address to use when\n    # using global addresses\n    # If not defined, ff0e::1 is used\n");
 730           fprintf(fd, "    Ip6MulticastGlobal\t%s\n\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_glbl.v6, ipv6_buf, sizeof(ipv6_buf)));
 731
 732
 733
 734           fprintf(fd, "    # Emission and validity intervals.\n    # If not defined, RFC proposed values will\n    # in most cases be used.\n\n");
 735
 736
 737           if(in->cnf->hello_params.emission_interval != HELLO_INTERVAL)
 738             fprintf(fd, "    HelloInterval\t%0.2f\n", in->cnf->hello_params.emission_interval);
 739           else
 740             fprintf(fd, "    #HelloInterval\t%0.2f\n", in->cnf->hello_params.emission_interval);
 741           if(in->cnf->hello_params.validity_time != NEIGHB_HOLD_TIME)
 742             fprintf(fd, "    HelloValidityTime\t%0.2f\n", in->cnf->hello_params.validity_time);
 743           else
 744             fprintf(fd, "    #HelloValidityTime\t%0.2f\n", in->cnf->hello_params.validity_time);
 745           if(in->cnf->tc_params.emission_interval != TC_INTERVAL)
 746             fprintf(fd, "    TcInterval\t\t%0.2f\n", in->cnf->tc_params.emission_interval);
 747           else
 748             fprintf(fd, "    #TcInterval\t\t%0.2f\n", in->cnf->tc_params.emission_interval);
 749           if(in->cnf->tc_params.validity_time != TOP_HOLD_TIME)
 750             fprintf(fd, "    TcValidityTime\t%0.2f\n", in->cnf->tc_params.validity_time);
 751           else
 752             fprintf(fd, "    #TcValidityTime\t%0.2f\n", in->cnf->tc_params.validity_time);
 753           if(in->cnf->mid_params.emission_interval != MID_INTERVAL)
 754             fprintf(fd, "    MidInterval\t\t%0.2f\n", in->cnf->mid_params.emission_interval);
 755           else
 756             fprintf(fd, "    #MidInterval\t%0.2f\n", in->cnf->mid_params.emission_interval);
 757           if(in->cnf->mid_params.validity_time != MID_HOLD_TIME)
 758             fprintf(fd, "    MidValidityTime\t%0.2f\n", in->cnf->mid_params.validity_time);
 759           else
 760             fprintf(fd, "    #MidValidityTime\t%0.2f\n", in->cnf->mid_params.validity_time);
 761           if(in->cnf->hna_params.emission_interval != HNA_INTERVAL)
 762             fprintf(fd, "    HnaInterval\t\t%0.2f\n", in->cnf->hna_params.emission_interval);
 763           else
 764             fprintf(fd, "    #HnaInterval\t%0.2f\n", in->cnf->hna_params.emission_interval);
 765           if(in->cnf->hna_params.validity_time != HNA_HOLD_TIME)
 766             fprintf(fd, "    HnaValidityTime\t%0.2f\n", in->cnf->hna_params.validity_time);
 767           else
 768             fprintf(fd, "    #HnaValidityTime\t%0.2f\n", in->cnf->hna_params.validity_time);
 769
 770           mult = in->cnf->lq_mult;
 771
 772           if (mult == NULL)
 773             fprintf(fd, "    #LinkQualityMult\tdefault 1.0\n");
 774
 775           else
 776           {
 777             while (mult != NULL)
 778             {
 779               inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf,
 780                         sizeof (ipv6_buf));
 781
 782               fprintf(fd, "    LinkQualityMult\t%s %0.2f\n",
 783                       ipv6_buf, mult->val);
 784
 785               mult = mult->next;
 786             }
 787           }
 788
 789           fprintf(fd, "}\n\n");
 790           in = in->next;
 791         }
 792
 793     }
 794
 795
 796   fprintf(fd, "\n# END AUTOGENERATED CONFIG\n");
 797
 798   fclose(fd);
 799   printf("DONE\n");
 800
 801   return 1;
 802 }
 803
 804
 805
 806
 807
 808 void
 809 olsrd_print_cnf(struct olsrd_config *cnf)
 810 {
 811   struct hna4_entry        *h4 = cnf->hna4_entries;
 812   struct hna6_entry        *h6 = cnf->hna6_entries;
 813   struct olsr_if           *in = cnf->interfaces;
 814   struct plugin_entry      *pe = cnf->plugins;
 815   struct ipc_host          *ih = cnf->ipc_hosts;
 816   struct ipc_net           *ie = cnf->ipc_nets;
 817   struct olsr_lq_mult      *mult;
 818   char ipv6_buf[100];             /* buffer for IPv6 inet_htop */
 819   struct in_addr in4;
 820
 821   printf(" *** olsrd configuration ***\n");
 822
 823   printf("Debug Level      : %d\n", cnf->debug_level);
 824   if(cnf->ip_version == AF_INET6)
 825     printf("IpVersion        : 6\n");
 826   else
 827     printf("IpVersion        : 4\n");
 828   if(cnf->allow_no_interfaces)
 829     printf("No interfaces    : ALLOWED\n");
 830   else
 831     printf("No interfaces    : NOT ALLOWED\n");
 832   printf("TOS              : 0x%02x\n", cnf->tos);
 833   if(cnf->willingness_auto)
 834     printf("Willingness      : AUTO\n");
 835   else
 836     printf("Willingness      : %d\n", cnf->willingness);
 837
 838   printf("IPC connections  : %d\n", cnf->ipc_connections);
 839
 840   while(ih)
 841     {
 842       in4.s_addr = ih->host.v4;
 843       printf("\tHost %s\n", inet_ntoa(in4));
 844       ih = ih->next;
 845     }
 846
 847   while(ie)
 848     {
 849       in4.s_addr = ie->net.v4;
 850       printf("\tNet %s/", inet_ntoa(in4));
 851       in4.s_addr = ie->mask.v4;
 852       printf("%s\n", inet_ntoa(in4));
 853       ie = ie->next;
 854     }
 855
 856
 857   printf("Pollrate         : %0.2f\n", cnf->pollrate);
 858
 859   printf("TC redundancy    : %d\n", cnf->tc_redundancy);
 860
 861   printf("MPR coverage     : %d\n", cnf->mpr_coverage);
 862
 863   printf("LQ level         : %d\n", cnf->lq_level);
 864
 865   printf("LQ window size   : %d\n", cnf->lq_wsize);
 866
 867   printf("Clear screen     : %s\n", cnf->clear_screen ? "yes" : "no");
 868
 869   /* Interfaces */
 870   if(in)
 871     {
 872       printf("Interfaces:\n");
 873       while(in)
 874         {
 875           printf(" dev: \"%s\"\n", in->name);
 876
 877           if(in->cnf->ipv4_broadcast.v4)
 878             {
 879               in4.s_addr = in->cnf->ipv4_broadcast.v4;
 880               printf("\tIPv4 broadcast           : %s\n", inet_ntoa(in4));
 881             }
 882           else
 883             {
 884               printf("\tIPv4 broadcast           : AUTO\n");
 885             }
 886
 887           if(in->cnf->ipv6_addrtype)
 888             printf("\tIPv6 addrtype            : %s\n", in->cnf->ipv6_addrtype ? "site-local" : "global");
 889
 890           //union olsr_ip_addr       ipv6_multi_site;
 891           //union olsr_ip_addr       ipv6_multi_glbl;
 892           printf("\tIPv6 multicast site/glbl : %s", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_site.v6, ipv6_buf, sizeof(ipv6_buf)));
 893           printf("/%s\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_glbl.v6, ipv6_buf, sizeof(ipv6_buf)));
 894
 895           printf("\tHELLO emission/validity  : %0.2f/%0.2f\n", in->cnf->hello_params.emission_interval, in->cnf->hello_params.validity_time);
 896           printf("\tTC emission/validity     : %0.2f/%0.2f\n", in->cnf->tc_params.emission_interval, in->cnf->tc_params.validity_time);
 897           printf("\tMID emission/validity    : %0.2f/%0.2f\n", in->cnf->mid_params.emission_interval, in->cnf->mid_params.validity_time);
 898           printf("\tHNA emission/validity    : %0.2f/%0.2f\n", in->cnf->hna_params.emission_interval, in->cnf->hna_params.validity_time);
 899
 900           for (mult = in->cnf->lq_mult; mult != NULL; mult = mult->next)
 901           {
 902             inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf,
 903                       sizeof (ipv6_buf));
 904
 905             printf("\tLinkQualityMult          : %s %0.2f\n",
 906                    ipv6_buf, mult->val);
 907           }
 908
 909           in = in->next;
 910         }
 911     }
 912
 913
 914
 915
 916   /* Plugins */
 917   if(pe)
 918     {
 919       printf("Plugins:\n");
 920
 921       while(pe)
 922         {
 923           printf("\tName: \"%s\"\n", pe->name);
 924           pe = pe->next;
 925         }
 926     }
 927
 928   /* Hysteresis */
 929   if(cnf->use_hysteresis)
 930     {
 931       printf("Using hysteresis:\n");
 932       printf("\tScaling      : %0.2f\n", cnf->hysteresis_param.scaling);
 933       printf("\tThr high/low : %0.2f/%0.2f\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
 934     }
 935   else
 936     printf("Not using hysteresis\n");
 937
 938   /* HNA IPv4 */
 939   if(h4)
 940     {
 941
 942       printf("HNA4 entries:\n");
 943       while(h4)
 944         {
 945           in4.s_addr = h4->net.v4;
 946           printf("\t%s/", inet_ntoa(in4));
 947           in4.s_addr = h4->netmask.v4;
 948           printf("%s\n", inet_ntoa(in4));
 949
 950           h4 = h4->next;
 951         }
 952     }
 953
 954   /* HNA IPv6 */
 955   if(h6)
 956     {
 957       printf("HNA6 entries:\n");
 958       while(h6)
 959         {
 960           printf("\t%s/%d\n", (char *)inet_ntop(AF_INET6, &h6->net.v6, ipv6_buf, sizeof(ipv6_buf)), h6->prefix_len);
 961           h6 = h6->next;
 962         }
 963     }
 964 }
 965
 966 void *olsrd_cnf_malloc(unsigned int len)
 967 {
 968   return malloc(len);
 969 }
 970
 971 void olsrd_cnf_free(void *addr)
 972 {
 973   free(addr);
 974 }
 975
 976 #if defined WIN32_STDIO_HACK
 977 struct ioinfo
 978 {
 979         unsigned int handle;
 980         unsigned char attr;
 981         char buff;
 982         int flag;
 983         CRITICAL_SECTION lock;
 984 };
 985
 986 void win32_stdio_hack(unsigned int handle)
 987 {
 988   HMODULE lib;
 989   struct ioinfo **info;
 990
 991   lib = LoadLibrary("msvcrt.dll");
 992
 993   info = (struct ioinfo **)GetProcAddress(lib, "__pioinfo");
 994
 995   // (*info)[1].handle = handle;
 996   // (*info)[1].attr = 0x89; // FOPEN | FTEXT | FPIPE;
 997
 998   (*info)[2].handle = handle;
 999   (*info)[2].attr = 0x89;
1000
1001   // stdout->_file = 1;
1002   stderr->_file = 2;
1003
1004   // setbuf(stdout, NULL);
1005   setbuf(stderr, NULL);
1006 }
1007 #else
1008 void win32_stdio_hack(unsigned int handle) {}
1009 #endif