src/main.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004, Andreas Tonnesen(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  */
  40
  41 #include <arpa/inet.h>
  42 #include <unistd.h>
  43 #include <signal.h>
  44 #include <sys/stat.h>
  45 #include <assert.h>
  46 #include <fcntl.h>
  47
  48 #include "cfgparser/olsrd_conf.h"
  49 #include "ipcalc.h"
  50 #include "defs.h"
  51 #include "builddata.h"
  52 #include "olsr.h"
  53 #include "log.h"
  54 #include "scheduler.h"
  55 #include "parser.h"
  56 #include "generate_msg.h"
  57 #include "plugin_loader.h"
  58 #include "apm.h"
  59 #include "net_os.h"
  60 #include "build_msg.h"
  61 #include "net_olsr.h"
  62 #include "mid_set.h"
  63 #include "mpr_selector_set.h"
  64 #include "gateway.h"
  65 #include "olsr_niit.h"
  66 #include "olsr_random.h"
  67 #include "pid_file.h"
  68 #include "lock_file.h"
  69 #include "cli.h"
  70
  71 #ifdef __linux__
  72 #include <linux/types.h>
  73 #include <linux/rtnetlink.h>
  74 #include "kernel_routes.h"
  75
  76 #endif /* __linux__ */
  77
  78 #ifdef _WIN32
  79 #include <process.h>
  80 #include <winbase.h>
  81 #define olsr_shutdown(x) SignalHandler(x)
  82 #define close(x) closesocket(x)
  83 int __stdcall SignalHandler(unsigned long signo) __attribute__ ((noreturn));
  84 void DisableIcmpRedirects(void);
  85 #endif /* _WIN32 */
  86
  87 struct timer_entry * heartBeatTimer = NULL;
  88
  89 static char **olsr_argv = NULL;
  90
  91 struct olsr_cookie_info *def_timer_ci = NULL;
  92
  93 #ifndef _WIN32
  94 /**
  95  * Reconfigure olsrd. Currently kind of a hack...
  96  *
  97  *@param signo the signal that triggered this callback
  98  */
  99 static void olsr_reconfigure(int signo __attribute__ ((unused))) {
 100 #ifndef _WIN32
 101   int errNr = errno;
 102 #endif
 103   /* if we are started with -nofork, we do not want to go into the
 104    * background here. So we can simply stop on -HUP
 105    */
 106   olsr_syslog(OLSR_LOG_INFO, "sot: olsr_reconfigure()\n");
 107   if (!olsr_cnf->no_fork) {
 108     if (!fork()) {
 109       int i;
 110       sigset_t sigs;
 111
 112       /* New process, wait a bit to let the old process exit */
 113       sleep(3);
 114       sigemptyset(&sigs);
 115       sigaddset(&sigs, SIGHUP);
 116       sigprocmask(SIG_UNBLOCK, &sigs, NULL);
 117       for (i = sysconf(_SC_OPEN_MAX); --i > STDERR_FILENO;) {
 118         close(i);
 119       }
 120       printf("Restarting %s", olsr_argv[0]);
 121       olsr_syslog(OLSR_LOG_INFO, "Restarting %s", olsr_argv[0]);
 122       execv(olsr_argv[0], olsr_argv);
 123       olsr_syslog(OLSR_LOG_ERR, "execv(%s) failed: %s", olsr_argv[0], strerror(errno));
 124     } else {
 125       olsr_syslog(OLSR_LOG_INFO, "RECONFIGURING");
 126     }
 127   }
 128 #ifndef _WIN32
 129   errno = errNr;
 130 #endif
 131   olsr_exit(NULL, EXIT_SUCCESS);
 132 }
 133 #endif /* _WIN32 */
 134
 135 static void olsr_shutdown_messages(void) {
 136   struct interface_olsr *ifn;
 137
 138   /* send TC reset */
 139   for (ifn = ifnet; ifn; ifn = ifn->int_next) {
 140     /* clean output buffer */
 141     net_output(ifn);
 142
 143     /* send 'I'm gone' messages */
 144     if (olsr_cnf->lq_level > 0) {
 145       olsr_output_lq_tc(ifn);
 146       olsr_output_lq_hello(ifn);
 147     } else {
 148       generate_tc(ifn);
 149       generate_hello(ifn);
 150     }
 151     net_output(ifn);
 152   }
 153 }
 154
 155 /**
 156  *Function called at shutdown. Signal handler
 157  *
 158  * @param signo the signal that triggered this call
 159  */
 160 #ifdef _WIN32
 161 int __stdcall
 162 SignalHandler(unsigned long signo)
 163 #else /* _WIN32 */
 164 static void olsr_shutdown(int signo __attribute__ ((unused)))
 165 #endif /* _WIN32 */
 166 {
 167 #ifndef _WIN32
 168   int errNr = errno;
 169 #endif
 170   struct interface_olsr *ifn;
 171   int exit_value;
 172
 173   OLSR_PRINTF(1, "Received signal %d - shutting down\n", (int)signo);
 174
 175   /* instruct the scheduler to stop */
 176   olsr_scheduler_stop();
 177
 178   /* clear all links and send empty hellos/tcs */
 179   olsr_reset_all_links();
 180
 181   /* deactivate fisheye and immediate TCs */
 182   olsr_cnf->lq_fish = 0;
 183   for (ifn = ifnet; ifn; ifn = ifn->int_next) {
 184     ifn->immediate_send_tc = false;
 185   }
 186   increase_local_ansn();
 187
 188   /* send first shutdown message burst */
 189   olsr_shutdown_messages();
 190
 191   /* delete all routes */
 192   olsr_delete_all_kernel_routes();
 193
 194   /* send second shutdown message burst */
 195   olsr_shutdown_messages();
 196
 197   /* now try to cleanup the rest of the mess */
 198   olsr_delete_all_tc_entries();
 199
 200   olsr_delete_all_mid_entries();
 201
 202 #ifdef __linux__
 203   /* trigger gateway selection */
 204   if (olsr_cnf->smart_gw_active) {
 205     olsr_shutdown_gateways();
 206     olsr_cleanup_gateways();
 207   }
 208
 209   /* trigger niit static route cleanup */
 210   if (olsr_cnf->use_niit) {
 211     olsr_cleanup_niit_routes();
 212   }
 213
 214   /* cleanup lo:olsr interface */
 215   if (olsr_cnf->use_src_ip_routes) {
 216     olsr_os_localhost_if(&olsr_cnf->main_addr, false);
 217   }
 218 #endif /* __linux__ */
 219
 220   olsr_destroy_parser();
 221
 222   OLSR_PRINTF(1, "Closing sockets...\n");
 223
 224   /* front-end IPC socket */
 225   if (olsr_cnf->ipc_connections > 0) {
 226     shutdown_ipc();
 227   }
 228
 229   /* OLSR sockets */
 230   for (ifn = ifnet; ifn; ifn = ifn->int_next) {
 231     close(ifn->olsr_socket);
 232     close(ifn->send_socket);
 233
 234 #ifdef __linux__
 235     if (DEF_RT_NONE != olsr_cnf->rt_table_defaultolsr_pri) {
 236       olsr_os_policy_rule(olsr_cnf->ip_version, olsr_cnf->rt_table_default,
 237           olsr_cnf->rt_table_defaultolsr_pri, ifn->int_name, false);
 238     }
 239 #endif /* __linux__ */
 240   }
 241
 242   /* Closing plug-ins */
 243   olsr_close_plugins();
 244
 245   /* Reset network settings */
 246   net_os_restore_ifoptions();
 247
 248   /* ioctl socket */
 249   close(olsr_cnf->ioctl_s);
 250
 251 #ifdef __linux__
 252   if (DEF_RT_NONE != olsr_cnf->rt_table_pri) {
 253     olsr_os_policy_rule(olsr_cnf->ip_version,
 254         olsr_cnf->rt_table, olsr_cnf->rt_table_pri, NULL, false);
 255   }
 256   if (DEF_RT_NONE != olsr_cnf->rt_table_tunnel_pri) {
 257     olsr_os_policy_rule(olsr_cnf->ip_version,
 258         olsr_cnf->rt_table_tunnel, olsr_cnf->rt_table_tunnel_pri, NULL, false);
 259   }
 260   if (DEF_RT_NONE != olsr_cnf->rt_table_default_pri) {
 261     olsr_os_policy_rule(olsr_cnf->ip_version,
 262         olsr_cnf->rt_table_default, olsr_cnf->rt_table_default_pri, NULL, false);
 263   }
 264   close(olsr_cnf->rtnl_s);
 265   close (olsr_cnf->rt_monitor_socket);
 266 #endif /* __linux__ */
 267
 268 #if defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__
 269   /* routing socket */
 270   close(olsr_cnf->rts);
 271 #endif /* defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__ */
 272
 273   /* remove the lock file */
 274   olsr_remove_lock_file();
 275
 276   /* stop heartbeat that is showing on stdout */
 277 #if !defined WINCE
 278   if (heartBeatTimer) {
 279     olsr_stop_timer(heartBeatTimer);
 280     heartBeatTimer = NULL;
 281   }
 282 #endif /* !defined WINCE */
 283
 284   /* Free cookies and memory pools attached. */
 285   OLSR_PRINTF(0, "Free all memory...\n");
 286   olsr_delete_all_cookies();
 287
 288   olsr_syslog(OLSR_LOG_INFO, "%s stopped", olsrd_version);
 289
 290   OLSR_PRINTF(1, "\n <<<< %s - terminating >>>>\n           http://www.olsr.org\n", olsrd_version);
 291
 292   exit_value = olsr_cnf->exit_value;
 293   olsrd_free_cnf(&olsr_cnf);
 294
 295   /* close the log */
 296   olsr_closelog();
 297
 298 #ifndef _WIN32
 299   errno = errNr;
 300 #endif
 301   exit(exit_value);
 302 }
 303
 304 /**
 305  * Sets the provided configuration on all unconfigured
 306  * interfaces
 307  *
 308  * @param ifs a linked list of interfaces to check and possible update
 309  * @param cnf the default configuration to set on unconfigured interfaces
 310  */
 311 static int set_default_ifcnfs(struct olsr_if *ifs, struct if_config_options *cnf) {
 312   int changes = 0;
 313
 314   while (ifs) {
 315     if (ifs->cnf == NULL) {
 316       ifs->cnf = olsr_malloc(sizeof(struct if_config_options),
 317           "Set default config");
 318       *ifs->cnf = *cnf;
 319       changes++;
 320     }
 321     ifs = ifs->next;
 322   }
 323   return changes;
 324 }
 325
 326 /**
 327  * Main entrypoint
 328  */
 329
 330 int main(int argc, char *argv[]) {
 331   int argcLocal = argc;
 332
 333   /* Open syslog */
 334   olsr_openlog("olsrd");
 335
 336   /*
 337    * Initialisation
 338    */
 339
 340   /* setup debug printf destination */
 341   debug_handle = stdout;
 342
 343   /* set stdout and stderr to unbuffered output */
 344   setbuf(stdout, NULL);
 345   setbuf(stderr, NULL);
 346
 347   /* setup random seed */
 348   srandom(time(NULL));
 349
 350   /* Init widely used statics */
 351   memset(&all_zero, 0, sizeof(union olsr_ip_addr));
 352
 353   /* store the arguments for restart */
 354   olsr_argv = argv;
 355
 356   /*
 357    * Start
 358    */
 359
 360   print_version();
 361
 362   if (argcLocal == 2) {
 363     if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "/?")) {
 364       /* help */
 365       print_usage(false);
 366       olsr_exit(NULL, EXIT_SUCCESS);
 367     }
 368     if (!strcmp(argv[1], "-v")) {
 369       /* version */
 370       olsr_exit(NULL, EXIT_SUCCESS);
 371     }
 372   }
 373
 374   /* Check root Privileges */
 375 #ifndef _WIN32
 376   if (geteuid()) {
 377     olsr_exit("You must be root (uid = 0) to run olsrd", EXIT_FAILURE);
 378   }
 379 #else /* _WIN32 */
 380   DisableIcmpRedirects();
 381
 382   {
 383     WSADATA WsaData;
 384     if (WSAStartup(0x0202, &WsaData)) {
 385       char buf2[1024];
 386       snprintf(buf2, sizeof(buf2), "%s: Could not initialise WinSock", __func__);
 387       olsr_exit(buf2, EXIT_FAILURE);
 388     }
 389   }
 390 #endif /* _WIN32 */
 391
 392   /* load the configuration */
 393   if (!loadConfig(&argcLocal, argv)) {
 394     olsr_exit(NULL, EXIT_FAILURE);
 395   }
 396
 397   /* Process CLI Arguments */
 398   {
 399     char * error = NULL;
 400     int exitCode = EXIT_FAILURE;
 401
 402     /* get the default interface config */
 403     struct if_config_options *default_ifcnf = get_default_if_config();
 404     if (!default_ifcnf) {
 405       olsr_exit("No default ifconfig found", EXIT_FAILURE);
 406     }
 407
 408     /* Process olsrd options */
 409     exitCode = olsr_process_arguments(argcLocal, argv, olsr_cnf, default_ifcnf, &error);
 410     if (exitCode != 0) {
 411       free(default_ifcnf);
 412       olsr_exit(error, EXIT_FAILURE);
 413     }
 414
 415     /* Set configuration for command-line specified interfaces */
 416     set_default_ifcnfs(olsr_cnf->interfaces, default_ifcnf);
 417
 418     /* free the default ifcnf */
 419     free(default_ifcnf);
 420   }
 421
 422   /* Sanity check configuration */
 423   if (olsrd_sanity_check_cnf(olsr_cnf) < 0) {
 424     char buf2[1024];
 425     snprintf(buf2, sizeof(buf2), "%s: Bad configuration", __func__);
 426     olsr_exit(buf2, EXIT_FAILURE);
 427   }
 428
 429   /* Setup derived configuration */
 430   set_derived_cnf(olsr_cnf);
 431
 432   /* Print configuration */
 433   if (olsr_cnf->debug_level > 1) {
 434     olsrd_print_cnf(olsr_cnf);
 435   }
 436
 437   /* configuration loaded and sane */
 438
 439   /* initialise timers */
 440   olsr_init_timers();
 441
 442   def_timer_ci = olsr_alloc_cookie("Default Timer Cookie", OLSR_COOKIE_TYPE_TIMER);
 443
 444   /* create a socket for ioctl calls */
 445   olsr_cnf->ioctl_s = socket(olsr_cnf->ip_version, SOCK_DGRAM, 0);
 446   if (olsr_cnf->ioctl_s < 0) {
 447     char buf2[1024];
 448     snprintf(buf2, sizeof(buf2), "ioctl socket: %s", strerror(errno));
 449     olsr_exit(buf2, EXIT_FAILURE);
 450   }
 451
 452   /* create a socket for netlink calls */
 453 #ifdef __linux__
 454   olsr_cnf->rtnl_s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
 455   if (olsr_cnf->rtnl_s < 0) {
 456     char buf2[1024];
 457     snprintf(buf2, sizeof(buf2), "rtnetlink socket: %s", strerror(errno));
 458     olsr_exit(buf2, EXIT_FAILURE);
 459   }
 460
 461   if (fcntl(olsr_cnf->rtnl_s, F_SETFL, O_NONBLOCK)) {
 462     olsr_syslog(OLSR_LOG_INFO, "rtnetlink could not be set to nonblocking");
 463   }
 464
 465   if ((olsr_cnf->rt_monitor_socket = rtnetlink_register_socket(RTMGRP_LINK)) < 0) {
 466     char buf2[1024];
 467     snprintf(buf2, sizeof(buf2), "rtmonitor socket: %s", strerror(errno));
 468     olsr_exit(buf2, EXIT_FAILURE);
 469   }
 470 #endif /* __linux__ */
 471
 472   /* create routing socket */
 473 #if defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__
 474   olsr_cnf->rts = socket(PF_ROUTE, SOCK_RAW, 0);
 475   if (olsr_cnf->rts < 0) {
 476     char buf2[1024];
 477     snprintf(buf2, sizeof(buf2), "routing socket: %s", strerror(errno));
 478     olsr_exit(buf2, EXIT_FAILURE);
 479   }
 480 #endif /* defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__ */
 481
 482   /* initialise gateway system */
 483 #ifdef __linux__
 484   if (olsr_cnf->smart_gw_active && olsr_init_gateways()) {
 485     olsr_exit("Cannot initialise gateway tunnels", EXIT_FAILURE);
 486   }
 487 #endif /* __linux__ */
 488
 489   /* initialise niit if index */
 490 #ifdef __linux__
 491   if (olsr_cnf->use_niit) {
 492     olsr_init_niit();
 493   }
 494 #endif /* __linux__ */
 495
 496   /* initialise empty TC timer */
 497   set_empty_tc_timer(GET_TIMESTAMP(0));
 498
 499   /* enable ip forwarding on host and disable redirects globally (not for WIN32) */
 500   net_os_set_global_ifoptions();
 501
 502   /* initialise parser */
 503   olsr_init_parser();
 504
 505   /* initialise route exporter */
 506   olsr_init_export_route();
 507
 508   /* initialise message sequence number */
 509   init_msg_seqno();
 510
 511   /* initialise dynamic willingness calculation */
 512   olsr_init_willingness();
 513
 514   /* Set up willingness/APM */
 515   if (olsr_cnf->willingness_auto) {
 516     if (apm_init() < 0) {
 517       OLSR_PRINTF(1, "Could not read APM info - setting default willingness(%d)\n", WILL_DEFAULT);
 518
 519       olsr_syslog(OLSR_LOG_ERR, "Could not read APM info - setting default willingness(%d)\n",
 520       WILL_DEFAULT);
 521
 522       olsr_cnf->willingness_auto = 0;
 523       olsr_cnf->willingness = WILL_DEFAULT;
 524     } else {
 525       olsr_cnf->willingness = olsr_calculate_willingness();
 526
 527       OLSR_PRINTF(1, "Willingness set to %d - next update in %.1f secs\n", olsr_cnf->willingness, (double )olsr_cnf->will_int);
 528     }
 529   }
 530
 531   /* initialise net */
 532   init_net();
 533
 534   /* initialise network interfaces */
 535   if (!olsr_init_interfacedb()) {
 536     if (olsr_cnf->allow_no_interfaces) {
 537       fprintf( stderr, "No interfaces detected! This might be intentional, but it also might mean"
 538           " that your configuration is fubar.\nI will continue after 5 seconds...\n");
 539       olsr_startup_sleep(5);
 540     } else {
 541       char buf2[1024];
 542       snprintf(buf2, sizeof(buf2), "%s: No interfaces detected", __func__);
 543       olsr_exit(buf2, EXIT_FAILURE);
 544     }
 545   }
 546
 547 #ifdef __linux__
 548   /* startup gateway system */
 549   if (olsr_cnf->smart_gw_active && olsr_startup_gateways()) {
 550     olsr_exit("Cannot startup gateway tunnels", EXIT_FAILURE);
 551   }
 552 #endif /* __linux__ */
 553
 554   /* initialise the IPC socket */
 555   if ((olsr_cnf->ipc_connections > 0) && ipc_init()) {
 556     olsr_exit("ipc_init failure", EXIT_FAILURE);
 557   }
 558
 559   /* Initialisation of different tables to be used. */
 560   olsr_init_tables();
 561
 562   olsr_do_startup_sleep();
 563
 564   /* start heartbeat that is showing on stdout */
 565 #if !defined WINCE
 566   if ((olsr_cnf->debug_level > 0) && isatty(STDOUT_FILENO)) {
 567     heartBeatTimer = olsr_start_timer(STDOUT_PULSE_INT, 0, OLSR_TIMER_PERIODIC, &generate_stdout_pulse, NULL, 0);
 568   }
 569 #endif /* !defined WINCE */
 570
 571   /* daemon mode */
 572 #ifndef _WIN32
 573   if ((olsr_cnf->debug_level == 0) && !olsr_cnf->no_fork) {
 574     printf("%s detaching from the current process...\n", olsrd_version);
 575     if (daemon(0, 0) < 0) {
 576       char buf2[1024];
 577       snprintf(buf2, sizeof(buf2), "daemon(3) failed: %s", strerror(errno));
 578       olsr_exit(buf2, EXIT_FAILURE);
 579     }
 580   }
 581 #endif /* _WIN32 */
 582
 583   if (!writePidFile()) {
 584     olsr_exit(NULL, EXIT_FAILURE);
 585   }
 586
 587   /* Create locking file for olsrd, will be cleared after olsrd exits */
 588   if (!olsr_create_lock_file()) {
 589     char buf2[1024];
 590     snprintf(buf2, sizeof(buf2), "Error, cannot create OLSR lock file '%s'", olsr_cnf->lock_file);
 591     olsr_exit(buf2, EXIT_FAILURE);
 592   }
 593
 594   /* Load plugins */
 595   olsr_load_plugins();
 596
 597   /* print the main address */
 598   {
 599     struct ipaddr_str buf;
 600     OLSR_PRINTF(1, "Main address: %s\n\n", olsr_ip_to_string(&buf, &olsr_cnf->main_addr));
 601   }
 602
 603   /* create policy routing rules with priorities if necessary */
 604 #ifdef __linux__
 605   if (DEF_RT_NONE != olsr_cnf->rt_table_pri) {
 606     olsr_os_policy_rule(olsr_cnf->ip_version, olsr_cnf->rt_table, olsr_cnf->rt_table_pri, NULL, true);
 607   }
 608
 609   if (DEF_RT_NONE != olsr_cnf->rt_table_tunnel_pri) {
 610     olsr_os_policy_rule(olsr_cnf->ip_version, olsr_cnf->rt_table_tunnel, olsr_cnf->rt_table_tunnel_pri, NULL, true);
 611   }
 612
 613   if (DEF_RT_NONE != olsr_cnf->rt_table_default_pri) {
 614     olsr_os_policy_rule(olsr_cnf->ip_version, olsr_cnf->rt_table_default, olsr_cnf->rt_table_default_pri, NULL, true);
 615   }
 616
 617   /* rule to default table on all olsrd interfaces */
 618   if (DEF_RT_NONE != olsr_cnf->rt_table_defaultolsr_pri) {
 619     struct interface_olsr *ifn;
 620     for (ifn = ifnet; ifn; ifn = ifn->int_next) {
 621       olsr_os_policy_rule(olsr_cnf->ip_version, olsr_cnf->rt_table_default, olsr_cnf->rt_table_defaultolsr_pri, ifn->int_name, true);
 622     }
 623   }
 624
 625   /* trigger gateway selection */
 626   if (olsr_cnf->smart_gw_active) {
 627     olsr_trigger_inetgw_startup();
 628   }
 629
 630   /* trigger niit static route setup */
 631   if (olsr_cnf->use_niit) {
 632     olsr_setup_niit_routes();
 633   }
 634
 635   /* create lo:olsr interface */
 636   if (olsr_cnf->use_src_ip_routes) {
 637     olsr_os_localhost_if(&olsr_cnf->main_addr, true);
 638   }
 639 #endif /* __linux__ */
 640
 641   /* Start syslog entry */
 642   olsr_syslog(OLSR_LOG_INFO, "%s successfully started", olsrd_version);
 643
 644   /* setup signal-handlers */
 645 #ifdef _WIN32
 646 #ifndef WINCE
 647   SetConsoleCtrlHandler(SignalHandler, true);
 648 #endif /* WINCE */
 649 #else /* _WIN32 */
 650   signal(SIGHUP, olsr_reconfigure);
 651   signal(SIGINT, olsr_shutdown);
 652   signal(SIGQUIT, olsr_shutdown);
 653   signal(SIGILL, olsr_shutdown);
 654   signal(SIGABRT, olsr_shutdown);
 655   //  signal(SIGSEGV, olsr_shutdown);
 656   signal(SIGTERM, olsr_shutdown);
 657   signal(SIGPIPE, SIG_IGN);
 658   // Ignoring SIGUSR1 and SIGUSR1 by default to be able to use them in plugins
 659   signal(SIGUSR1, SIG_IGN);
 660   signal(SIGUSR2, SIG_IGN);
 661 #endif /* _WIN32 */
 662
 663   /* Starting scheduler */
 664   olsr_scheduler();
 665
 666   /* We'll only get here when olsr_shutdown has stopped the scheduler */
 667   sleep(30);
 668
 669   exit(EXIT_FAILURE);
 670 } /* main */
 671
 672 /*
 673  * Local Variables:
 674  * c-basic-offset: 2
 675  * indent-tabs-mode: nil
 676  * End:
 677  */