inline small functions
authorBernd Petrovitsch <bernd@firmix.at>
Sun, 1 Jun 2008 22:35:41 +0000 (00:35 +0200)
committerBernd Petrovitsch <bernd@firmix.at>
Sun, 1 Jun 2008 22:35:41 +0000 (00:35 +0200)
83 files changed:
Makefile
Makefile.inc
files/olsrd.conf.default.lq
files/olsrd.conf.default.lq-fisheye
files/olsrd.conf.default.rfc
files/olsrd.conf.win32.lq
files/olsrd.conf.win32.rfc
lib/Makefile
lib/bmf/src/NetworkInterfaces.c
lib/dot_draw/src/olsrd_dot_draw.c
lib/httpinfo/src/admin_interface.c
lib/httpinfo/src/olsrd_httpinfo.c
lib/lq_etx_fpm/Makefile [deleted file]
lib/lq_etx_fpm/README_LQ_ETX_FPM [deleted file]
lib/lq_etx_fpm/src/lq_etx_fpm_plugin.c [deleted file]
lib/lq_etx_fpm/src/lq_etx_fpm_plugin.h [deleted file]
lib/lq_etx_fpm/version-script.txt [deleted file]
lib/nameservice/README_NAMESERVICE
lib/nameservice/src/nameservice.c
lib/nameservice/src/nameservice.h
lib/tas/src/plugin.c
lib/txtinfo/src/olsrd_txtinfo.c
src/bsd/kernel_routes.c
src/bsd/net.c
src/build_msg.c
src/cfgparser/cfgfile_gen.c
src/cfgparser/olsrd_conf.c
src/cfgparser/oparse.y
src/cfgparser/oscan.lex
src/common/avl.c
src/common/avl.h
src/defs.h
src/duplicate_set.c
src/duplicate_set.h
src/hashing.c
src/hna_set.c
src/hna_set.h
src/hysteresis.c
src/hysteresis.h
src/interfaces.c
src/interfaces.h
src/link_set.c
src/link_set.h
src/lq_packet.c
src/lq_packet.h
src/lq_plugin.c
src/lq_plugin.h
src/lq_plugin_default.c [deleted file]
src/lq_plugin_default_float.c [new file with mode: 0644]
src/lq_plugin_default_float.h [moved from src/lq_plugin_default.h with 65% similarity]
src/lq_plugin_default_fpm.c [moved from lib/lq_etx_fpm/src/lq_etx_fpm.c with 53% similarity]
src/lq_plugin_default_fpm.h [moved from lib/lq_etx_fpm/src/lq_etx_fpm.h with 65% similarity]
src/main.c
src/mantissa.c
src/mantissa.h
src/mid_set.c
src/mid_set.h
src/mpr_selector_set.c
src/mpr_selector_set.h
src/olsr.c
src/olsr.h
src/olsr_cfg.h
src/olsr_cookie.c
src/olsr_cookie.h
src/olsr_protocol.h
src/olsr_spf.c [moved from src/lq_route.c with 99% similarity]
src/olsr_spf.h [moved from src/lq_route.h with 95% similarity]
src/packet.c
src/packet.h
src/print_packet.c
src/process_package.c
src/process_routes.c
src/rebuild_packet.c
src/routing_table.c
src/routing_table.h
src/scheduler.c
src/scheduler.h
src/tc_set.c
src/tc_set.h
src/two_hop_neighbor_table.c
src/two_hop_neighbor_table.h
src/unix/ifnet.c
src/win32/ifnet.c

index 6ea2e7b..9d13e2f 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -36,7 +36,7 @@
 # the copyright holders.
 #
 
-VERS =         0.5.6-rc1
+VERS =         0.5.6-rc4
 
 TOPDIR = .
 include Makefile.inc
index f387340..a76b9dc 100644 (file)
@@ -11,7 +11,7 @@ DEBUG ?= 0
 NO_DEBUG_MESSAGES ?= 0
 
 # the optimize option to be set for gcc
-OPTIMIZE ?= -O2
+OPTIMIZE ?= 
 
 # enable mudflap with 1 or deactivate with 0
 # you need a recent enough gcc and the libmudflap installed
@@ -97,7 +97,7 @@ ifeq ($(DEBUG),0)
 WARNINGS +=    -fomit-frame-pointer
 endif
 # we have small inline functions in src/lq_route.h which should always be inlined
-WARNINGS +=    -finline-limit=100
+WARNINGS +=    -finline-limit=350
 # These tell gcc to put each function and global variable in a separate section.
 # The linker can than remove all unreferenced section. But in the olsrd binary
 # unused doesn't imply unused at all since the function may be used by plugins,
@@ -128,6 +128,7 @@ LDFLAGS +=  -Wl,--version-script=version-script.txt
 else
 # c and ld flags for main
 LDFLAGS +=     -Wl,-export-dynamic 
+LDFLAGS +=     -Wl,-rpath,$(LIBDIR)
 endif
 # LDFLAGS for all 
 LDFLAGS +=     -Wl,--warn-common
@@ -178,7 +179,7 @@ OBJS +=             $(SRCS:%.c=%.o)
 # debugging or non-debugging flags
 ifeq ($(DEBUG),1)
 CPPFLAGS +=    -DDEBUG
-CFLAGS +=      -g
+CFLAGS +=      -ggdb
 else
 CPPFLAGS +=    -DNDEBUG
 endif
index 1b8cd05..012f841 100644 (file)
@@ -127,10 +127,15 @@ UseHysteresis     no
 
 LinkQualityLevel       2
 
-# Link quality window size
-# Defaults to 10
+# Link quality aging factor
+# Defaults to 0.1, smaller values mean faster reaction to changing links
 
-LinkQualityWinSize     12
+#LinkQualityAging 0.1 
+
+# Link quality algorithm
+# Defaults to "etx_fpm" for fixpoint based etx algorithm
+
+#LinkQualityAlgorithm    "etx_fpm"
 
 # Polling rate in seconds(float). 
 # Default value 0.05 sec
index c7e695a..21f0a0c 100644 (file)
@@ -239,10 +239,15 @@ UseHysteresis     no
 
 LinkQualityLevel       2
 
-# Link quality window size
-# Defaults to 10
+# Link quality aging factor
+# Defaults to 0.1, smaller values mean faster reaction to changing links
 
-LinkQualityWinSize     100
+#LinkQualityAging 0.1 
+
+# Link quality algorithm
+# Defaults to "etx_fpm" for fixpoint based etx algorithm
+
+#LinkQualityAlgorithm    "etx_fpm"
 
 # Polling rate in seconds(float). 
 # Default value 0.05 sec
index 11bb224..58f6c74 100644 (file)
@@ -122,10 +122,9 @@ HystThrLow 0.30
 
 #LinkQualityLevel      0
 
-# Link quality window size
-# Defaults to 10
-
-#LinkQualityWinSize    12
+# Link quality aging factor
+# Defaults to 0.05, smaller values mean larger LQ window size
+# LinkQualityAging 0.1 
 
 # Polling rate in seconds(float). 
 # Default value 0.05 sec
index f71f26a..caa572d 100644 (file)
@@ -31,11 +31,9 @@ ClearScreen          no
 \r
 LinkQualityLevel       2\r
 \r
-#\r
-# Windows size for packet loss calculation\r
-#\r
-\r
-LinkQualityWinSize     12\r
+# Link quality aging factor\r
+# Defaults to 0.05, smaller values mean larger LQ window size\r
+LinkQualityAging 0.1 \r
 \r
 #\r
 # Do not use hysteresis\r
index fe76d27..b388807 100644 (file)
@@ -31,11 +31,9 @@ ClearScreen          no
 \r
 LinkQualityLevel       0\r
 \r
-#\r
-# Windows size for packet loss calculation\r
-#\r
-\r
-LinkQualityWinSize     12\r
+# Link quality aging factor\r
+# Defaults to 0.05, smaller values mean larger LQ window size\r
+LinkQualityAging 0.1 \r
 \r
 #\r
 # Do not use hysteresis\r
index df29c9b..0b0dc71 100644 (file)
@@ -3,9 +3,9 @@ ifeq ($(OS),linux)
 SUBDIRS := $(shell find -maxdepth 2 -name Makefile -not -path ./Makefile -printf "%h\n")
 else
 ifeq ($(OS),win32)
-SUBDIRS := bmf dot_draw httpinfo mini pgraph secure txtinfo lq_etx_fpm
+SUBDIRS := bmf dot_draw httpinfo mini pgraph secure txtinfo
 else
-SUBDIRS := bmf dot_draw dyn_gw dyn_gw_plain httpinfo mini nameservice pgraph secure txtinfo lq_etx_fpm
+SUBDIRS := bmf dot_draw dyn_gw dyn_gw_plain httpinfo mini nameservice pgraph secure txtinfo
 endif
 endif
 
index efbaaff..38f3c31 100644 (file)
@@ -61,7 +61,6 @@
 #include "ipcalc.h"
 #include "defs.h" /* olsr_cnf */
 #include "link_set.h" /* get_link_set() */
-#include "lq_route.h" /* MIN_LINK_QUALITY */
 #include "tc_set.h" /* olsr_lookup_tc_entry(), olsr_lookup_tc_edge() */
 #include "net_olsr.h" /* ipequal */
 #include "lq_plugin.h"
index 95c20d5..7b265d0 100644 (file)
@@ -265,9 +265,8 @@ ipc_action(int fd __attribute__((unused)))
     return;
   }
   olsr_printf(1, "(DOT DRAW)IPC: Connection from %s\n", inet_ntoa(pin.sin_addr));
-  close(ipc_connection); /* close connection after one output */
   pcf_event(1, 1, 1);
-  close(ipc_connection); // close connection after one output
+  close(ipc_connection); /* close connection after one output */
 }
 
 
index 781f8a8..335156c 100644 (file)
@@ -138,8 +138,8 @@ build_admin_body(char *buf, olsr_u32_t bufsize __attribute__((unused)))
   if(olsr_cnf->lq_level) {
     size += snprintf(&buf[size], bufsize-size, admin_basic_setting_int,
                      "LQ level:", "lq_level", 1, olsr_cnf->lq_level);
-    size += snprintf(&buf[size], bufsize-size, admin_basic_setting_int,
-                     "LQ winsize:", "lq_wsize", 2, olsr_cnf->lq_wsize);
+    size += snprintf(&buf[size], bufsize-size, admin_basic_setting_float,
+                     "LQ aging:", "lq_aging", 2, olsr_cnf->lq_aging);
   } else {
     size += snprintf(&buf[size], bufsize-size, "<td>LQ disabled</td>\n");
   }
index 3235478..00dc72f 100644 (file)
@@ -872,9 +872,9 @@ static int build_config_body(char *buf, olsr_u32_t bufsize)
     if (olsr_cnf->lq_level) {
       size += snprintf(&buf[size], bufsize-size,
                        "<td>LQ level: %d</td>\n"
-                       "<td>LQ winsize: %d</td>\n",
+                       "<td>LQ aging: %f</td>\n",
                        olsr_cnf->lq_level,
-                       olsr_cnf->lq_wsize);
+                       olsr_cnf->lq_aging);
     }
     size += snprintf(&buf[size], bufsize-size, "</tr></table>\n");
 
@@ -1053,6 +1053,7 @@ static int build_topo_body(char *buf, olsr_u32_t bufsize)
   OLSR_FOR_ALL_TC_ENTRIES(tc) {
       struct tc_edge_entry *tc_edge;
       OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
+       if (tc_edge->edge_inv)  {
           size += snprintf(&buf[size], bufsize-size, "<tr>");
           size += build_ipaddr_with_link(&buf[size], bufsize, &tc_edge->T_dest_addr, -1);
           size += build_ipaddr_with_link(&buf[size], bufsize, &tc->addr, -1);
@@ -1064,7 +1065,7 @@ static int build_topo_body(char *buf, olsr_u32_t bufsize)
                                get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
           }
           size += snprintf(&buf[size], bufsize-size, "</tr>\n");
-
+       }
       } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
   } OLSR_FOR_ALL_TC_ENTRIES_END(tc);
 
diff --git a/lib/lq_etx_fpm/Makefile b/lib/lq_etx_fpm/Makefile
deleted file mode 100644 (file)
index 8b456ef..0000000
+++ /dev/null
@@ -1,56 +0,0 @@
-# The olsr.org Optimized Link-State Routing daemon(olsrd)
-# Copyright (c) 2004, Andreas T�nnesen(andreto@olsr.org)
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without 
-# modification, are permitted provided that the following conditions 
-# are met:
-#
-# * Redistributions of source code must retain the above copyright 
-#   notice, this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright 
-#   notice, this list of conditions and the following disclaimer in 
-#   the documentation and/or other materials provided with the 
-#   distribution.
-# * Neither the name of olsr.org, olsrd nor the names of its 
-#   contributors may be used to endorse or promote products derived 
-#   from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
-# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-#
-# Visit http://www.olsr.org for more information.
-#
-# If you find this software useful feel free to make a donation
-# to the project. For more information see the website or contact
-# the copyright holders.
-#
-
-OLSRD_PLUGIN = true
-PLUGIN_NAME =  lq_etx_fpm
-PLUGIN_VER =   0.1
-
-TOPDIR = ../..
-include $(TOPDIR)/Makefile.inc
-
-default_target: $(PLUGIN_FULLNAME)
-
-$(PLUGIN_FULLNAME): $(OBJS) version-script.txt
-               $(CC) $(LDFLAGS) -o $(PLUGIN_FULLNAME) $(OBJS) $(LIBS)
-
-install:       $(PLUGIN_FULLNAME)
-               $(STRIP) $(PLUGIN_FULLNAME)
-               $(INSTALL_LIB)
-
-clean:
-               rm -f $(OBJS) $(SRCS:%.c=%.d) $(PLUGIN_FULLNAME)
diff --git a/lib/lq_etx_fpm/README_LQ_ETX_FPM b/lib/lq_etx_fpm/README_LQ_ETX_FPM
deleted file mode 100644 (file)
index 8796b10..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
----------------------------------------------------------------------
-ETX-FPM LINKQUALITY PLUGIN FOR OLSRD
-by Henning Rogge <rogge@fgan.de>
----------------------------------------------------------------------
-
-This plugin is a fpm implementation of the etx metric calculation.
-
----------------------------------------------------------------------
-SAMPLE CONFIG
----------------------------------------------------------------------
-
-add in /etc/olsrd.conf:
-
-LoadPlugin "lq_etx_fpm.so.0.1"
-{
-    PlParam "alpha" "0.05"
-}
-
-
----------------------------------------------------------------------
-EOF / 30.03.2008
diff --git a/lib/lq_etx_fpm/src/lq_etx_fpm_plugin.c b/lib/lq_etx_fpm/src/lq_etx_fpm_plugin.c
deleted file mode 100644 (file)
index 19158f2..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
- * are met:
- *
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in 
- *   the documentation and/or other materials provided with the 
- *   distribution.
- * * Neither the name of olsr.org, olsrd nor the names of its 
- *   contributors may be used to endorse or promote products derived 
- *   from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Visit http://www.olsr.org for more information.
- *
- * If you find this software useful feel free to make a donation
- * to the project. For more information see the website or contact
- * the copyright holders.
- *
- */
-
-#include <stdio.h>
-#include <string.h>
-
-#include "../../../src/olsrd_plugin.h"
-
-#include "lq_etx_fpm_plugin.h"
-#include "lq_etx_fpm.h"
-#include "olsr.h"
-#include "fpm.h"
-
-#define PLUGIN_INTERFACE_VERSION 5
-
-/****************************************************************************
- *                Functions that the plugin MUST provide                    *
- ****************************************************************************/
-/**
- * Plugin interface version
- * Used by main olsrd to check plugin interface version
- */
-int olsrd_plugin_interface_version(void)
-{
-    return PLUGIN_INTERFACE_VERSION;
-}
-
-
-static int set_alpha(const char *value, void *data __attribute__((unused)), set_plugin_parameter_addon addon __attribute__((unused)))
-{
-    set_lq_etx_fpm_alpha(atofpm(value));
-    return 0;
-}
-
-/**
- * Register parameters from config file
- * Called for all plugin parameters
- */
-static const struct olsrd_plugin_parameters plugin_parameters[] = {
-    { .name = "alpha",   .set_plugin_parameter = &set_alpha,      .data = NULL },
-};
-
-void olsrd_get_plugin_parameters(const struct olsrd_plugin_parameters **params, int *size)
-{
-    *params = plugin_parameters;
-    *size = sizeof(plugin_parameters)/sizeof(*plugin_parameters);
-}
-/**
- * Initialize plugin
- * Called after all parameters are passed
- */
-int
-olsrd_plugin_init(void)
-{
-  return init_lq_etx_fpm();
-}
-
-
-/****************************************************************************
- *       Optional private constructor and destructor functions              *
- ****************************************************************************/
-
-/* attention: make static to avoid name clashes */
-
-static void my_init(void) __attribute__ ((constructor));
-static void my_fini(void) __attribute__ ((destructor));
-
-
-/**
- * Optional Private Constructor
- */
-static void my_init(void)
-{
-}
-
-
-/**
- * Optional Private Destructor
- */
-static void my_fini(void)
-{
-}
diff --git a/lib/lq_etx_fpm/src/lq_etx_fpm_plugin.h b/lib/lq_etx_fpm/src/lq_etx_fpm_plugin.h
deleted file mode 100644 (file)
index 2fc2e04..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
- * are met:
- *
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in 
- *   the documentation and/or other materials provided with the 
- *   distribution.
- * * Neither the name of olsr.org, olsrd nor the names of its 
- *   contributors may be used to endorse or promote products derived 
- *   from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Visit http://www.olsr.org for more information.
- *
- * If you find this software useful feel free to make a donation
- * to the project. For more information see the website or contact
- * the copyright holders.
- *
- */
-
-#ifndef LQ_ETX_FPM_PLUGIN_
-#define LQ_ETX_FPM_PLUGIN_
-
-
-/****************************************************************************
- *                Functions that the plugin MUST provide                    *
- ****************************************************************************/
-
-
-/* Initialization function */
-int
-olsrd_plugin_init(void);
-
-int 
-olsrd_plugin_interface_version(void);
-
-#endif
diff --git a/lib/lq_etx_fpm/version-script.txt b/lib/lq_etx_fpm/version-script.txt
deleted file mode 100644 (file)
index a145659..0000000
+++ /dev/null
@@ -1,10 +0,0 @@
-VERS_1.0
-{
-  global:
-    olsrd_plugin_interface_version;
-    olsrd_plugin_init;
-    olsrd_get_plugin_parameters;
-
-  local:
-    *;
-};
index 3b5149e..d9598f3 100644 (file)
@@ -101,6 +101,23 @@ PlParam "latlon-infile" "name-of-input.txt"
        latitude and longitude to this file. Will overwrite the
        "lat" and "lon" parameters during runtime.
 
+PlParam "sighup-pid-file" "/path/to/pidfile.pid"
+        (*nix systems only) Sends a HUP signal to the process specified
+        by the pidfile (usually /var/run/dnsmasq.pid) when the host name
+        table changes. This is useful for letting dnsmasq or bind know
+        they have to reload their hosts file.
+
+PlParam "name-change-script" "/path/to/script"
+        Script to execute when there is a change in the hosts names
+        table. Useful for executing a script that uses the hosts file
+        to keep a website or a database updated.
+
+PlParam "services-change-script" "/path/to/script"
+        Similar to the previous parameter. Script to execute when there
+        is a change in the services list propagated by the nameserver
+        plugin. Useful for executing a script that uses the services file
+        to keep a website or a database updated.
+
 ---------------------------------------------------------------------
 SAMPLE CONFIG
 ---------------------------------------------------------------------
@@ -135,15 +152,22 @@ UNIX VARIANTS:
        if you want to make the names available via ordinary DNS
        you can use dnsmasq to read the hosts file and serve it to
        users. add "addn-hosts=/var/run/hosts_olsr" to dnsmasq.conf 
-       and restart dnsmasq
+        and:
+               PlParam "sighup-pid-file" "/var/run/dnsmasq.pid"
+
+        to your nameservice plugin configuration.
+
+        This is especially usefull for infrastructure mesh networks that
+        can't afford to run olsrd on all the clients but wish to provide
+        DNS to them. This is solved by running dnsmasq and olsrd with
+        this setup on "edge" nodes that provide connectivity.
 
 WINDOWS:
 
 * overwrite C:\WINDOWS\system32\drivers\etc\hosts
        be sure you have nothing in the file which you still need 
        and configure the plugin with
-       PlParam "filename" "C:\WINDOWS\system32\drivers\etc\hosts"
-
+        PlParam "hosts-file" "C:\WINDOWS\system32\drivers\etc\hosts"
 
 ---------------------------------------------------------------------
 TODO
index ca11ebd..cd5f872 100644 (file)
@@ -43,6 +43,9 @@
 #include <ctype.h>
 #include <sys/types.h>
 #include <regex.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <fcntl.h>
 
 #include "olsr.h"
 #include "ipcalc.h"
 
 /* config parameters */
 static char my_hosts_file[MAX_FILE + 1];
+static char my_sighup_pid_file[MAX_FILE + 1];
+
 static char my_add_hosts[MAX_FILE + 1];
 static char my_suffix[MAX_SUFFIX];
 static int my_interval = EMISSION_INTERVAL;
 static double my_timeout = NAME_VALID_TIME;
 static char my_resolv_file[MAX_FILE +1];
 static char my_services_file[MAX_FILE + 1];
+static char my_name_change_script[MAX_FILE + 1];
+static char my_services_change_script[MAX_FILE + 1];
 static char latlon_in_file[MAX_FILE + 1];
 static char my_latlon_file[MAX_FILE + 1];
 float my_lat = 0.0, my_lon = 0.0;
@@ -145,12 +152,15 @@ name_constructor(void)
        strcpy(my_hosts_file, "/var/run/hosts_olsr");
        strcpy(my_services_file, "/var/run/services_olsr");
        strcpy(my_resolv_file, "/var/run/resolvconf_olsr");
+       *my_sighup_pid_file = 0;
 #endif
 
        my_suffix[0] = '\0';
        my_add_hosts[0] = '\0';
        my_latlon_file[0] = '\0';
        latlon_in_file[0] = '\0';
+       my_name_change_script[0] = '\0';
+       my_services_change_script[0] = '\0';
        
        /* init the lists heads */
        for(i = 0; i < HASHSIZE; i++) {
@@ -240,7 +250,10 @@ static int set_nameservice_float(const char *value, void *data, set_plugin_param
 static const struct olsrd_plugin_parameters plugin_parameters[] = {
     { .name = "interval",      .set_plugin_parameter = &set_plugin_int,         .data = &my_interval },
     { .name = "timeout",       .set_plugin_parameter = &set_nameservice_float,  .data = &my_timeout },
+    { .name = "sighup-pid-file",.set_plugin_parameter = &set_plugin_string,      .data = &my_sighup_pid_file, .addon = {sizeof(my_sighup_pid_file)} },
     { .name = "hosts-file",    .set_plugin_parameter = &set_plugin_string,      .data = &my_hosts_file,    .addon = {sizeof(my_hosts_file)} },
+    { .name = "name-change-script", .set_plugin_parameter = &set_plugin_string,  .data = &my_name_change_script, .addon = {sizeof(my_name_change_script)} },
+    { .name = "services-change-script", .set_plugin_parameter = &set_plugin_string, .data = &my_services_change_script, .addon = {sizeof(my_services_change_script)} },
     { .name = "resolv-file",   .set_plugin_parameter = &set_plugin_string,      .data = &my_resolv_file,   .addon = {sizeof(my_resolv_file)} },
     { .name = "suffix",        .set_plugin_parameter = &set_plugin_string,      .data = &my_suffix,        .addon = {sizeof(my_suffix)} },
     { .name = "add-hosts",     .set_plugin_parameter = &set_plugin_string,      .data = &my_add_hosts,     .addon = {sizeof(my_add_hosts)} },
@@ -575,7 +588,7 @@ olsr_namesvc_gen(void *foo __attribute__((unused)))
        {
                /* IPv4 */
                message->v4.olsr_msgtype = MESSAGE_TYPE;
-               message->v4.olsr_vtime = double_to_me(my_timeout);
+               message->v4.olsr_vtime = reltime_to_me(my_timeout * MSEC_PER_SEC);
                memcpy(&message->v4.originator, &olsr_cnf->main_addr, olsr_cnf->ipsize);
                message->v4.ttl = MAX_TTL;
                message->v4.hopcnt = 0;
@@ -590,7 +603,7 @@ olsr_namesvc_gen(void *foo __attribute__((unused)))
        {
                /* IPv6 */
                message->v6.olsr_msgtype = MESSAGE_TYPE;
-               message->v6.olsr_vtime = double_to_me(my_timeout);
+               message->v6.olsr_vtime = reltime_to_me(my_timeout * MSEC_PER_SEC);
                memcpy(&message->v6.originator, &olsr_cnf->main_addr, olsr_cnf->ipsize);
                message->v6.ttl = MAX_TTL;
                message->v6.hopcnt = 0;
@@ -628,7 +641,7 @@ olsr_parser(union olsr_message *m,
 {
        struct namemsg *namemessage;
        union olsr_ip_addr originator;
-       double vtime;
+       olsr_reltime vtime;
        int size;
        olsr_u16_t seqno;
 
@@ -643,12 +656,12 @@ olsr_parser(union olsr_message *m,
                
        /* Fetch the message based on IP version */
        if(olsr_cnf->ip_version == AF_INET) {
-               vtime = me_to_double(m->v4.olsr_vtime);
+               vtime = me_to_reltime(m->v4.olsr_vtime);
                size = ntohs(m->v4.olsr_msgsize);
                namemessage = (struct namemsg*)&m->v4.message;
        }
        else {
-               vtime = me_to_double(m->v6.olsr_vtime);
+               vtime = me_to_reltime(m->v6.olsr_vtime);
                size = ntohs(m->v6.olsr_msgsize);
                namemessage = (struct namemsg*)&m->v6.message;
        }
@@ -880,7 +893,7 @@ decap_namemsg(struct name *from_packet, struct name_entry **to, olsr_bool *this_
  * name/service/forwarder entry in the message
  */
 void
-update_name_entry(union olsr_ip_addr *originator, struct namemsg *msg, int msg_size, double vtime)
+update_name_entry(union olsr_ip_addr *originator, struct namemsg *msg, int msg_size, olsr_reltime vtime)
 {
 #ifndef NODEBUG
        struct ipaddr_str strbuf;
@@ -944,7 +957,7 @@ void
 insert_new_name_in_list(union olsr_ip_addr *originator,
                                                struct list_node *this_list,
                                                struct name *from_packet, olsr_bool *this_table_changed,
-                                               double vtime)
+                                               olsr_reltime vtime)
 {
        int hash;
        struct db_entry *entry;
@@ -972,7 +985,7 @@ insert_new_name_in_list(union olsr_ip_addr *originator,
                        //delegate to function for parsing the packet and linking it to entry->names
                        decap_namemsg(from_packet, &entry->names, this_table_changed);
 
-                       olsr_set_timer(&entry->db_timer, vtime * MSEC_PER_SEC,
+                       olsr_set_timer(&entry->db_timer, vtime,
                                                   OLSR_NAMESVC_DB_JITTER, OLSR_TIMER_ONESHOT,
                                                   &olsr_nameservice_expire_db_timer, entry, 0);
 
@@ -994,7 +1007,7 @@ insert_new_name_in_list(union olsr_ip_addr *originator,
 
                entry->originator = *originator;
 
-               olsr_set_timer(&entry->db_timer, vtime * MSEC_PER_SEC,
+               olsr_set_timer(&entry->db_timer, vtime,
                                           OLSR_LINK_LOSS_JITTER, OLSR_TIMER_ONESHOT,
                                           &olsr_nameservice_expire_db_timer, entry, 0);
 
@@ -1008,6 +1021,51 @@ insert_new_name_in_list(union olsr_ip_addr *originator,
        }
 }
 
+#ifndef WIN32
+static void
+send_sighup_to_pidfile(char * pid_file){
+       int fd;
+       int i=0;
+       int result;
+       pid_t ipid;
+       char line[20];
+       char * endptr;
+
+       fd = open(pid_file, O_RDONLY);
+       if (fd<0) {
+               OLSR_PRINTF(2, "NAME PLUGIN: can't open file %s\n", pid_file);
+               return;
+       }
+
+       while (i<19) {
+               result = read(fd, line+i, 19-i);
+               if (!result) { /* EOF */
+                       break;
+               } else if (result>0) {
+                       i += result;
+               } else if(errno!=EINTR && errno!=EAGAIN) {
+                       OLSR_PRINTF(2, "NAME PLUGIN: can't read file %s\n", pid_file);
+                       return;
+               }
+       }
+       line[i]=0;
+       close(fd);
+       ipid = strtol(line, &endptr, 0);
+       if (endptr==line) {
+               OLSR_PRINTF(2, "NAME PLUGIN: invalid pid at file %s\n", pid_file);
+               return; 
+       }
+
+       result=kill(ipid, SIGHUP);
+       if (result==0){
+               OLSR_PRINTF(2, "NAME PLUGIN: SIGHUP sent to pid %i\n", ipid);   
+       } else {
+               OLSR_PRINTF(2, "NAME PLUGIN: failed to send SIGHUP to pid %i\n", ipid);
+       }
+
+}
+#endif
+
 /**
  * write names to a file in /etc/hosts compatible format
  */
@@ -1131,7 +1189,22 @@ write_hosts_file(void)
        }
          
        fclose(hosts);
+
+#ifndef WIN32
+       if (*my_sighup_pid_file)
+               send_sighup_to_pidfile(my_sighup_pid_file);
+#endif
        name_table_changed = OLSR_FALSE;
+
+       // Executes my_name_change_script after writing the hosts file
+        if (my_name_change_script[0] != '\0') {
+               if(system(my_name_change_script) != -1) {
+                       OLSR_PRINTF(2, "NAME PLUGIN: Name changed, %s executed\n", my_name_change_script);
+               }
+               else {
+                       OLSR_PRINTF(2, "NAME PLUGIN: WARNING! Failed to execute %s on hosts change\n", my_name_change_script);
+               }
+       }
 }
 
 
@@ -1201,6 +1274,16 @@ write_services_file(void)
          
        fclose(services_file);
        service_table_changed = OLSR_FALSE;
+       
+       // Executes my_services_change_script after writing the services file
+       if (my_services_change_script[0] != '\0') {
+               if(system(my_services_change_script) != -1) {
+                       OLSR_PRINTF(2, "NAME PLUGIN: Service changed, %s executed\n", my_services_change_script);
+               }
+               else {
+                       OLSR_PRINTF(2, "NAME PLUGIN: WARNING! Failed to execute %s on service change\n", my_services_change_script);
+               }
+       }
 }
 
 /**
index 78fce58..acf6383 100644 (file)
@@ -49,6 +49,7 @@
 #include "nameservice_msg.h"
 #include "hashing.h"
 #include "mapwrite.h"
+#include "mantissa.h"
 
 #define PLUGIN_NAME    "OLSRD nameservice plugin"
 #define PLUGIN_VERSION "0.3"
@@ -146,13 +147,13 @@ decap_namemsg(struct name *from_packet, struct name_entry **to, olsr_bool *this_
 
 void
 insert_new_name_in_list(union olsr_ip_addr *, struct list_node *,
-                        struct name *, olsr_bool *, double);
+                        struct name *, olsr_bool *, olsr_reltime);
 
 olsr_bool
 allowed_hostname_or_ip_in_service(const char *service_line, const regmatch_t *hostname_or_ip);
 
 void
-update_name_entry(union olsr_ip_addr *, struct namemsg *, int, double);
+update_name_entry(union olsr_ip_addr *, struct namemsg *, int, olsr_reltime);
 
 void
 write_hosts_file(void);
index cfc9e7d..7c626a3 100644 (file)
@@ -64,7 +64,6 @@
 #include <hna_set.h>
 #include <routing_table.h>
 #include <olsr_protocol.h>
-#include <lq_route.h>
 #include <mpr_selector_set.h>
 #include <duplicate_set.h>
 #include <lq_plugin.h>
index 3ae0ca3..9252f03 100644 (file)
@@ -400,6 +400,7 @@ static void ipc_print_topology(void)
     OLSR_FOR_ALL_TC_ENTRIES(tc) {
         struct tc_edge_entry *tc_edge;
         OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
+               if (tc_edge->edge_inv)  {
             struct ipaddr_str dstbuf, addrbuf;
             struct lqtextbuffer lqbuffer1, lqbuffer2;
             ipc_sendf( "%s\t%s\t%s\t%s\n", 
@@ -407,7 +408,7 @@ static void ipc_print_topology(void)
                        olsr_ip_to_string(&addrbuf, &tc->addr), 
                        get_tc_edge_entry_text(tc_edge, &lqbuffer1),
                        get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
-
+               }
         } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
     } OLSR_FOR_ALL_TC_ENTRIES_END(tc);
 
index 6161b04..b866566 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Thomas Lopatic (thomas@lopatic.de)
 #include "ipcalc.h"
 
 #include <net/if_dl.h>
-#include <ifaddrs.h>
+#include <net/ifaddrs.h>
+
+#ifdef _WRS_KERNEL
+#include <wrn/coreip/net/route.h>
+#include <m2Lib.h>
+#define OLSR_PID taskIdSelf ()
+#else
+#define OLSR_PID getpid ()
+#endif
 
 static unsigned int seq = 0;
 
-static int add_del_route(const struct rt_entry *rt, int add)
+/*
+ * Sends an add or delete message via the routing socket.
+ * The message consists of:
+ *  - a header i.e. struct rt_msghdr
+ *  - 0-8 socket address structures
+ */
+static int
+add_del_route(const struct rt_entry *rt, int add)
 {
-  struct rt_msghdr *rtm;
+  struct rt_msghdr *rtm;              /* message to configure a route */
+                                       /* contains data to be written to the
+                                          routing socket */
   unsigned char buff[512];
-  unsigned char *walker;
-  struct sockaddr_in sin;
-  struct sockaddr_dl *sdl;
+  unsigned char *walker;              /* points within the buffer */
+  struct sockaddr_in sin;             /* internet style sockaddr */
+  struct sockaddr_dl *sdl;            /* link level sockaddr */
   struct ifaddrs *addrs;
   struct ifaddrs *awalker;
   const struct rt_nexthop *nexthop;
-  union olsr_ip_addr mask;
-  int step, step2;
-  int len;
-  int flags;
+  union olsr_ip_addr mask;            /* netmask as ip address */
+  int sin_size, sdl_size;              /* size of addresses - e.g. destination
+                                          (payload of the message) */
+  int len;                             /* message size written to routing socket */
 
   if (add) {
-      OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
+    OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
   } else {
-      OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
+    OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
   }
 
-  memset(buff, 0, sizeof (buff));
-  memset(&sin, 0, sizeof (sin));
+  memset(buff, 0, sizeof(buff));
+  memset(&sin, 0, sizeof(sin));
 
-  sin.sin_len = sizeof (sin);
+  sin.sin_len = sizeof(sin);
   sin.sin_family = AF_INET;
 
-  step = 1 + ((sizeof (struct sockaddr_in) - 1) | 3);
-  step2 = 1 + ((sizeof (struct sockaddr_dl) - 1) | 3);
-
-  rtm = (struct rt_msghdr *)buff;
-
-  flags = olsr_rt_flags(rt);
+  sin_size = 1 + ((sizeof(struct sockaddr_in) - 1) | 3);
+  sdl_size = 1 + ((sizeof(struct sockaddr_dl) - 1) | 3);
 
-  // the host is directly reachable, so use cloning and a /32 net
-  // routing table entry
+  /**********************************************************************
+   *                  FILL THE ROUTING MESSAGE HEADER
+   **********************************************************************/
 
-  if ((flags & RTF_GATEWAY) == 0)
-  {
-    flags |= RTF_CLONING;
-    flags &= ~RTF_HOST;
-  }
+  /* position header to the beginning of the buffer */
+  rtm = (struct rt_msghdr *)buff;
 
   rtm->rtm_version = RTM_VERSION;
-  rtm->rtm_type = (add != 0) ? RTM_ADD : RTM_DELETE;
-  rtm->rtm_index = 0;
-  rtm->rtm_flags = flags;
-  rtm->rtm_addrs = RTA_DST | RTA_NETMASK | RTA_GATEWAY;
+  rtm->rtm_type = add ? RTM_ADD : RTM_DELETE;
+  rtm->rtm_index = 0;          /* is ignored in outgoing messages */
+  /* RTF_UP [and RTF_HOST and/or RTF_GATEWAY] */
+  rtm->rtm_flags = olsr_rt_flags(rt);
+  rtm->rtm_pid = OLSR_PID;
   rtm->rtm_seq = ++seq;
 
-  walker = buff + sizeof (struct rt_msghdr);
+  /* walk to the end of the header */
+  walker = buff + sizeof(struct rt_msghdr);
+
+  /**********************************************************************
+   *                  SET  DESTINATION OF THE ROUTE
+   **********************************************************************/
+
+  rtm->rtm_addrs = RTA_DST;    /* part of the header */
 
   sin.sin_addr = rt->rt_dst.prefix.v4;
+  OLSR_PRINTF(8, "\t- Destination of the route: %s\n", inet_ntoa(sin.sin_addr));
 
-  memcpy(walker, &sin, sizeof (sin));
-  walker += step;
+  /* change proto or tos here */
+  OLSR_PRINTF(8, "\t- Setting Protocol: 0\n");
+  ((struct sockaddr_rt *)(&sin))->srt_proto = 0;
+  OLSR_PRINTF(8, "\t- Setting TOS: 0\n");
+  ((struct sockaddr_rt *)(&sin))->srt_tos = 0;
 
-  nexthop = olsr_get_nh(rt);
-  if ((flags & RTF_GATEWAY) != 0)
-  {
-    sin.sin_addr = nexthop->gateway.v4;
+  memcpy(walker, &sin, sizeof(sin));
+  walker += sin_size;
 
-    memcpy(walker, &sin, sizeof (sin));
-    walker += step;
-  }
+  /**********************************************************************
+   *                  SET GATEWAY OF THE ROUTE
+   **********************************************************************/
 
-  // the host is directly reachable, so add the output interface's
-  // MAC address
+  if (add || (rtm->rtm_addrs & RTF_GATEWAY)) {
+    rtm->rtm_addrs |= RTA_GATEWAY;     /* part of the header */
+    nexthop = olsr_get_nh(rt);
 
-  else
-  {
-    if (getifaddrs(&addrs))
-    {
-      fprintf(stderr, "getifaddrs() failed\n");
-      return -1;
+    if ((rtm->rtm_flags & RTF_GATEWAY)) {      /* GATEWAY */
+      sin.sin_addr = nexthop->gateway.v4;
+
+      memcpy(walker, &sin, sizeof(sin));
+      walker += sin_size;
+
+      OLSR_PRINTF(8, "\t- Gateway of the route: %s\n", inet_ntoa(sin.sin_addr));
     }
+    /* NO GATEWAY - destination is directly reachable */
+    else {
+      rtm->rtm_flags |= RTF_CLONING;   /* part of the header! */
+
+      /*
+       * Host is directly reachable, so add the output interface MAC address.
+       */
+      if (getifaddrs(&addrs)) {
+       fprintf(stderr, "\ngetifaddrs() failed\n");
+       return -1;
+      }
+
+      for (awalker = addrs; awalker != NULL; awalker = awalker->ifa_next)
+       if (awalker->ifa_addr->sa_family == AF_LINK &&
+           strcmp(awalker->ifa_name,
+                  if_ifwithindex_name(nexthop->iif_index)) == 0)
+         break;
+
+      if (awalker == NULL) {
+       fprintf(stderr, "\nInterface %s not found\n",
+               if_ifwithindex_name(nexthop->iif_index));
+       freeifaddrs(addrs);
+       return -1;
+      }
+
+      /* sdl is "struct sockaddr_dl" */
+      sdl = (struct sockaddr_dl *)awalker->ifa_addr;
+#ifdef DEBUG
+      OLSR_PRINTF(8,"\t- Link layer address of the non gateway route: %s\n",
+                  LLADDR(sdl));
+#endif
 
-    for (awalker = addrs; awalker != NULL; awalker = awalker->ifa_next)
-      if (awalker->ifa_addr->sa_family == AF_LINK &&
-          strcmp(awalker->ifa_name, if_ifwithindex_name(nexthop->iif_index)) == 0)
-        break;
+      memcpy(walker, sdl, sdl->sdl_len);
+      walker += sdl_size;
 
-    if (awalker == NULL)
-    {
-      fprintf(stderr, "interface %s not found\n", if_ifwithindex_name(nexthop->iif_index));
       freeifaddrs(addrs);
-      return -1;
     }
+  } else {
+    /* Route with no gateway is deleted */
+  }
 
-    sdl = (struct sockaddr_dl *)awalker->ifa_addr;
+  /**********************************************************************
+   *                         SET  NETMASK
+   **********************************************************************/
 
-    memcpy(walker, sdl, sdl->sdl_len);
-    walker += step2;
+  if ((rtm->rtm_flags & RTF_HOST)) {
+    OLSR_PRINTF(8, "\t- No netmask needed for a host route.\n");
+  } else {                     /* NO! hoste route */
 
-    freeifaddrs(addrs);
-  }
+    rtm->rtm_addrs |= RTA_NETMASK; /* part of the header */
 
-  if (!olsr_prefix_to_netmask(&mask, rt->rt_dst.prefix_len)) {
-    return -1;
+    if (!olsr_prefix_to_netmask(&mask, rt->rt_dst.prefix_len)) {
+      return -1;
+    }
+    sin.sin_addr = mask.v4;
+
+    memcpy(walker, &sin, sizeof(sin));
+    walker += sin_size;
+
+    OLSR_PRINTF(8, "\t- Netmask of the route: %s\n", inet_ntoa(sin.sin_addr));
   }
-  sin.sin_addr = mask.v4;
 
-  memcpy(walker, &sin, sizeof (sin));
-  walker += step;
+  /**********************************************************************
+   *           WRITE CONFIGURATION MESSAGE TO THE ROUTING SOCKET
+   **********************************************************************/
 
   rtm->rtm_msglen = (unsigned short)(walker - buff);
 
   len = write(olsr_cnf->rts, buff, rtm->rtm_msglen);
+  OLSR_PRINTF(8, "\nWrote %d bytes to rts socket (FD=%d)\n", len,
+             olsr_cnf->rts);
 
-  if (len < rtm->rtm_msglen)
-    fprintf(stderr, "cannot write to routing socket: %s\n", strerror(errno));
+  if (0 != rtm->rtm_errno || len < rtm->rtm_msglen) {
+    fprintf(stderr,
+           "\nCannot write to routing socket: (rtm_errno= 0x%x) (last error message: %s)\n",
+           rtm->rtm_errno, strerror(errno));
+  }
+
+  OLSR_PRINTF(8,
+             "\nWriting the following information to routing socket (message header):"
+             "\n\trtm_msglen: %u" "\n\trtm_version: %u" "\n\trtm_type: %u"
+             "\n\trtm_index: %u" "\n\trtm_flags: 0x%x" "\n\trtm_addrs: %u"
+             "\n\trtm_pid: 0x%x" "\n\trtm_seq: %u" "\n\trtm_errno: 0x%x"
+             "\n\trtm_use %u" "\n\trtm_inits: %u\n",
+             (unsigned int)rtm->rtm_msglen, (unsigned int)rtm->rtm_version,
+             (unsigned int)rtm->rtm_type, (unsigned int)rtm->rtm_index,
+             (unsigned int)rtm->rtm_flags, (unsigned int)rtm->rtm_addrs,
+             (unsigned int)rtm->rtm_pid, (unsigned int)rtm->rtm_seq,
+             (unsigned int)rtm->rtm_errno, (unsigned int)rtm->rtm_use,
+             (unsigned int)rtm->rtm_inits);
 
   return 0;
 }
 
-int olsr_ioctl_add_route(const struct rt_entry *rt)
+int
+olsr_ioctl_add_route(const struct rt_entry *rt)
 {
   return add_del_route(rt, 1);
 }
 
-int olsr_ioctl_del_route(const struct rt_entry *rt)
+int
+olsr_ioctl_del_route(const struct rt_entry *rt)
 {
   return add_del_route(rt, 0);
 }
 
-static int add_del_route6(const struct rt_entry *rt, int add)
+static int
+add_del_route6(const struct rt_entry *rt, int add)
 {
   struct rt_msghdr *rtm;
   unsigned char buff[512];
@@ -188,22 +270,22 @@ static int add_del_route6(const struct rt_entry *rt, int add)
   int len;
 
   if (add) {
-      OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
+    OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
   } else {
-      OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
+    OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
   }
 
-  memset(buff, 0, sizeof (buff));
-  memset(&sin6, 0, sizeof (sin6));
-  memset(&sdl, 0, sizeof (sdl));
+  memset(buff, 0, sizeof(buff));
+  memset(&sin6, 0, sizeof(sin6));
+  memset(&sdl, 0, sizeof(sdl));
 
-  sin6.sin6_len = sizeof (sin6);
+  sin6.sin6_len = sizeof(sin6);
   sin6.sin6_family = AF_INET6;
-  sdl.sdl_len = sizeof (sdl);
+  sdl.sdl_len = sizeof(sdl);
   sdl.sdl_family = AF_LINK;
 
-  step = 1 + ((sizeof (struct sockaddr_in6) - 1) | 3);
-  step_dl = 1 + ((sizeof (struct sockaddr_dl) - 1) | 3);
+  step = 1 + ((sizeof(struct sockaddr_in6) - 1) | 3);
+  step_dl = 1 + ((sizeof(struct sockaddr_dl) - 1) | 3);
 
   rtm = (struct rt_msghdr *)buff;
   rtm->rtm_version = RTM_VERSION;
@@ -213,53 +295,54 @@ static int add_del_route6(const struct rt_entry *rt, int add)
   rtm->rtm_addrs = RTA_DST | RTA_GATEWAY;
   rtm->rtm_seq = ++seq;
 
-  walker = buff + sizeof (struct rt_msghdr);
+  walker = buff + sizeof(struct rt_msghdr);
 
-  memcpy(&sin6.sin6_addr.s6_addr, &rt->rt_dst.prefix.v6, sizeof(struct in6_addr));
+  memcpy(&sin6.sin6_addr.s6_addr, &rt->rt_dst.prefix.v6,
+        sizeof(struct in6_addr));
 
-  memcpy(walker, &sin6, sizeof (sin6));
+  memcpy(walker, &sin6, sizeof(sin6));
   walker += step;
 
   nexthop = olsr_get_nh(rt);
-  if ((rtm->rtm_flags & RTF_GATEWAY) != 0)
-  {
-    memcpy(&sin6.sin6_addr.s6_addr, &nexthop->gateway.v6, sizeof(struct in6_addr));
+  if ((rtm->rtm_flags & RTF_GATEWAY) != 0) {
+    memcpy(&sin6.sin6_addr.s6_addr, &nexthop->gateway.v6,
+          sizeof(struct in6_addr));
 
     memset(&sin6.sin6_addr.s6_addr, 0, 8);
     sin6.sin6_addr.s6_addr[0] = 0xfe;
     sin6.sin6_addr.s6_addr[1] = 0x80;
     sin6.sin6_scope_id = nexthop->iif_index;
 #ifdef __KAME__
-    *(u_int16_t *)&sin6.sin6_addr.s6_addr[2] = htons(sin6.sin6_scope_id);
+    *(u_int16_t *) & sin6.sin6_addr.s6_addr[2] = htons(sin6.sin6_scope_id);
     sin6.sin6_scope_id = 0;
 #endif
-    memcpy(walker, &sin6, sizeof (sin6));
+    memcpy(walker, &sin6, sizeof(sin6));
     walker += step;
   }
 
-  // the host is directly reachable, so add the output interface's address
+  /* the host is directly reachable, so add the output interface's address */
 
-  else
-  {
-    memcpy(&sin6.sin6_addr.s6_addr,  &rt->rt_dst.prefix.v6, sizeof(struct in6_addr));
+  else {
+    memcpy(&sin6.sin6_addr.s6_addr, &rt->rt_dst.prefix.v6,
+          sizeof(struct in6_addr));
     memset(&sin6.sin6_addr.s6_addr, 0, 8);
     sin6.sin6_addr.s6_addr[0] = 0xfe;
     sin6.sin6_addr.s6_addr[1] = 0x80;
     sin6.sin6_scope_id = nexthop->iif_index;
 #ifdef __KAME__
-    *(u_int16_t *)&sin6.sin6_addr.s6_addr[2] = htons(sin6.sin6_scope_id);
+    *(u_int16_t *) & sin6.sin6_addr.s6_addr[2] = htons(sin6.sin6_scope_id);
     sin6.sin6_scope_id = 0;
 #endif
 
-    memcpy(walker, &sin6, sizeof (sin6));
+    memcpy(walker, &sin6, sizeof(sin6));
     walker += step;
     rtm->rtm_flags |= RTF_GATEWAY;
   }
 
-  if ((rtm->rtm_flags & RTF_HOST) == 0)
-  {
-    olsr_prefix_to_netmask((union olsr_ip_addr *)&sin6.sin6_addr, rt->rt_dst.prefix_len);
-    memcpy(walker, &sin6, sizeof (sin6));
+  if ((rtm->rtm_flags & RTF_HOST) == 0) {
+    olsr_prefix_to_netmask((union olsr_ip_addr *)&sin6.sin6_addr,
+                          rt->rt_dst.prefix_len);
+    memcpy(walker, &sin6, sizeof(sin6));
     walker += step;
     rtm->rtm_addrs |= RTA_NETMASK;
   }
@@ -275,7 +358,7 @@ static int add_del_route6(const struct rt_entry *rt, int add)
     struct rt_msghdr *drtm;
     unsigned char dbuff[512];
 
-    memset(dbuff, 0, sizeof (dbuff));
+    memset(dbuff, 0, sizeof(dbuff));
     drtm = (struct rt_msghdr *)dbuff;
     drtm->rtm_version = RTM_VERSION;
     drtm->rtm_type = RTM_DELETE;
@@ -284,10 +367,10 @@ static int add_del_route6(const struct rt_entry *rt, int add)
     drtm->rtm_flags = olsr_rt_flags(rt);
     drtm->rtm_seq = ++seq;
 
-    walker = dbuff + sizeof (struct rt_msghdr);
+    walker = dbuff + sizeof(struct rt_msghdr);
     memcpy(&sin6.sin6_addr.s6_addr, &rt->rt_dst.prefix.v6,
-       sizeof(struct in6_addr));
-    memcpy(walker, &sin6, sizeof (sin6));
+          sizeof(struct in6_addr));
+    memcpy(walker, &sin6, sizeof(sin6));
     walker += step;
     drtm->rtm_msglen = (unsigned short)(walker - dbuff);
     len = write(olsr_cnf->rts, dbuff, drtm->rtm_msglen);
@@ -302,12 +385,14 @@ static int add_del_route6(const struct rt_entry *rt, int add)
   return 0;
 }
 
-int olsr_ioctl_add_route6(const struct rt_entry *rt)
+int
+olsr_ioctl_add_route6(const struct rt_entry *rt)
 {
   return add_del_route6(rt, 1);
 }
 
-int olsr_ioctl_del_route6(const struct rt_entry *rt)
+int
+olsr_ioctl_del_route6(const struct rt_entry *rt)
 {
   return add_del_route6(rt, 0);
 }
index 401b38c..7515f68 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
 #include "../defs.h"
 #include "../net_os.h"
 #include "../ipcalc.h"
-#include "../parser.h" /* dnc: needed for call to packet_parser() */
+#include "../parser.h"         /* dnc: needed for call to packet_parser() */
 #include "../olsr_protocol.h"
 
-#include <sys/param.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <stdio.h>
 #include <netinet/in.h>
 #include <net/if.h>
 
+#ifdef _WRS_KERNEL
+#include <vxWorks.h>
+#include "wrn/coreip/netinet6/in6_var.h"
+#include <sockLib.h>
+#include <sys/socket.h>
+#include "wrn/coreip/net/ifaddrs.h"
+#include <selectLib.h>
+#include <logLib.h>
+#define syslog(a, b) fdprintf(a, b);
+#else
+#include <sys/param.h>
+#endif
+
+
 #ifdef __NetBSD__
 #include <net/if_ether.h>
 #endif
@@ -68,7 +82,7 @@
 #include <netinet/ip_icmp.h>
 #include <netinet/icmp_var.h>
 #include <netinet/icmp6.h>
-#include <netinet6/in6_var.h> /* For struct in6_ifreq */
+#include <netinet6/in6_var.h>  /* For struct in6_ifreq */
 #include <ifaddrs.h>
 #include <sys/uio.h>
 #include <net80211/ieee80211.h>
 #include <libnet.h>
 #endif /* SPOOF */
 
-//#define      SIOCGIFGENERIC  _IOWR('i', 58, struct ifreq)    /* generic IF get op */
-//#define SIOCGWAVELAN SIOCGIFGENERIC
+#if 0
+#define        SIOCGIFGENERIC  _IOWR('i', 58, struct ifreq)    /* generic IF get op */
+#define SIOCGWAVELAN SIOCGIFGENERIC
+#endif
 
 #include <sys/sysctl.h>
 
@@ -107,13 +123,14 @@ static int ignore_redir;
 static int send_redir;
 static int gateway;
 
-static int set_sysctl_int(const char *name, int new)
+static int
+set_sysctl_int(const char *name, int new)
 {
   int old;
 #if __MacOSX__ || __OpenBSD__
-  size_t len = sizeof (old);
+  size_t len = sizeof(old);
 #else
-  unsigned int len = sizeof (old);
+  unsigned int len = sizeof(old);
 #endif
 
 #ifdef __OpenBSD__
@@ -125,50 +142,45 @@ static int set_sysctl_int(const char *name, int new)
   mib[2] = IPPROTO_IP;
   mib[3] = IPCTL_FORWARDING;
 
-  if (!strcmp(name, "net.inet6.ip6.forwarding"))
-  {
+  if (!strcmp(name, "net.inet6.ip6.forwarding")) {
     mib[1] = PF_INET6;
     mib[2] = IPPROTO_IPV6;
-  }
-  else if (!strcmp(name, "net.inet.icmp.rediraccept"))
-  {
+  } else if (!strcmp(name, "net.inet.icmp.rediraccept")) {
     mib[2] = IPPROTO_ICMP;
     mib[3] = ICMPCTL_REDIRACCEPT;
-  }
-  else if (!strcmp(name, "net.inet6.icmp6.rediraccept"))
-  {
+  } else if (!strcmp(name, "net.inet6.icmp6.rediraccept")) {
     mib[2] = IPPROTO_ICMPV6;
     mib[3] = ICMPV6CTL_REDIRACCEPT;
-  }
-  else if (!strcmp(name, "net.inet.ip.redirect"))
-  {
+  } else if (!strcmp(name, "net.inet.ip.redirect")) {
     mib[3] = IPCTL_SENDREDIRECTS;
-  }
-  else if (!strcmp(name, "net.inet6.ip6.redirect"))
-  {
+  } else if (!strcmp(name, "net.inet6.ip6.redirect")) {
     mib[1] = PF_INET6;
     mib[2] = IPPROTO_IPV6;
     mib[3] = IPCTL_SENDREDIRECTS;
   }
 
-  if (sysctl(mib, 4, &old, &len, &new, sizeof (new)) < 0)
+  if (sysctl(mib, 4, &old, &len, &new, sizeof(new)) < 0)
     return -1;
 #else
 
-  if (sysctlbyname(name, &old, &len, &new, sizeof (new)) < 0)
+  if (sysctlbyname((char *)name, &old, &len, &new, sizeof(new)) < 0)
     return -1;
 #endif
 
   return old;
 }
 
-int enable_ip_forwarding(int version)
+int
+enable_ip_forwarding(int version)
 {
-  const char *name = version == AF_INET ? "net.inet.ip.forwarding" : "net.inet6.ip6.forwarding";
+  const char *name =
+    version == AF_INET ? "net.inet.ip.forwarding" : "net.inet6.ip6.forwarding";
 
   gateway = set_sysctl_int(name, 1);
   if (gateway < 0) {
-    fprintf(stderr, "Cannot enable IP forwarding. Please enable IP forwarding manually. Continuing in 3 seconds...\n");
+    fprintf(stderr,
+           "Cannot enable IP forwarding. Please enable IP forwarding manually."
+            " Continuing in 3 seconds...\n");
     sleep(3);
   }
 
@@ -180,7 +192,7 @@ disable_redirects_global(int version)
 {
   const char *name;
 
-  // do not accept ICMP redirects
+  /* do not accept ICMP redirects */
 
 #ifdef __OpenBSD__
   if (version == AF_INET)
@@ -190,13 +202,10 @@ disable_redirects_global(int version)
 
   ignore_redir = set_sysctl_int(name, 0);
 #elif defined __FreeBSD__ || defined __MacOSX__
-  if (version == AF_INET)
-  {
+  if (version == AF_INET) {
     name = "net.inet.icmp.drop_redirect";
     ignore_redir = set_sysctl_int(name, 1);
-  }
-  else
-  {
+  } else {
     name = "net.inet6.icmp6.rediraccept";
     ignore_redir = set_sysctl_int(name, 0);
   }
@@ -209,13 +218,14 @@ disable_redirects_global(int version)
   ignore_redir = set_sysctl_int(name, 1);
 #endif
 
-  if (ignore_redir < 0)
-    {
-      fprintf(stderr, "Cannot disable incoming ICMP redirect messages. Please disable them manually. Continuing in 3 seconds...\n");
-      sleep(3);
-    }
+  if (ignore_redir < 0) {
+    fprintf(stderr,
+           "Cannot disable incoming ICMP redirect messages. "
+            "Please disable them manually. Continuing in 3 seconds...\n");
+    sleep(3);
+  }
 
-  // do not send ICMP redirects
+  /* do not send ICMP redirects */
 
   if (version == AF_INET)
     name = "net.inet.ip.redirect";
@@ -223,48 +233,66 @@ disable_redirects_global(int version)
     name = "net.inet6.ip6.redirect";
 
   send_redir = set_sysctl_int(name, 0);
-  if (send_redir < 0)
-    {
-      fprintf(stderr, "Cannot disable outgoing ICMP redirect messages. Please disable them manually. Continuing in 3 seconds...\n");
-      sleep(3);
-    }
+  if (send_redir < 0) {
+    fprintf(stderr,
+           "Cannot disable outgoing ICMP redirect messages. "
+            "Please disable them manually. Continuing in 3 seconds...\n");
+    sleep(3);
+  }
 
   return 1;
 }
 
-int disable_redirects(const char *if_name __attribute__((unused)), struct interface *iface __attribute__((unused)), int version __attribute__((unused)))
+int
+disable_redirects(const char *if_name
+                 __attribute__ ((unused)), struct interface *iface
+                 __attribute__ ((unused)), int version
+                 __attribute__ ((unused)))
 {
-  // this function gets called for each interface olsrd uses; however,
-  // FreeBSD can only globally control ICMP redirects, and not on a
-  // per-interface basis; hence, only disable ICMP redirects in the "global"
-  // function
+  /*
+   *  this function gets called for each interface olsrd uses; however,
+   * FreeBSD can only globally control ICMP redirects, and not on a
+   * per-interface basis; hence, only disable ICMP redirects in the "global"
+   * function
+   */
   return 1;
 }
 
-int deactivate_spoof(const char *if_name __attribute__((unused)), struct interface *iface __attribute__((unused)), int version __attribute__((unused)))
+int
+deactivate_spoof(const char *if_name
+                __attribute__ ((unused)), struct interface *iface
+                __attribute__ ((unused)), int version __attribute__ ((unused)))
 {
   return 1;
 }
 
-int restore_settings(int version)
+int
+restore_settings(int version)
 {
-  // reset IP forwarding
-  const char *name = version == AF_INET ? "net.inet.ip.forwarding" : "net.inet6.ip6.forwarding";
+  /* reset IP forwarding */
+  const char *name =
+    version == AF_INET ? "net.inet.ip.forwarding" : "net.inet6.ip6.forwarding";
 
   set_sysctl_int(name, gateway);
 
-  // reset incoming ICMP redirects
+  /* reset incoming ICMP redirects */
 
 #ifdef __OpenBSD__
-  name = version == AF_INET ? "net.inet.icmp.rediraccept"   : "net.inet6.icmp6.rediraccept";
+  name =
+    version ==
+    AF_INET ? "net.inet.icmp.rediraccept" : "net.inet6.icmp6.rediraccept";
 #elif defined __FreeBSD__ || defined __MacOSX__
-  name = version == AF_INET ? "net.inet.icmp.drop_redirect" : "net.inet6.icmp6.rediraccept";
+  name =
+    version ==
+    AF_INET ? "net.inet.icmp.drop_redirect" : "net.inet6.icmp6.rediraccept";
 #else
-  name = version == AF_INET ? "net.inet.icmp.drop_redirect" : "net.inet6.icmp6.drop_redirect";
+  name =
+    version ==
+    AF_INET ? "net.inet.icmp.drop_redirect" : "net.inet6.icmp6.drop_redirect";
 #endif
   set_sysctl_int(name, ignore_redir);
 
-  // reset outgoing ICMP redirects
+  /* reset outgoing ICMP redirects */
   name = version == AF_INET ? "net.inet.ip.redirect" : "net.inet6.ip6.redirect";
   set_sysctl_int(name, send_redir);
   return 1;
@@ -284,187 +312,169 @@ gethemusocket(struct sockaddr_in *pin)
   OLSR_PRINTF(1, "       Connecting to switch daemon port 10150...");
 
 
-  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
-    {
-      perror("hcsocket");
-      syslog(LOG_ERR, "hcsocket: %m");
-      return (-1);
-    }
+  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    perror("hcsocket");
+    syslog(LOG_ERR, "hcsocket: %m");
+    return (-1);
+  }
 
-  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) 
-    {
-      perror("SO_REUSEADDR failed");
-      close(sock);
-      return (-1);
-    }
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
+    perror("SO_REUSEADDR failed");
+    close(sock);
+    return (-1);
+  }
   /* connect to PORT on HOST */
-  if (connect(sock,(struct sockaddr *) pin, sizeof(*pin)) < 0) 
-    {
-      printf("FAILED\n");
-      fprintf(stderr, "Error connecting %d - %s\n", errno, strerror(errno));
-      printf("connection refused\n");
-      close(sock);
-      return (-1);
-    }
+  if (connect(sock, (struct sockaddr *)pin, sizeof(*pin)) < 0) {
+    printf("FAILED\n");
+    fprintf(stderr, "Error connecting %d - %s\n", errno, strerror(errno));
+    printf("connection refused\n");
+    close(sock);
+    return (-1);
+  }
 
   printf("OK\n");
 
-  /* Keep TCP socket blocking */  
+  /* Keep TCP socket blocking */
   return (sock);
 }
 
 
 int
-getsocket(int bufspace, char *int_name __attribute__((unused)))
+getsocket(int bufspace, char *int_name __attribute__ ((unused)))
 {
   struct sockaddr_in sin;
   int on;
   int sock = socket(AF_INET, SOCK_DGRAM, 0);
-  if (sock < 0) 
-    {
-      perror("socket");
-      syslog(LOG_ERR, "socket: %m");
-      return -1;
-    }
+  if (sock < 0) {
+    perror("socket");
+    syslog(LOG_ERR, "socket: %m");
+    return -1;
+  }
 
   on = 1;
-  if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0)
-    {
-      perror("setsockopt");
-      syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&on, sizeof(on)) < 0) {
+    perror("setsockopt");
+    syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
+    close(sock);
+    return -1;
+  }
 
-  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) 
-    {
-      perror("SO_REUSEADDR failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
+    perror("SO_REUSEADDR failed");
+    close(sock);
+    return -1;
+  }
 
-  if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0) 
-    {
-      perror("SO_REUSEPORT failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (char *)&on, sizeof(on)) < 0) {
+    perror("SO_REUSEPORT failed");
+    close(sock);
+    return -1;
+  }
 
-  if (setsockopt(sock, IPPROTO_IP, IP_RECVIF, &on, sizeof(on)) < 0) 
-    {
-      perror("IP_RECVIF failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, IPPROTO_IP, IP_RECVIF, (char *)&on, sizeof(on)) < 0) {
+    perror("IP_RECVIF failed");
+    close(sock);
+    return -1;
+  }
 
-  for (on = bufspace; ; on -= 1024) 
-    {
-      if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof (on)) == 0)
-       break;
-      if (on <= 8*1024) 
-       {
-         perror("setsockopt");
-         syslog(LOG_ERR, "setsockopt SO_RCVBUF: %m");
-         break;
-       }
+  for (on = bufspace;; on -= 1024) {
+    if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&on, sizeof(on)) == 0)
+      break;
+    if (on <= 8 * 1024) {
+      perror("setsockopt");
+      syslog(LOG_ERR, "setsockopt SO_RCVBUF: %m");
+      break;
     }
+  }
 
-  memset(&sin, 0, sizeof (sin));
+  memset(&sin, 0, sizeof(sin));
   sin.sin_family = AF_INET;
   sin.sin_port = htons(OLSRPORT);
   sin.sin_addr.s_addr = INADDR_ANY;
-  if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) 
-    {
-      perror("bind");
-      syslog(LOG_ERR, "bind: %m");
-      close(sock);
-      return -1;
-    }
+  if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
+    perror("bind");
+    syslog(LOG_ERR, "bind: %m");
+    close(sock);
+    return -1;
+  }
 
   on = fcntl(sock, F_GETFL);
   if (on == -1) {
-      syslog(LOG_ERR, "fcntl (F_GETFL): %m\n");
+    syslog(LOG_ERR, "fcntl (F_GETFL): %m\n");
   } else {
-      if (fcntl(sock, F_SETFL, on|O_NONBLOCK) == -1) {
-          syslog(LOG_ERR, "fcntl O_NONBLOCK: %m\n");
-      }
+    if (fcntl(sock, F_SETFL, on | O_NONBLOCK) == -1) {
+      syslog(LOG_ERR, "fcntl O_NONBLOCK: %m\n");
+    }
   }
   return (sock);
 }
 
-int getsocket6(int bufspace, char *int_name __attribute__((unused)))
+int
+getsocket6(int bufspace, char *int_name __attribute__ ((unused)))
 {
   struct sockaddr_in6 sin;
   int on;
   int sock = socket(AF_INET6, SOCK_DGRAM, 0);
 
-  if (sock < 0) 
-    {
-      perror("socket");
-      syslog(LOG_ERR, "socket: %m");
-      return -1;
-    }
-
-  for (on = bufspace; ; on -= 1024) 
-    {
-      if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof (on)) == 0)
-          break;
-      if (on <= 8*1024) 
-       {
-         perror("setsockopt");
-         syslog(LOG_ERR, "setsockopt SO_RCVBUF: %m");
-         break;
-       }
-    }
+  if (sock < 0) {
+    perror("socket");
+    syslog(LOG_ERR, "socket: %m");
+    return -1;
+  }
 
-  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) 
-    {
-      perror("SO_REUSEADDR failed");
-      close(sock);
-      return -1;
+  for (on = bufspace;; on -= 1024) {
+    if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&on, sizeof(on)) == 0)
+      break;
+    if (on <= 8 * 1024) {
+      perror("setsockopt");
+      syslog(LOG_ERR, "setsockopt SO_RCVBUF: %m");
+      break;
     }
+  }
 
-  if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0) 
-    {
-      perror("SO_REUSEPORT failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
+    perror("SO_REUSEADDR failed");
+    close(sock);
+    return -1;
+  }
 
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (char *)&on, sizeof(on)) < 0) {
+    perror("SO_REUSEPORT failed");
+    close(sock);
+    return -1;
+  }
 #ifdef IPV6_RECVPKTINFO
-  if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on)) < 0)
-    {
-      perror("IPV6_RECVPKTINFO failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, (char *)&on, sizeof(on))
+      < 0) {
+    perror("IPV6_RECVPKTINFO failed");
+    close(sock);
+    return -1;
+  }
 #elif defined IPV6_PKTINFO
-  if (setsockopt(sock, IPPROTO_IPV6, IPV6_PKTINFO, &on, sizeof(on)) < 0)
-    {
-      perror("IPV6_PKTINFO failed");
-      close(sock);
-      return -1;
-    }
+  if (setsockopt(sock, IPPROTO_IPV6, IPV6_PKTINFO, (char *)&on, sizeof(on)) < 0) {
+    perror("IPV6_PKTINFO failed");
+    close(sock);
+    return -1;
+  }
 #endif
 
   memset(&sin, 0, sizeof(sin));
   sin.sin6_family = AF_INET6;
   sin.sin6_port = htons(OLSRPORT);
-  if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0)
-    {
-      perror("bind");
-      syslog(LOG_ERR, "bind: %m");
-      close(sock);
-      return -1;
-    }
+  if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
+    perror("bind");
+    syslog(LOG_ERR, "bind: %m");
+    close(sock);
+    return -1;
+  }
 
   on = fcntl(sock, F_GETFL);
   if (on == -1) {
-      syslog(LOG_ERR, "fcntl (F_GETFL): %m\n");
+    syslog(LOG_ERR, "fcntl (F_GETFL): %m\n");
   } else {
-      if (fcntl(sock, F_SETFL, on|O_NONBLOCK) == -1) {
-          syslog(LOG_ERR, "fcntl O_NONBLOCK: %m\n");
-      }
+    if (fcntl(sock, F_SETFL, on | O_NONBLOCK) == -1) {
+      syslog(LOG_ERR, "fcntl O_NONBLOCK: %m\n");
+    }
   }
   return sock;
 }
@@ -481,40 +491,39 @@ join_mcast(struct interface *ifs, int sock)
   mcastreq.ipv6mr_multiaddr = ifs->int6_multaddr.sin6_addr;
   mcastreq.ipv6mr_interface = ifs->if_index;
 
-  OLSR_PRINTF(3, "Interface %s joining multicast %s...", ifs->int_name, olsr_ip_to_string(&addrstr, (union olsr_ip_addr *)&ifs->int6_multaddr.sin6_addr));
+  OLSR_PRINTF(3, "Interface %s joining multicast %s...", ifs->int_name,
+             olsr_ip_to_string(&addrstr,
+                               (union olsr_ip_addr *)&ifs->int6_multaddr.
+                               sin6_addr));
 
   /* rfc 3493 */
 #ifdef IPV6_JOIN_GROUP
   /* Join reciever group */
-  if(setsockopt(sock, 
-               IPPROTO_IPV6, 
-               IPV6_JOIN_GROUP, 
-               (char *)&mcastreq, 
-               sizeof(struct ipv6_mreq)) 
-     < 0)
+  if (setsockopt(sock,
+                IPPROTO_IPV6,
+                IPV6_JOIN_GROUP, (char *)&mcastreq, sizeof(struct ipv6_mreq))
+      < 0)
 #else /* rfc 2133, obsoleted */
   /* Join receiver group */
-  if(setsockopt(sock, 
-               IPPROTO_IPV6, 
-               IPV6_ADD_MEMBERSHIP, 
-               (char *)&mcastreq, 
-               sizeof(struct ipv6_mreq)) < 0)
-#endif 
-    {
-      perror("Join multicast send");
-      return -1;
-    }
+  if (setsockopt(sock,
+                IPPROTO_IPV6,
+                IPV6_ADD_MEMBERSHIP,
+                (char *)&mcastreq, sizeof(struct ipv6_mreq)) < 0)
+#endif
+  {
+    perror("Join multicast send");
+    return -1;
+  }
 
-  
-  if(setsockopt(sock, 
-               IPPROTO_IPV6, 
-               IPV6_MULTICAST_IF, 
-               (char *)&mcastreq.ipv6mr_interface, 
-               sizeof(mcastreq.ipv6mr_interface)) < 0)
-    {
-      perror("Set multicast if");
-      return -1;
-    }
+
+  if (setsockopt(sock,
+                IPPROTO_IPV6,
+                IPV6_MULTICAST_IF,
+                (char *)&mcastreq.ipv6mr_interface,
+                sizeof(mcastreq.ipv6mr_interface)) < 0) {
+    perror("Set multicast if");
+    return -1;
+  }
 
 
   OLSR_PRINTF(3, "OK\n");
@@ -524,7 +533,8 @@ join_mcast(struct interface *ifs, int sock)
 
 
 
-int get_ipv6_address(char *ifname, struct sockaddr_in6 *saddr6, int scope_in)
+int
+get_ipv6_address(char *ifname, struct sockaddr_in6 *saddr6, int scope_in)
 {
   struct ifaddrs *ifap, *ifa;
   const struct sockaddr_in6 *sin6 = NULL;
@@ -533,59 +543,47 @@ int get_ipv6_address(char *ifname, struct sockaddr_in6 *saddr6, int scope_in)
   int s6;
   u_int32_t flags6;
 
-  if (getifaddrs(&ifap) != 0)
-    {
-      OLSR_PRINTF(3, "get_ipv6_address: getifaddrs() failed.\n");
-      return 0;
-    }
+  if (getifaddrs(&ifap) != 0) {
+    OLSR_PRINTF(3, "get_ipv6_address: getifaddrs() failed.\n");
+    return 0;
+  }
 
-  for (ifa = ifap; ifa; ifa = ifa->ifa_next)
-    {
-      if (ifa->ifa_addr->sa_family == AF_INET6 &&
-          strcmp(ifa->ifa_name, ifname) == 0)
-        {
-         sin6 = (const struct sockaddr_in6 *)ifa->ifa_addr;
-         if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
-           continue;
-         strncpy(ifr6.ifr_name, ifname, sizeof(ifr6.ifr_name));
-         if ((s6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
-           {
-             OLSR_PRINTF(3, "socket(AF_INET6,SOCK_DGRAM)");
-             break;
-           }
-         ifr6.ifr_addr = *sin6;
-         if (ioctl(s6, SIOCGIFAFLAG_IN6, &ifr6) < 0)
-           {
-             OLSR_PRINTF(3, "ioctl(SIOCGIFAFLAG_IN6)");
-             close(s6);
-             break;
-           }
-         close(s6);
-         flags6 = ifr6.ifr_ifru.ifru_flags6;
-         if ((flags6 & IN6_IFF_ANYCAST) != 0)
-           continue;
-         if (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))
-           {
-             if (scope_in)
-               {
-                 memcpy(&saddr6->sin6_addr, &sin6->sin6_addr,
-                        sizeof(struct in6_addr));
-                 found = 1;
-                 break;
-               }
-           }
-         else
-           {
-             if (scope_in == 0)
-               {
-                 memcpy(&saddr6->sin6_addr, &sin6->sin6_addr,
-                        sizeof(struct in6_addr));
-                 found = 1;
-                 break;
-               }
-           }
+  for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
+    if ((ifa->ifa_addr->sa_family == AF_INET6) &&
+       (strcmp(ifa->ifa_name, ifname) == 0)) {
+      sin6 = (const struct sockaddr_in6 *)(ifa->ifa_addr);
+      if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
+       continue;
+      strncpy(ifr6.ifr_name, ifname, sizeof(ifr6.ifr_name));
+      if ((s6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
+       OLSR_PRINTF(3, "socket(AF_INET6,SOCK_DGRAM)");
+       break;
+      }
+      ifr6.ifr_addr = *sin6;
+      if (ioctl(s6, SIOCGIFAFLAG_IN6, (int)&ifr6) < 0) {
+       OLSR_PRINTF(3, "ioctl(SIOCGIFAFLAG_IN6)");
+       close(s6);
+       break;
+      }
+      close(s6);
+      flags6 = ifr6.ifr_ifru.ifru_flags6;
+      if ((flags6 & IN6_IFF_ANYCAST) != 0)
+       continue;
+      if (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr)) {
+       if (scope_in) {
+         memcpy(&saddr6->sin6_addr, &sin6->sin6_addr, sizeof(struct in6_addr));
+         found = 1;
+         break;
+       }
+      } else {
+       if (scope_in == 0) {
+         memcpy(&saddr6->sin6_addr, &sin6->sin6_addr, sizeof(struct in6_addr));
+         found = 1;
+         break;
        }
+      }
     }
+  }
   freeifaddrs(ifap);
   if (found)
     return 1;
@@ -605,12 +603,11 @@ static u_int16_t ip_id = 0;
 #endif /* SPOOF */
 
 ssize_t
-olsr_sendto(int s, 
-           const void *buf, 
-           size_t len, 
-           int flags __attribute__((unused)), 
-           const struct sockaddr *to, 
-           socklen_t tolen)
+olsr_sendto(int s,
+           const void *buf,
+           size_t len,
+           int flags __attribute__ ((unused)),
+           const struct sockaddr *to, socklen_t tolen)
 {
 #ifdef SPOOF
   /* IPv4 for now! */
@@ -618,89 +615,84 @@ olsr_sendto(int s,
   libnet_t *context;
   char errbuf[LIBNET_ERRBUF_SIZE];
   libnet_ptag_t udp_tag, ip_tag, ether_tag;
-  unsigned char enet_broadcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+  unsigned char enet_broadcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
   int status;
-  struct sockaddr_in *to_in = (struct sockaddr_in *) to;
+  struct sockaddr_in *to_in = (struct sockaddr_in *)to;
   u_int32_t destip;
   struct interface *iface;
 
   udp_tag = ip_tag = ether_tag = 0;
   destip = to_in->sin_addr.s_addr;
-  iface = if_ifwithsock (s);
+  iface = if_ifwithsock(s);
 
   /* initialize libnet */
   context = libnet_init(LIBNET_LINK, iface->int_name, errbuf);
-  if (context == NULL)
-    {
-      OLSR_PRINTF (1, "libnet init: %s\n", libnet_geterror (context));
-      return (0);
-    }
+  if (context == NULL) {
+    OLSR_PRINTF(1, "libnet init: %s\n", libnet_geterror(context));
+    return (0);
+  }
 
   /* initialize IP ID field if necessary */
-  if (ip_id == 0)
-    {
-      ip_id = (u_int16_t) (arc4random () & 0xffff);
-    }
+  if (ip_id == 0) {
+    ip_id = (u_int16_t) (arc4random() & 0xffff);
+  }
 
-  udp_tag = libnet_build_udp (698,                             /* src port */
-                             698,                              /* dest port */
-                             LIBNET_UDP_H + len,               /* length */
-                             0,                                /* checksum */
-                             buf,                              /* payload */
-                             len,                              /* payload size */
-                             context,                          /* context */
-                             udp_tag);                         /* pblock */
-  if (udp_tag == -1)
-    {
-      OLSR_PRINTF (1, "libnet UDP header: %s\n", libnet_geterror (context));
-       return (0);
-    }
+  udp_tag = libnet_build_udp(698,      /* src port */
+                            698,       /* dest port */
+                            LIBNET_UDP_H + len,        /* length */
+                            0, /* checksum */
+                            buf,       /* payload */
+                            len,       /* payload size */
+                            context,   /* context */
+                            udp_tag);  /* pblock */
+  if (udp_tag == -1) {
+    OLSR_PRINTF(1, "libnet UDP header: %s\n", libnet_geterror(context));
+    return (0);
+  }
 
-  ip_tag = libnet_build_ipv4 (LIBNET_IPV4_H + LIBNET_UDP_H + len, /* len */
-                             0,                                /* TOS */
-                             ip_id++,                          /* IP id */
-                             0,                                /* IP frag */
-                             1,                                /* IP TTL */
-                             IPPROTO_UDP,                      /* protocol */
-                             0,                                /* checksum */
-                             libnet_get_ipaddr4 (context),     /* src IP */
-                             destip,                           /* dest IP */
-                             NULL,                             /* payload */
-                             0,                                /* payload len */
-                             context,                          /* context */
-                             ip_tag);                          /* pblock */
-  if (ip_tag == -1)
-    {
-      OLSR_PRINTF (1, "libnet IP header: %s\n", libnet_geterror (context));
-      return (0);
-    }
+  ip_tag = libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_UDP_H + len,       /* len */
+                            0, /* TOS */
+                            ip_id++,   /* IP id */
+                            0, /* IP frag */
+                            1, /* IP TTL */
+                            IPPROTO_UDP,       /* protocol */
+                            0, /* checksum */
+                            libnet_get_ipaddr4(context),       /* src IP */
+                            destip,    /* dest IP */
+                            NULL,      /* payload */
+                            0, /* payload len */
+                            context,   /* context */
+                            ip_tag);   /* pblock */
+  if (ip_tag == -1) {
+    OLSR_PRINTF(1, "libnet IP header: %s\n", libnet_geterror(context));
+    return (0);
+  }
 
-  ether_tag = libnet_build_ethernet (enet_broadcast,           /* ethernet dest */
-                                    libnet_get_hwaddr (context), /* ethernet source */
-                                    ETHERTYPE_IP,              /* protocol type */
-                                    NULL,                      /* payload */
-                                    0,                         /* payload size */
-                                    context,                   /* libnet handle */
-                                    ether_tag);                /* pblock tag */
-  if (ether_tag == -1)
-    {
-      OLSR_PRINTF (1, "libnet ethernet header: %s\n", libnet_geterror (context));
-      return (0);
-    }
-  status = libnet_write (context);
-  if (status == -1)
-    {
-      OLSR_PRINTF (1, "libnet packet write: %s\n", libnet_geterror (context));
-      return (0);
-    }
+  ether_tag = libnet_build_ethernet(enet_broadcast,    /* ethernet dest */
+                                   libnet_get_hwaddr(context), /* ethernet source */
+                                   ETHERTYPE_IP,       /* protocol type */
+                                   NULL,       /* payload */
+                                   0,  /* payload size */
+                                   context,    /* libnet handle */
+                                   ether_tag); /* pblock tag */
+  if (ether_tag == -1) {
+    OLSR_PRINTF(1, "libnet ethernet header: %s\n", libnet_geterror(context));
+    return (0);
+  }
 
-  libnet_destroy (context);
+  status = libnet_write(context);
+  if (status == -1) {
+    OLSR_PRINTF(1, "libnet packet write: %s\n", libnet_geterror(context));
+    return (0);
+  }
+
+  libnet_destroy(context);
 
   return (len);
 
 #else
-  return sendto(s, buf, len, flags, to, tolen);
+  return sendto(s, (caddr_t) buf, (int)len, flags, (struct sockaddr *)to,
+               tolen);
 #endif
 }
 
@@ -709,23 +701,22 @@ olsr_sendto(int s,
  * Wrapper for recvfrom(2)
  */
 
-ssize_t  
-olsr_recvfrom(int  s, 
-             void *buf, 
-             size_t len, 
-             int flags __attribute__((unused)), 
-             struct sockaddr *from,
-             socklen_t *fromlen)
+ssize_t
+olsr_recvfrom(int s,
+             void *buf,
+             size_t len,
+             int flags __attribute__ ((unused)),
+             struct sockaddr *from, socklen_t * fromlen)
 {
   struct msghdr mhdr;
   struct iovec iov;
   union {
-       struct cmsghdr cmsg;
-       unsigned char chdr[4096];
+    struct cmsghdr cmsg;
+    unsigned char chdr[4096];
   } cmu;
   struct cmsghdr *cm;
   struct sockaddr_dl *sdl;
-  struct sockaddr_in *sin = (struct sockaddr_in *) from; //XXX
+  struct sockaddr_in *sin = (struct sockaddr_in *)from;
   struct sockaddr_in6 *sin6;
   struct in6_addr *iaddr6;
   struct in6_pktinfo *pkti;
@@ -741,55 +732,49 @@ olsr_recvfrom(int  s,
   mhdr.msg_namelen = *fromlen;
   mhdr.msg_iov = &iov;
   mhdr.msg_iovlen = 1;
-  mhdr.msg_control = (caddr_t) &cmu;
-  mhdr.msg_controllen = sizeof (cmu);
+  mhdr.msg_control = (caddr_t) & cmu;
+  mhdr.msg_controllen = sizeof(cmu);
 
   iov.iov_len = len;
   iov.iov_base = buf;
 
-  count = recvmsg (s, &mhdr, MSG_DONTWAIT);
-  if (count <= 0)
-    {
-      return (count);
-    }
+  count = recvmsg(s, &mhdr, MSG_DONTWAIT);
+  if (count <= 0) {
+    return (count);
+  }
 
   /* this needs to get communicated back to caller */
   *fromlen = mhdr.msg_namelen;
-  if (olsr_cnf->ip_version == AF_INET6)
-    {
-      for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&mhdr); cm;
-          cm = (struct cmsghdr *)CMSG_NXTHDR(&mhdr, cm))
-       {
-         if (cm->cmsg_level == IPPROTO_IPV6 && cm->cmsg_type == IPV6_PKTINFO)
-           {
-             pkti = (struct in6_pktinfo *) CMSG_DATA(cm);
-             iaddr6 = &pkti->ipi6_addr;
-             if_indextoname(pkti->ipi6_ifindex, iname);
-           }
-       }
-    }
-  else
-    {
-      cm = &cmu.cmsg;
-      sdl = (struct sockaddr_dl *) CMSG_DATA (cm);
-      memset (iname, 0, sizeof (iname));
-      memcpy (iname, sdl->sdl_data, sdl->sdl_nlen);
+  if (olsr_cnf->ip_version == AF_INET6) {
+    for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&mhdr); cm;
+        cm = (struct cmsghdr *)CMSG_NXTHDR(&mhdr, cm)) {
+      if (cm->cmsg_level == IPPROTO_IPV6 && cm->cmsg_type == IPV6_PKTINFO) {
+       pkti = (struct in6_pktinfo *)CMSG_DATA(cm);
+       iaddr6 = &pkti->ipi6_addr;
+       if_indextoname(pkti->ipi6_ifindex, iname);
+      }
     }
+  } else {
+    cm = &cmu.cmsg;
+    sdl = (struct sockaddr_dl *)CMSG_DATA(cm);
+    memset(iname, 0, sizeof(iname));
+    memcpy(iname, sdl->sdl_data, sdl->sdl_nlen);
+  }
 
-  ifc = if_ifwithsock (s);
+  ifc = if_ifwithsock(s);
 
   sin6 = (struct sockaddr_in6 *)from;
-  OLSR_PRINTF (4, "%d bytes from %s, socket associated %s really received on %s\n",
-              count,          
-               inet_ntop(olsr_cnf->ip_version, olsr_cnf->ip_version == AF_INET6 ?
-                         (char *)&sin6->sin6_addr : (char *)&sin->sin_addr, addrstr, sizeof(addrstr)),
-              ifc->int_name,
-              iname);
-
-  if (strcmp (ifc->int_name, iname) != 0)
-    {
-      return (0);
-    }
+  OLSR_PRINTF(4,
+             "%d bytes from %s, socket associated %s really received on %s\n",
+             count, inet_ntop(olsr_cnf->ip_version,
+                              olsr_cnf->ip_version ==
+                              AF_INET6 ? (char *)&sin6->
+                              sin6_addr : (char *)&sin->sin_addr, addrstr,
+                              sizeof(addrstr)), ifc->int_name, iname);
+
+  if (strcmp(ifc->int_name, iname) != 0) {
+    return (0);
+  }
 
   return (count);
 }
@@ -800,23 +785,18 @@ olsr_recvfrom(int  s,
 
 int
 olsr_select(int nfds,
-           fd_set *readfds,
-           fd_set *writefds,
-           fd_set *exceptfds,
-           struct timeval *timeout)
+           fd_set * readfds,
+           fd_set * writefds, fd_set * exceptfds, struct timeval *timeout)
 {
-  return select(nfds,
-               readfds,
-               writefds,
-               exceptfds,
-               timeout);
+  return select(nfds, readfds, writefds, exceptfds, timeout);
 }
 
 
-int 
+int
 check_wireless_interface(char *ifname)
 {
 #if defined __FreeBSD__ &&  !defined FBSD_NO_80211
+
 /* From FreeBSD ifconfig/ifieee80211.c ieee80211_status() */
   struct ieee80211req ireq;
   u_int8_t data[32];
@@ -831,9 +811,9 @@ check_wireless_interface(char *ifname)
   struct ieee80211_nodereq nr;
   bzero(&nr, sizeof(nr));
   strlcpy(nr.nr_ifname, ifname, sizeof(nr.nr_ifname));
-  return (ioctl(olsr_cnf->ioctl_s, SIOCG80211FLAGS, &nr) >=0) ? 1: 0;
+  return (ioctl(olsr_cnf->ioctl_s, SIOCG80211FLAGS, &nr) >= 0) ? 1 : 0;
 #else
-  ifname = NULL; /* squelsh compiler warning */
+  ifname = NULL;               /* squelsh compiler warning */
   return 0;
 #endif
 }
@@ -843,29 +823,25 @@ check_wireless_interface(char *ifname)
 int
 calculate_if_metric(char *ifname)
 {
-  if(check_wireless_interface(ifname))
-    {
-      /* Wireless */
-      return 1;
-    }
-  else
-    {
-      /* Ethernet */
+  if (check_wireless_interface(ifname)) {
+    /* Wireless */
+    return 1;
+  } else {
+    /* Ethernet */
 #if 0
-      /* Andreas: Perhaps SIOCGIFMEDIA is the way to do this? */
-      struct ifmediareq ifm;
+    /* Andreas: Perhaps SIOCGIFMEDIA is the way to do this? */
+    struct ifmediareq ifm;
 
-      memset(&ifm, 0, sizeof(ifm));
-      strlcpy(ifm.ifm_name, ifname, sizeof(ifm.ifm_name));
-
-      if(ioctl(olsr_cnf->ioctl_s, SIOCGIFMEDIA, &ifm) < 0)
-       {
-         OLSR_PRINTF(1, "Error SIOCGIFMEDIA(%s)\n", ifm.ifm_name);
-         return WEIGHT_ETHERNET_DEFAULT;
-       }
+    memset(&ifm, 0, sizeof(ifm));
+    strlcpy(ifm.ifm_name, ifname, sizeof(ifm.ifm_name));
 
-      OLSR_PRINTF(1, "%s: STATUS 0x%08x\n", ifm.ifm_name, ifm.ifm_status);
-#endif
+    if (ioctl(olsr_cnf->ioctl_s, SIOCGIFMEDIA, &ifm) < 0) {
+      OLSR_PRINTF(1, "Error SIOCGIFMEDIA(%s)\n", ifm.ifm_name);
       return WEIGHT_ETHERNET_DEFAULT;
     }
+
+    OLSR_PRINTF(1, "%s: STATUS 0x%08x\n", ifm.ifm_name, ifm.ifm_status);
+#endif
+    return WEIGHT_ETHERNET_DEFAULT;
+  }
 }
index e45c705..0690610 100644 (file)
@@ -304,7 +304,7 @@ serialize_hello4(struct hello_message *message, struct interface *ifp)
 
   /* Fill HELLO header */
   h->willingness = message->willingness; 
-  h->htime = double_to_me(ifp->hello_etime);
+  h->htime = reltime_to_me(ifp->hello_etime);
 
   memset(&h->reserved, 0, sizeof(olsr_u16_t));
   
@@ -479,7 +479,7 @@ serialize_hello6(struct hello_message *message, struct interface *ifp)
   
   /* Fill packet header */
   h6->willingness = message->willingness; 
-  h6->htime = double_to_me(ifp->hello_etime);
+  h6->htime = reltime_to_me(ifp->hello_etime);
   memset(&h6->reserved, 0, sizeof(olsr_u16_t));
 
   /*
index a592fe0..24e5fb5 100644 (file)
@@ -182,8 +182,8 @@ olsrd_write_cnf(struct olsrd_config *cnf, const char *fname)
   fprintf(fd, "# Fish Eye algorithm\n# 0 = do not use fish eye\n# 1 = use fish eye\n\n");
   fprintf(fd, "LinkQualityFishEye\t%d\n\n", cnf->lq_fish);
 
-  fprintf(fd, "# Link quality window size\n\n");
-  fprintf(fd, "LinkQualityWinSize\t%d\n\n", cnf->lq_wsize);
+  fprintf(fd, "# Link quality aging factor\n\n");
+  fprintf(fd, "LinkQualityAging\t%f\n\n", cnf->lq_aging);
 
   fprintf(fd, "# NAT threshold\n\n");
   fprintf(fd, "NatThreshold\t%f\n\n", cnf->lq_nat_thresh);
@@ -296,7 +296,7 @@ olsrd_write_cnf(struct olsrd_config *cnf, const char *fname)
            {
              while (mult != NULL)
                {
-                 fprintf(fd, "    LinkQualityMult\t%s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof(ipv6_buf)), mult->val);
+                 fprintf(fd, "    LinkQualityMult\t%s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof(ipv6_buf)), (float)(mult->value) / 65536.0);
                  mult = mult->next;
                }
            }
@@ -466,8 +466,8 @@ olsrd_write_cnf_buf(struct olsrd_config *cnf, char *buf, olsr_u32_t bufsize)
   WRITE_TO_BUF("# 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");
   WRITE_TO_BUF("LinkQualityLevel\t%d\n\n", cnf->lq_level);
 
-  WRITE_TO_BUF("# Link quality window size\n\n");
-  WRITE_TO_BUF("LinkQualityWinSize\t%d\n\n", cnf->lq_wsize);
+  WRITE_TO_BUF("# Link quality aging factor\n\n");
+  WRITE_TO_BUF("LinkQualityAging\t%f\n\n", cnf->lq_aging);
 
   WRITE_TO_BUF("# NAT threshold\n\n");
   WRITE_TO_BUF("NatThreshold\t%f\n\n", cnf->lq_nat_thresh);
@@ -592,7 +592,7 @@ olsrd_write_cnf_buf(struct olsrd_config *cnf, char *buf, olsr_u32_t bufsize)
            {
              while (mult != NULL)
                {
-                 WRITE_TO_BUF("    LinkQualityMult\t%s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof (ipv6_buf)), mult->val);
+                 WRITE_TO_BUF("    LinkQualityMult\t%s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof (ipv6_buf)), (float)(mult->value) / 65536.0);
                  mult = mult->next;
                }
            }
index 4e205da..a4ec8bc 100644 (file)
@@ -234,6 +234,12 @@ olsrd_sanity_check_cnf(struct olsrd_config *cnf)
        }
     }
 
+  /* Check Link quality dijkstra limit */
+  if (olsr_cnf->lq_dinter < cnf->pollrate && olsr_cnf->lq_dlimit != 255) {
+       fprintf(stderr, "Link quality dijkstra limit must be higher than pollrate\n");
+       return -1;
+  }
+  
   /* Pollrate */
 
   if(cnf->pollrate < MIN_POLLRATE ||
@@ -285,9 +291,9 @@ olsrd_sanity_check_cnf(struct olsrd_config *cnf)
     }
 
   /* Link quality window size */
-  if(cnf->lq_level && (cnf->lq_wsize < MIN_LQ_WSIZE || cnf->lq_wsize > MAX_LQ_WSIZE))
+  if(cnf->lq_level && (cnf->lq_aging < MIN_LQ_AGING || cnf->lq_aging > MAX_LQ_AGING))
     {
-      fprintf(stderr, "LQ window size %d is not allowed\n", cnf->lq_wsize);
+      fprintf(stderr, "LQ aging factor %f is not allowed\n", cnf->lq_aging);
       return -1;
     }
 
@@ -329,7 +335,7 @@ olsrd_sanity_check_cnf(struct olsrd_config *cnf)
           io->hello_params.validity_time = NEIGHB_HOLD_TIME;
 
         else
-          io->hello_params.validity_time = cnf->lq_wsize * io->hello_params.emission_interval;
+          io->hello_params.validity_time = (int)(REFRESH_INTERVAL / cnf->lq_aging);
       }
 
       if(io->hello_params.emission_interval < cnf->pollrate ||
@@ -463,7 +469,8 @@ set_default_cnf(struct olsrd_config *cnf)
     cnf->lq_fish = DEF_LQ_FISH;
     cnf->lq_dlimit = DEF_LQ_DIJK_LIMIT;
     cnf->lq_dinter = DEF_LQ_DIJK_INTER;
-    cnf->lq_wsize = DEF_LQ_WSIZE;
+    cnf->lq_aging = DEF_LQ_AGING;
+    cnf->lq_algorithm = NULL;
     cnf->lq_nat_thresh = DEF_LQ_NAT_THRESH;
     cnf->clear_screen = DEF_CLEAR_SCREEN;
 
@@ -585,8 +592,10 @@ olsrd_print_cnf(struct olsrd_config *cnf)
 
   printf("LQ Dijkstra limit: %d, %0.2f\n", cnf->lq_dlimit, cnf->lq_dinter);
 
-  printf("LQ window size   : %d\n", cnf->lq_wsize);
+  printf("LQ aging factor  : %f\n", cnf->lq_aging);
 
+  printf("LQ algorithm name: %s\n", cnf->lq_algorithm ? cnf->lq_algorithm : "default");
+  
   printf("NAT threshold    : %f\n", cnf->lq_nat_thresh);
 
   printf("Clear screen     : %s\n", cnf->clear_screen ? "yes" : "no");
@@ -622,7 +631,7 @@ olsrd_print_cnf(struct olsrd_config *cnf)
          
           for (mult = in->cnf->lq_mult; mult != NULL; mult = mult->next)
           {
-            printf("\tLinkQualityMult          : %s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof (ipv6_buf)), mult->val);
+            printf("\tLinkQualityMult          : %s %0.2f\n", inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf, sizeof (ipv6_buf)), (float)(mult->value)/65536.0);
           }
 
           printf("\tAutodetetc changes       : %s\n", in->cnf->autodetect_chg ? "yes" : "no");
index a107e74..03944ae 100644 (file)
@@ -2,7 +2,7 @@
 
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
@@ -103,7 +103,7 @@ static int lq_mult_helper(YYSTYPE ip_addr_arg, YYSTYPE mult_arg)
     }
 
     mult->addr = addr;
-    mult->val = mult_arg->floating;
+    mult->value = (olsr_u32_t)(mult_arg->floating * 65536);
 
     mult->next = walker->cnf->lq_mult;
     walker->cnf->lq_mult = mult;
@@ -189,6 +189,8 @@ static int add_ipv6_addr(YYSTYPE ipaddr_arg, YYSTYPE prefixlen_arg)
 %token TOK_LQ_FISH
 %token TOK_LQ_DLIMIT
 %token TOK_LQ_WSIZE
+%token TOK_LQ_AGING
+%token TOK_LQ_PLUGIN
 %token TOK_LQ_NAT_THRESH
 %token TOK_LQ_MULT
 %token TOK_CLEAR_SCREEN
@@ -243,10 +245,12 @@ stmt:       idebug
           | atcredundancy
           | amprcoverage
           | alq_level
+          | alq_plugin
           | alq_fish
           | alq_dlimit
           | anat_thresh
           | alq_wsize
+          | alq_aging
           | bclear_screen
           | vcomment
 ;
@@ -984,8 +988,22 @@ alq_dlimit: TOK_LQ_DLIMIT TOK_INTEGER TOK_FLOAT
 
 alq_wsize: TOK_LQ_WSIZE TOK_INTEGER
 {
-  PARSER_DEBUG_PRINTF("Link quality window size %d\n", $2->integer);
-  olsr_cnf->lq_wsize = $2->integer;
+  free($2);
+}
+;
+
+alq_aging: TOK_LQ_AGING TOK_FLOAT
+{
+  PARSER_DEBUG_PRINTF("Link quality aging factor %f\n", $2->floating);
+  olsr_cnf->lq_aging = $2->floating;
+  free($2);
+}
+;
+
+alq_plugin: TOK_LQ_PLUGIN TOK_STRING
+{
+  olsr_cnf->lq_algorithm = $2->string;
+  PARSER_DEBUG_PRINTF("LQ Algorithm: %s\n", $2->string);
   free($2);
 }
 ;
index 7519098..acb3f91 100644 (file)
@@ -2,7 +2,7 @@
 
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
@@ -383,6 +383,16 @@ IPV6ADDR {IP6PAT1}|{IP6PAT2}|{IP6PAT3}|{IP6PAT4}|{IP6PAT5}|{IP6PAT6}|{IP6PAT7}|{
     return TOK_LQ_DLIMIT;
 }
 
+"LinkQualityAging" {
+    yylval = NULL;
+    return TOK_LQ_AGING;
+}
+
+"LinkQualityAlgorithm" {
+    yylval = NULL;
+    return TOK_LQ_PLUGIN;
+}
+
 "LinkQualityWinSize" {
     yylval = NULL;
     return TOK_LQ_WSIZE;
index 265d9e0..cce14c9 100644 (file)
@@ -82,7 +82,8 @@ avl_init(struct avl_tree *tree, avl_tree_comp comp)
   tree->first = NULL;
   tree->last = NULL;
   tree->count = 0;
-  tree->comp = comp;
+  
+  tree->comp = comp == avl_comp_ipv4 ? NULL : comp;
 }
 
 static struct avl_node *
index 1d1b294..f71058d 100644 (file)
@@ -43,6 +43,8 @@
 #ifndef _AVL_H
 #define _AVL_H
 
+#include <stddef.h>
+
 /* must be declared here because of circular dependency through "defs.h" */
 
 #define INLINE inline __attribute__((always_inline))
index 9a4784a..7eb4964 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
index 1c00d54..388cb80 100644 (file)
@@ -1,7 +1,11 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
+<<<<<<< /home/rogge/develop/olsrd/olsrd-linkset-refactoring/src/duplicate_set.c
+ * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+=======
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
  * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+>>>>>>> /tmp/duplicate_set.c~other.bvK6d3
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
 #include "common/avl.h"
 #include "olsr.h"
 #include "mid_set.h"
+#include "scheduler.h"
+#include "mantissa.h"
+
+static void olsr_cleanup_duplicate_entry(void *unused);
 
 struct avl_tree duplicate_set;
+struct timer_entry *duplicate_cleanup_timer;
+
 
 void olsr_init_duplicate_set(void) {
   avl_init(&duplicate_set, olsr_cnf->ip_version == AF_INET ? &avl_comp_ipv4 : &avl_comp_ipv6);
+  
+  olsr_set_timer(&duplicate_cleanup_timer, DUPLICATE_CLEANUP_INTERVAL,
+     DUPLICATE_CLEANUP_JITTER, OLSR_TIMER_PERIODIC,
+     &olsr_cleanup_duplicate_entry, NULL, 0);
 }
 
-struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr) {
-  struct duplicate_entry *entry;
-  entry = olsr_malloc(sizeof(struct duplicate_entry), "New duplicate entry");
+struct dup_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr) {
+  struct dup_entry *entry;
+  entry = olsr_malloc(sizeof(struct dup_entry), "New duplicate entry");
   if (entry != NULL) {
     memcpy (&entry->ip, ip, olsr_cnf->ip_version == AF_INET ? sizeof(entry->ip.v4) : sizeof(entry->ip.v6)); 
     entry->seqnr = seqnr;
@@ -63,10 +77,23 @@ struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr)
   return entry;
 }
 
+static void olsr_cleanup_duplicate_entry(void __attribute__ ((unused)) *unused) {
+  struct dup_entry *entry;
+  
+  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+    if (TIMED_OUT(entry->valid_until)) {
+      avl_delete(&duplicate_set, &entry->avl);
+      free (entry);
+    }
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+}
+
 int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
-  struct duplicate_entry *entry;
+  struct dup_entry *entry;
   int diff;
   void *mainIp;
+  clock_t valid_until;
+  
 #ifndef NODEBUG
   struct ipaddr_str buf;
 #endif  
@@ -76,17 +103,25 @@ int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
     mainIp = ip;
   }
   
-  entry = (struct duplicate_entry *)avl_find(&duplicate_set, ip);
+  valid_until = GET_TIMESTAMP(DUPLICATE_VTIME);
+  
+  entry = (struct dup_entry *)avl_find(&duplicate_set, ip);
   if (entry == NULL) {
     entry = olsr_create_duplicate_entry(ip, seqnr);
     if (entry != NULL) {
       avl_insert(&duplicate_set, &entry->avl, 0);
+      entry->valid_until = valid_until;
     }
     return 1; // okay, we process this package
   }
 
   diff = (int)seqnr - (int)(entry->seqnr);
   
+  // update timestamp
+  if (valid_until > entry->valid_until) {
+    entry->valid_until = valid_until;
+  }
+  
   // overflow ?
   if (diff > (1<<15)) {
     diff -= (1<<16);
@@ -131,11 +166,22 @@ int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
 }
 
 void olsr_print_duplicate_table(void) {
-  /* XXX FIXME */
-}
+#ifndef NODEBUG
+  /* The whole function makes no sense without it. */
+  struct dup_entry *entry;
+  const int ipwidth = olsr_cnf->ip_version == AF_INET ? 15 : 30;
+  struct ipaddr_str addrbuf;
+  
+  OLSR_PRINTF(1,
+        "\n--- %s ------------------------------------------------- DUPLICATE SET\n\n"
+        "%-*s %8s %s\n", olsr_wallclock_string(), ipwidth,
+        "Node IP", "DupArray", "VTime");
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * End:
- */
+  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+    OLSR_PRINTF(1, "%-*s %08x %s\n",
+        ipwidth, olsr_ip_to_string(&addrbuf, (union olsr_ip_addr *)(entry->avl.key)),
+        entry->array,
+        olsr_clock_string(entry->valid_until));
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+#endif
+}
index e421345..8833e5b 100644 (file)
@@ -1,7 +1,11 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
+<<<<<<< /home/rogge/develop/olsrd/olsrd-linkset-refactoring/src/duplicate_set.h
+ * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+=======
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
  * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+>>>>>>> /tmp/duplicate_set.h~other.fO3lgV
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
  *
  */
 
-#ifndef DUPLICATE_SET_H_
-#define DUPLICATE_SET_H_
+#ifndef DUPLICATE_SET_2_H_
+#define DUPLICATE_SET_2_H_
 
-#include "common/avl.h"
+#include "defs.h"
 #include "olsr.h"
+#include "mantissa.h"
+#include "common/avl.h"
 
-struct duplicate_entry {
+#define DUPLICATE_CLEANUP_INTERVAL 15000
+#define DUPLICATE_CLEANUP_JITTER 25
+#define DUPLICATE_VTIME 120000
+
+struct dup_entry {
   struct avl_node avl;
   union olsr_ip_addr ip;
   olsr_u16_t seqnr;
   olsr_u16_t too_low_counter;
   olsr_u32_t array;
+  clock_t    valid_until;
 };
 
+AVLNODE2STRUCT(duptree2dupentry, struct dup_entry , avl);
+
 void olsr_init_duplicate_set(void);
-struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr);
+struct dup_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr);
 int olsr_shall_process_message(void *ip, olsr_u16_t seqnr);
 void olsr_print_duplicate_table(void);
 
-#endif /*DUPLICATE_SET_H_*/
+#define OLSR_FOR_ALL_DUP_ENTRIES(dup) \
+{ \
+  struct avl_node *dup_tree_node, *next_dup_tree_node; \
+  for (dup_tree_node = avl_walk_first(&duplicate_set); \
+    dup_tree_node; dup_tree_node = next_dup_tree_node) { \
+    next_dup_tree_node = avl_walk_next(dup_tree_node); \
+    dup = duptree2dupentry(dup_tree_node);
+#define OLSR_FOR_ALL_DUP_ENTRIES_END(dup) }}
+
+#endif /*DUPLICATE_SET_2_H_*/
 
 /*
  * Local Variables:
index d04e20e..59b4fc5 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
 #include "hashing.h"
 #include "defs.h"
 
+/*
+ * Taken from lookup2.c by Bob Jenkins.  (http://burtleburtle.net/bob/c/lookup2.c).
+ * --------------------------------------------------------------------
+ * lookup2.c, by Bob Jenkins, December 1996, Public Domain.
+ * You can use this free for any purpose.  It has no warranty.
+ * --------------------------------------------------------------------
+ */
+
+#define __jhash_mix(a, b, c) \
+{ \
+  a -= b; a -= c; a ^= (c>>13); \
+  b -= c; b -= a; b ^= (a<<8); \
+  c -= a; c -= b; c ^= (b>>13); \
+  a -= b; a -= c; a ^= (c>>12);  \
+  b -= c; b -= a; b ^= (a<<16); \
+  c -= a; c -= b; c ^= (b>>5); \
+  a -= b; a -= c; a ^= (c>>3);  \
+  b -= c; b -= a; b ^= (a<<10); \
+  c -= a; c -= b; c ^= (b>>15); \
+}
+
+static inline olsr_u32_t
+jenkins_hash(const olsr_u8_t * k, olsr_u32_t length)
+{
+  /* k: the key
+   * length: length of the key
+   * initval: the previous hash, or an arbitrary value
+   */
+  olsr_u32_t a, b, c, len;
+
+  /* Set up the internal state */
+  len = length;
+  a = b = 0x9e3779b9;          /* the golden ratio; an arbitrary value */
+  c = 0;                       /* the previous hash value */
+
+  /* handle most of the key */
+  while (len >= 12) {
+    a += (k[0] + ((olsr_u32_t) k[1] << 8) + ((olsr_u32_t) k[2] << 16)
+         + ((olsr_u32_t) k[3] << 24));
+    b += (k[4] + ((olsr_u32_t) k[5] << 8) + ((olsr_u32_t) k[6] << 16)
+         + ((olsr_u32_t) k[7] << 24));
+    c += (k[8] + ((olsr_u32_t) k[9] << 8) + ((olsr_u32_t) k[10] << 16)
+         + ((olsr_u32_t) k[11] << 24));
+
+    __jhash_mix(a, b, c);
+
+    k += 12;
+    len -= 12;
+  }
+
+  c += length;
+  switch (len) {
+  case 11:
+    c += ((olsr_u32_t) k[10] << 24);
+  case 10:
+    c += ((olsr_u32_t) k[9] << 16);
+  case 9:
+    c += ((olsr_u32_t) k[8] << 8);
+    /* the first byte of c is reserved for the length */
+  case 8:
+    b += ((olsr_u32_t) k[7] << 24);
+  case 7:
+    b += ((olsr_u32_t) k[6] << 16);
+  case 6:
+    b += ((olsr_u32_t) k[5] << 8);
+  case 5:
+    b += k[4];
+  case 4:
+    a += ((olsr_u32_t) k[3] << 24);
+  case 3:
+    a += ((olsr_u32_t) k[2] << 16);
+  case 2:
+    a += ((olsr_u32_t) k[1] << 8);
+  case 1:
+    a += k[0];
+  }
+  __jhash_mix(a, b, c);
+
+  return c;
+}
+
+
 /**
- * Hashing function. Creates a key based on
- * an 32-bit address.
+ * Hashing function. Creates a key based on an IP address.
  * @param address the address to hash
  * @return the hash(a value in the (0 to HASHMASK-1) range)
  */
-olsr_u32_t olsr_ip_hashing(const union olsr_ip_addr * address)
+olsr_u32_t
+olsr_ip_hashing(const union olsr_ip_addr *address)
 {
   olsr_u32_t hash;
-  if(olsr_cnf->ip_version == AF_INET) {
-    /* IPv4 */  
-    const olsr_u8_t * const v4x = (const olsr_u8_t *)&address->v4;
-    hash = v4x[0] ^ v4x[1] ^ v4x[2] ^ v4x[3];
-  } else {
-    /* IPv6 */
-    const char * const tmp = (const char *)&address->v6;
-    hash = ntohl(*tmp);
+
+  switch (olsr_cnf->ip_version) {
+  case AF_INET:
+    hash = jenkins_hash((const olsr_u8_t *)&address->v4,
+                        sizeof(olsr_u32_t));
+    break;
+  case AF_INET6:
+    hash = jenkins_hash((const olsr_u8_t *)&address->v6,
+                       sizeof(struct in6_addr));
+    break;
+  default:
+    hash = 0;
+    break;
+
   }
   return hash & HASHMASK;
 }
index 3a8f58f..02cfa2a 100644 (file)
@@ -233,11 +233,6 @@ olsr_expire_hna_net_entry(void *context)
     DEQUEUE_ELEM(hna_gw);
     free(hna_gw);
   }
-
-  DEQUEUE_ELEM(net_to_delete);
-  free(net_to_delete);
-
-  changes_hna = OLSR_TRUE;
 }
 
 /**
@@ -255,7 +250,7 @@ olsr_expire_hna_net_entry(void *context)
  */
 void
 olsr_update_hna_entry(const union olsr_ip_addr *gw, const union olsr_ip_addr *net,
-                      olsr_u8_t prefixlen, const float vtime)
+                      olsr_u8_t prefixlen, olsr_reltime vtime)
 {
   struct hna_entry *gw_entry = olsr_lookup_hna_gw(gw);
   struct hna_net *net_entry;
@@ -273,7 +268,7 @@ olsr_update_hna_entry(const union olsr_ip_addr *gw, const union olsr_ip_addr *ne
     changes_hna = OLSR_TRUE;
   }
 
-  olsr_set_timer(&net_entry->hna_net_timer, vtime * MSEC_PER_SEC,
+  olsr_set_timer(&net_entry->hna_net_timer, vtime,
                  OLSR_HNA_NET_JITTER, OLSR_TIMER_ONESHOT,
                  &olsr_expire_hna_net_entry, net_entry, 0);
 }
index 1d268f7..776dc77 100644 (file)
@@ -44,6 +44,7 @@
 
 #include "hashing.h"
 #include "olsr_types.h"
+#include "mantissa.h"
 
 #include <time.h>
 
@@ -97,10 +98,7 @@ struct hna_net *
 olsr_add_hna_net(struct hna_entry *, const union olsr_ip_addr *, olsr_u8_t);
 
 void
-olsr_update_hna_entry(const union olsr_ip_addr *, const union olsr_ip_addr *, olsr_u8_t, const float);
-
-void
-olsr_time_out_hna_set(void *);
+olsr_update_hna_entry(const union olsr_ip_addr *, const union olsr_ip_addr *, olsr_u8_t, olsr_reltime);
 
 void
 olsr_print_hna_set(void);
index 50e0bce..fe735a2 100644 (file)
@@ -147,15 +147,15 @@ olsr_process_hysteresis(struct link_entry *entry)
  *@return nada
  */
 void
-olsr_update_hysteresis_hello(struct link_entry *entry, double htime)
+olsr_update_hysteresis_hello(struct link_entry *entry, olsr_reltime htime)
 {
 #ifndef NODEBUG
   struct ipaddr_str buf;
 #endif
-  OLSR_PRINTF(3, "HYST[%s]: HELLO update vtime %f\n",
-              olsr_ip_to_string(&buf, &entry->neighbor_iface_addr), htime*1.5);
+  OLSR_PRINTF(3, "HYST[%s]: HELLO update vtime %u ms\n",
+              olsr_ip_to_string(&buf, &entry->neighbor_iface_addr), htime+htime/2);
 
-  olsr_set_timer(&entry->link_hello_timer, htime * 1500, OLSR_LINK_HELLO_JITTER,
+  olsr_set_timer(&entry->link_hello_timer, htime + htime/2, OLSR_LINK_HELLO_JITTER,
                  OLSR_TIMER_PERIODIC, &olsr_expire_link_hello_timer, entry, 0);
 
   return;
index f4eea6a..22a017e 100644 (file)
@@ -41,6 +41,7 @@
 #define _OLSR_HYSTERESIS
 
 #include "link_set.h"
+#include "mantissa.h"
 
 float
 olsr_hyst_calc_stability
@@ -53,7 +54,7 @@ float
 olsr_hyst_calc_instability(float);
 
 void
-olsr_update_hysteresis_hello(struct link_entry *, double);
+olsr_update_hysteresis_hello(struct link_entry *, olsr_reltime);
 
 void
 update_hysteresis_incoming(union olsr_ip_addr *, struct interface *, olsr_u16_t);
index 606980d..48a7df8 100644 (file)
@@ -335,7 +335,6 @@ del_ifchgf(int (*f)(struct interface *, int))
 
   return 0;
 }
-
 /*
  * Local Variables:
  * c-basic-offset: 2
index 8ed76f1..493e9aa 100644 (file)
@@ -52,6 +52,7 @@
 #include <time.h>
 
 #include "olsr_types.h"
+#include "mantissa.h"
 
 #define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
 
@@ -118,7 +119,6 @@ struct olsr_netbuf
   int reserved;   /* Plugins can reserve space in buffers */
 };
 
-
 /**
  *A struct containing all necessary information about each
  *interface participating in the OLSRD routing
@@ -135,14 +135,16 @@ struct interface
   /* IP independent */
   union         olsr_ip_addr ip_addr;
   int           is_hcif;                        /* Is this a emulated host-client if? */
-  int           olsr_socket;                    /* The broadcast socket for this interface */
-  int          int_metric;                     /* metric of interface */
-  int           int_mtu;                        /* MTU of interface */
-  int          int_flags;                      /* see below */
-  int           if_index;                       /* Kernels index of this interface */
-  int           is_wireless;                    /* wireless interface or not*/
+  
+  int           olsr_socket;        /* The broadcast socket for this interface */
+  
+  int            int_metric;                   /* metric of interface */
+  int           int_mtu;        /* MTU of interface */
+  int            int_flags;                    /* see below */
+  int           if_index;       /* Kernels index of this interface */
+  int           is_wireless;    /* wireless interface or not*/
   char         *int_name;                      /* from kernel if structure */
-  olsr_u16_t    olsr_seqnum;                    /* Olsr message seqno */
+  olsr_u16_t    olsr_seqnum;    /* Olsr message seqno */
 
   /* Periodic message generation timers */
   struct timer_entry *hello_gen_timer;
@@ -159,7 +161,7 @@ struct interface
   } nic_state;
 #endif
 
-  float         hello_etime;
+  olsr_reltime  hello_etime;
   struct        vtimes valtimes;
 
   clock_t       fwdtimer;                       /* Timeout for OLSR forwarding on this if */
index 5854b51..6aa14d3 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
@@ -38,7 +39,6 @@
  *
  */
 
-
 /*
  * Link sensing database for the OLSR routing daemon
  */
@@ -51,7 +51,7 @@
 #include "neighbor_table.h"
 #include "olsr.h"
 #include "scheduler.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "net_olsr.h"
 #include "ipcalc.h"
 #include "lq_plugin.h"
 /* head node for all link sets */
 struct list_node link_entry_head;
 
-olsr_bool link_changes; /* is set if changes occur in MPRS set */ 
+olsr_bool link_changes;                       /* is set if changes occur in MPRS set */
 
 void
-signal_link_changes(olsr_bool val) /* XXX ugly */
-{
+signal_link_changes(olsr_bool val)
+{                              /* XXX ugly */
   link_changes = val;
 }
 
-static int
-check_link_status(const struct hello_message *message, const struct interface *in_if);
-
-static struct link_entry *
-add_link_entry(const union olsr_ip_addr *, const union olsr_ip_addr *, const union olsr_ip_addr *, double, double, const struct interface *);
-
-static int
-get_neighbor_status(const union olsr_ip_addr *);
+/* Prototypes. */
+static int check_link_status(const struct hello_message *message,
+                             const struct interface *in_if);
+static struct link_entry *add_link_entry(const union olsr_ip_addr *,
+                                        const union olsr_ip_addr *,
+                                        const union olsr_ip_addr *, olsr_reltime,
+                                        olsr_reltime, const struct interface *);
+static int get_neighbor_status(const union olsr_ip_addr *);
 
 void
 olsr_init_link_set(void)
@@ -89,267 +89,248 @@ olsr_init_link_set(void)
  * Get the status of a link. The status is based upon different
  * timeouts in the link entry.
  *
- *@param remote address of the remote interface
- *
- *@return the link status of the link
+ * @param remote address of the remote interface
+ * @return the link status of the link
  */
 int
 lookup_link_status(const struct link_entry *entry)
 {
 
-  if(entry == NULL || list_is_empty(&link_entry_head)) {
+  if (entry == NULL || list_is_empty(&link_entry_head)) {
     return UNSPEC_LINK;
   }
 
   /*
    * Hysteresis
    */
-  if(olsr_cnf->use_hysteresis)
-    {
-      /*
-       if L_LOST_LINK_time is not expired, the link is advertised
-       with a link type of LOST_LINK.
-      */
+  if (olsr_cnf->use_hysteresis) {
 
-      if(!TIMED_OUT(entry->L_LOST_LINK_time))
-       return LOST_LINK;
-      /*
-       otherwise, if L_LOST_LINK_time is expired and L_link_pending
-       is set to "true", the link SHOULD NOT be advertised at all;
-      */
-      if(entry->L_link_pending == 1)
-       {
+    /*
+     * if L_LOST_LINK_time is not expired, the link is advertised
+     * with a link type of LOST_LINK.
+     */
+
+    if (!TIMED_OUT(entry->L_LOST_LINK_time)) {
+      return LOST_LINK;
+    }
+
+    /*
+     * otherwise, if L_LOST_LINK_time is expired and L_link_pending
+     * is set to "true", the link SHOULD NOT be advertised at all;
+     */
+    if (entry->L_link_pending == 1) {
 #ifndef NODEBUG
-          struct ipaddr_str buf;
-         OLSR_PRINTF(3, "HYST[%s]: Setting to HIDE\n", olsr_ip_to_string(&buf, &entry->neighbor_iface_addr));
+      struct ipaddr_str buf;
+      OLSR_PRINTF(3, "HYST[%s]: Setting to HIDE\n",
+                 olsr_ip_to_string(&buf, &entry->neighbor_iface_addr));
 #endif
-         return HIDE_LINK;
-       }
-      /*
-       otherwise, if L_LOST_LINK_time is expired and L_link_pending
-       is set to "false", the link is advertised as described
-       previously in section 6.
-      */
+      return HIDE_LINK;
     }
 
+    /*
+     * otherwise, if L_LOST_LINK_time is expired and L_link_pending
+     * is set to "false", the link is advertised as described
+     * previously in section 6.
+     */
+  }
+
   if (entry->link_sym_timer) {
     return SYM_LINK;
   }
 
-  if(!TIMED_OUT(entry->ASYM_time))
+  if (!TIMED_OUT(entry->ASYM_time)) {
     return ASYM_LINK;
+  }
 
   return LOST_LINK;
-
-
 }
 
 
 /**
- *Find the "best" link status to a
- *neighbor
- *
- *@param address the address to check for
+ * Find the "best" link status to a neighbor
  *
- *@return SYM_LINK if a symmetric link exists 0 if not
+ * @param address the address to check for
+ * @return SYM_LINK if a symmetric link exists 0 if not
  */
 static int
 get_neighbor_status(const union olsr_ip_addr *address)
 {
   const union olsr_ip_addr *main_addr;
-  struct interface   *ifs;
-
-  //printf("GET_NEIGHBOR_STATUS\n");
+  struct interface *ifs;
 
   /* Find main address */
-  if(!(main_addr = mid_lookup_main_addr(address)))
+  if (!(main_addr = mid_lookup_main_addr(address)))
     main_addr = address;
 
-  //printf("\tmain: %s\n", olsr_ip_to_string(main_addr));
-
   /* Loop trough local interfaces to check all possebilities */
-  for(ifs = ifnet; ifs != NULL; ifs = ifs->int_next)
-    {
-      struct mid_address   *aliases;
-      struct link_entry  *lnk = lookup_link_entry(main_addr, NULL, ifs);
-
-      //printf("\tChecking %s->", olsr_ip_to_string(&ifs->ip_addr));
-      //printf("%s : ", olsr_ip_to_string(main_addr)); 
-      if(lnk != NULL)
-       {
-         //printf("%d\n", lookup_link_status(link));
-         if(lookup_link_status(lnk) == SYM_LINK)
-           return SYM_LINK;
-       }
-      /* Get aliases */
-      for(aliases = mid_lookup_aliases(main_addr);
-         aliases != NULL;
-         aliases = aliases->next_alias)
-       {
-         //printf("\tChecking %s->", olsr_ip_to_string(&ifs->ip_addr));
-         //printf("%s : ", olsr_ip_to_string(&aliases->address)); 
-            lnk = lookup_link_entry(&aliases->alias, NULL, ifs);
-            if(lnk != NULL)
-           {
-             //printf("%d\n", lookup_link_status(link));
-
-             if(lookup_link_status(lnk) == SYM_LINK)
-               return SYM_LINK;
-           }
-       }
+  for (ifs = ifnet; ifs != NULL; ifs = ifs->int_next) {
+    struct mid_address *aliases;
+    struct link_entry *lnk = lookup_link_entry(main_addr, NULL, ifs);
+
+    if (lnk != NULL) {
+      if (lookup_link_status(lnk) == SYM_LINK)
+       return SYM_LINK;
+    }
+
+    /* Get aliases */
+    for (aliases = mid_lookup_aliases(main_addr);
+        aliases != NULL; aliases = aliases->next_alias) {
+
+      lnk = lookup_link_entry(&aliases->alias, NULL, ifs);
+      if (lnk && (lookup_link_status(lnk) == SYM_LINK)) {
+         return SYM_LINK;
+      }
     }
-  
+  }
+
   return 0;
 }
 
 /**
  * Find best link to a neighbor
  */
-
 struct link_entry *
 get_best_link_to_neighbor(const union olsr_ip_addr *remote)
 {
   const union olsr_ip_addr *main_addr;
   struct link_entry *walker, *good_link, *backup_link;
+  struct interface *tmp_if;
   int curr_metric = MAX_IF_METRIC;
   olsr_linkcost curr_lcost = LINK_COST_BROKEN;
-  
-  // main address lookup
+  olsr_linkcost tmp_lc;
 
+  /* main address lookup */
   main_addr = mid_lookup_main_addr(remote);
 
-  // "remote" *already is* the main address
-
-  if (main_addr == NULL)
+  /* "remote" *already is* the main address */
+  if (!main_addr) {
     main_addr = remote;
+  }
 
-  // we haven't selected any links, yet
-
+  /* we haven't selected any links, yet */
   good_link = NULL;
   backup_link = NULL;
 
-  // loop through all links that we have
-
+  /* loop through all links that we have */
   OLSR_FOR_ALL_LINK_ENTRIES(walker) {
 
     /* if this is not a link to the neighour in question, skip */
     if (!ipequal(&walker->neighbor->neighbor_main_addr, main_addr))
       continue;
 
-    // handle the non-LQ, RFC-compliant case
+    if (olsr_cnf->lq_level == 0) {
 
-    if (olsr_cnf->lq_level == 0)
-    {
-      struct interface *tmp_if;
+      /*
+       * handle the non-LQ, RFC-compliant case
+       */
 
-      // find the interface for the link - we select the link with the
-      // best local interface metric
+      /*
+       * find the interface for the link.
+       * we select the link with the best local interface metric.
+       */
       tmp_if = walker->if_name ? if_ifwithname(walker->if_name) :
-              if_ifwithaddr(&walker->local_iface_addr);
+       if_ifwithaddr(&walker->local_iface_addr);
 
-      if(!tmp_if)
+      if (!tmp_if) {
        continue;
+      }
 
-      // is this interface better than anything we had before?
-
+      /*
+       * is this interface better than anything we had before ?
+       * use the requested remote interface address as a tie-breaker
+       */
       if ((tmp_if->int_metric < curr_metric) ||
-          // use the requested remote interface address as a tie-breaker
-          ((tmp_if->int_metric == curr_metric) && 
-           ipequal(&walker->local_iface_addr, remote)))
-      {
-        // memorize the interface's metric
-
-        curr_metric = tmp_if->int_metric;
-
-        // prefer symmetric links over asymmetric links
-
-        if (lookup_link_status(walker) == SYM_LINK)
-          good_link = walker;
-
-        else
-          backup_link = walker;
+         ((tmp_if->int_metric == curr_metric) &&
+          ipequal(&walker->local_iface_addr, remote))) {
+
+       /* memorize the interface's metric */
+       curr_metric = tmp_if->int_metric;
+
+       /* prefer symmetric links over asymmetric links */
+       if (lookup_link_status(walker) == SYM_LINK) {
+         good_link = walker;
+        } else {
+         backup_link = walker;
+        }
       }
-    }
-
-    // handle the LQ, non-RFC compliant case
-
-    else
-    {
-      olsr_linkcost tmp_lc;
-
-      // get the link cost
+    } else {
 
-      tmp_lc = walker->linkcost; 
-
-      // is this link better than anything we had before?
-             
-      if((tmp_lc < curr_lcost) ||
-         // use the requested remote interface address as a tie-breaker
-         ((tmp_lc == curr_lcost) && ipequal(&walker->local_iface_addr, remote)))
-      {
-        // memorize the link quality
-
-        curr_lcost = tmp_lc;
-
-        // prefer symmetric links over asymmetric links
+      /*
+       * handle the LQ, non-RFC compliant case.
+       */
 
-        if(lookup_link_status(walker) == SYM_LINK)
-          good_link = walker;
+      /* get the link cost */
+      tmp_lc = walker->linkcost;
 
-        else
-          backup_link = walker;
+      /*
+       * is this link better than anything we had before ?
+       * use the requested remote interface address as a tie-breaker.
+       */
+      if ((tmp_lc < curr_lcost) ||
+          ((tmp_lc == curr_lcost) &&
+           ipequal(&walker->local_iface_addr, remote))) {
+
+       /* memorize the link quality */
+       curr_lcost = tmp_lc;
+
+       /* prefer symmetric links over asymmetric links */
+       if (lookup_link_status(walker) == SYM_LINK) {
+         good_link = walker;
+        } else {
+         backup_link = walker;
+        }
       }
     }
   } OLSR_FOR_ALL_LINK_ENTRIES_END(walker);
 
-  // if we haven't found any symmetric links, try to return an
-  // asymmetric link
-
+  /*
+   * if we haven't found any symmetric links, try to return an asymmetric link.
+   */
   return good_link ? good_link : backup_link;
 }
 
-static void set_loss_link_multiplier(struct link_entry *entry)
+static void
+set_loss_link_multiplier(struct link_entry *entry)
 {
   struct interface *inter;
   struct olsr_if *cfg_inter;
   struct olsr_lq_mult *mult;
-  float val = -1.0;
+  olsr_u32_t val = 0;
   union olsr_ip_addr null_addr;
 
-  // find the interface for the link
-
+  /* find the interface for the link */
   inter = if_ifwithaddr(&entry->local_iface_addr);
 
-  // find the interface configuration for the interface
-
-  for (cfg_inter = olsr_cnf->interfaces; cfg_inter != NULL;
-       cfg_inter = cfg_inter->next)
-    if (cfg_inter->interf == inter)
+  /* find the interface configuration for the interface */
+  for (cfg_inter = olsr_cnf->interfaces; cfg_inter;
+       cfg_inter = cfg_inter->next) {
+    if (cfg_inter->interf == inter) {
       break;
+    }
+  }
 
-  // create a null address for comparison
-
-  memset(&null_addr, 0, sizeof (union olsr_ip_addr));
-
-  // loop through the multiplier entries
+  /* create a null address for comparison */
+  memset(&null_addr, 0, sizeof(union olsr_ip_addr));
 
-  for (mult = cfg_inter->cnf->lq_mult; mult != NULL; mult = mult->next)
-  {
-    // use the default multiplier only if there isn't any entry that
-    // has a matching IP address
+  /* loop through the multiplier entries */
+  for (mult = cfg_inter->cnf->lq_mult; mult != NULL; mult = mult->next) {
 
+    /*
+     * use the default multiplier only if there isn't any entry that
+     * has a matching IP address.
+     */
     if ((ipequal(&mult->addr, &null_addr) && val < 0.0) ||
-        ipequal(&mult->addr, &entry->neighbor_iface_addr))
-      val = mult->val;
+       ipequal(&mult->addr, &entry->neighbor_iface_addr)) {
+      val = mult->value;
+    }
   }
 
-  // if we have not found an entry, then use the default multiplier
-
-  if (val < 0)
-    val = 1.0;
-
-  // store the multiplier
+  /* if we have not found an entry, then use the default multiplier */
+  if (val == 0) {
+    val = 65536;
+  }
 
+  /* store the multiplier */
   entry->loss_link_multiplier = val;
 }
 
@@ -397,6 +378,7 @@ olsr_delete_link_entry_by_ip(const union olsr_ip_addr *int_addr)
   OLSR_FOR_ALL_LINK_ENTRIES(link) {
     if (ipequal(int_addr, &link->local_iface_addr)) {
       olsr_delete_link_entry(link);
+      break;
     }
   } OLSR_FOR_ALL_LINK_ENTRIES_END(link);
 }
@@ -408,15 +390,15 @@ static void
 olsr_expire_link_loss_timer(void *context)
 {
   struct link_entry *link;
-  
+
   link = (struct link_entry *)context;
 
   /* count the lost packet */
   olsr_update_packet_loss_worker(link, OLSR_TRUE);
 
   /* next timeout in 1.0 x htime */
-  olsr_change_timer(link->link_loss_timer, link->loss_hello_int * MSEC_PER_SEC,
-                    OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC);
+  olsr_change_timer(link->link_loss_timer, link->loss_helloint,
+                   OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC);
 }
 
 /**
@@ -428,15 +410,15 @@ olsr_expire_link_sym_timer(void *context)
   struct link_entry *link;
 
   link = (struct link_entry *)context;
-  link->link_sym_timer = NULL; /* be pedandic */
+  link->link_sym_timer = NULL; /* be pedandic */
 
   if (link->prev_status != SYM_LINK) {
     return;
-  } 
+  }
 
   link->prev_status = lookup_link_status(link);
   update_neighbor_status(link->neighbor,
-                         get_neighbor_status(&link->neighbor_iface_addr));
+                        get_neighbor_status(&link->neighbor_iface_addr));
   changes_neighborhood = OLSR_TRUE;
 }
 
@@ -456,19 +438,19 @@ olsr_expire_link_hello_timer(void *context)
   link->L_link_quality = olsr_hyst_calc_instability(link->L_link_quality);
 
   OLSR_PRINTF(1, "HYST[%s] HELLO timeout %f\n",
-              olsr_ip_to_string(&buf, &link->neighbor_iface_addr),
-              link->L_link_quality);
+             olsr_ip_to_string(&buf, &link->neighbor_iface_addr),
+             link->L_link_quality);
 
   /* Update hello_timeout - NO SLACK THIS TIME */
-  olsr_change_timer(link->link_hello_timer, link->last_htime * MSEC_PER_SEC,
-                    OLSR_LINK_JITTER, OLSR_TIMER_PERIODIC);
+  olsr_change_timer(link->link_hello_timer, link->last_htime,
+                   OLSR_LINK_JITTER, OLSR_TIMER_PERIODIC);
 
   /* Update hysteresis values */
   olsr_process_hysteresis(link);
-         
+
   /* update neighbor status */
   update_neighbor_status(link->neighbor,
-                         get_neighbor_status(&link->neighbor_iface_addr));
+                        get_neighbor_status(&link->neighbor_iface_addr));
 
   /* Update seqno - not mentioned in the RFC... kind of a hack.. */
   link->olsr_seqno++;
@@ -483,7 +465,7 @@ olsr_expire_link_entry(void *context)
   struct link_entry *link;
 
   link = (struct link_entry *)context;
-  link->link_timer = NULL; /* be pedandic */
+  link->link_timer = NULL;     /* be pedandic */
 
   olsr_delete_link_entry(link);
 }
@@ -495,32 +477,32 @@ void
 olsr_set_link_timer(struct link_entry *link, unsigned int rel_timer)
 {
   olsr_set_timer(&link->link_timer, rel_timer, OLSR_LINK_JITTER,
-                 OLSR_TIMER_ONESHOT, &olsr_expire_link_entry, link, 0);
+                OLSR_TIMER_ONESHOT, &olsr_expire_link_entry, link, 0);
 }
 
 /**
- *Nothing mysterious here.
- *Adding a new link entry to the link set.
+ * Nothing mysterious here.
+ * Adding a new link entry to the link set.
  *
- *@param local the local IP address
- *@param remote the remote IP address
- *@param remote_main the remote nodes main address
- *@param vtime the validity time of the entry
- *@param htime the HELLO interval of the remote node
- *@param local_if the local interface
+ * @param local the local IP address
+ * @param remote the remote IP address
+ * @param remote_main the remote nodes main address
+ * @param vtime the validity time of the entry
+ * @param htime the HELLO interval of the remote node
+ * @param local_if the local interface
+ * @return the new link_entry
  */
-
 static struct link_entry *
 add_link_entry(const union olsr_ip_addr *local,
-               const union olsr_ip_addr *remote,
-               const union olsr_ip_addr *remote_main,
-               double vtime,
-               double htime,
-               const struct interface *local_if)
+              const union olsr_ip_addr *remote,
+              const union olsr_ip_addr *remote_main,
+              olsr_reltime vtime, olsr_reltime htime, const struct interface *local_if)
 {
   struct link_entry *new_link;
   struct neighbor_entry *neighbor;
-  struct link_entry *tmp_link_set = lookup_link_entry(remote, remote_main, local_if);
+  struct link_entry *tmp_link_set;
+
+  tmp_link_set = lookup_link_entry(remote, remote_main, local_if);
   if (tmp_link_set) {
     return tmp_link_set;
   }
@@ -535,21 +517,23 @@ add_link_entry(const union olsr_ip_addr *local,
 #ifndef NODEBUG
     struct ipaddr_str localbuf, rembuf;
 #endif
-    OLSR_PRINTF(1, "Adding %s=>%s to link set\n", olsr_ip_to_string(&localbuf, local), olsr_ip_to_string(&rembuf, remote));
+    OLSR_PRINTF(1, "Adding %s=>%s to link set\n",
+               olsr_ip_to_string(&localbuf, local), olsr_ip_to_string(&rembuf,
+                                                                      remote));
   }
 #endif
 
   /* a new tuple is created with... */
-
   new_link = olsr_malloc_link_entry("new link entry");
-  
+
   /* copy if_name, if it is defined */
-  if (local_if->int_name)
-    {
-      new_link->if_name = olsr_malloc(strlen(local_if->int_name)+1, "target of if_name in new link entry");
-      strcpy(new_link->if_name, local_if->int_name);
-    } else 
-      new_link->if_name = NULL;
+  if (local_if->int_name) {
+    new_link->if_name =
+      olsr_malloc(strlen(local_if->int_name) + 1,
+                 "target of if_name in new link entry");
+    strcpy(new_link->if_name, local_if->int_name);
+  } else
+    new_link->if_name = NULL;
 
   /* shortcut to interface. XXX refcount */
   new_link->inter = local_if;
@@ -558,39 +542,37 @@ add_link_entry(const union olsr_ip_addr *local,
    * L_local_iface_addr = Address of the interface
    * which received the HELLO message
    */
-  //printf("\tLocal IF: %s\n", olsr_ip_to_string(local));
   new_link->local_iface_addr = *local;
+
   /* L_neighbor_iface_addr = Source Address */
   new_link->neighbor_iface_addr = *remote;
 
   /* L_time = current time + validity time */
-  olsr_set_link_timer(new_link, vtime * MSEC_PER_SEC);
+  olsr_set_link_timer(new_link, vtime);
 
   new_link->prev_status = ASYM_LINK;
 
   /* HYSTERESIS */
-  if(olsr_cnf->use_hysteresis)
-    {
-      new_link->L_link_pending = 1;
-      new_link->L_LOST_LINK_time = GET_TIMESTAMP(vtime*1000);
-      olsr_update_hysteresis_hello(new_link, htime);
-      new_link->last_htime = htime;
-      new_link->olsr_seqno = 0;
-      new_link->olsr_seqno_valid = OLSR_FALSE;
-    }
+  if (olsr_cnf->use_hysteresis) {
+    new_link->L_link_pending = 1;
+    new_link->L_LOST_LINK_time = GET_TIMESTAMP(vtime);
+    olsr_update_hysteresis_hello(new_link, htime);
+    new_link->last_htime = htime;
+    new_link->olsr_seqno = 0;
+    new_link->olsr_seqno_valid = OLSR_FALSE;
+  }
 
   new_link->L_link_quality = 0.0;
 
-  if (olsr_cnf->lq_level > 0)
-    {
-      new_link->loss_hello_int = htime;
+  if (olsr_cnf->lq_level > 0) {
+    new_link->loss_helloint = htime;
 
-      olsr_set_timer(&new_link->link_loss_timer, htime * 1500,
-                     OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC,
-                     &olsr_expire_link_loss_timer, new_link, 0);
+    olsr_set_timer(&new_link->link_loss_timer, htime + htime/2,
+                  OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC,
+                  &olsr_expire_link_loss_timer, new_link, 0);
 
-      set_loss_link_multiplier(new_link);
-    }
+    set_loss_link_multiplier(new_link);
+  }
 
   new_link->linkcost = LINK_COST_BROKEN;
 
@@ -603,16 +585,16 @@ add_link_entry(const union olsr_ip_addr *local,
 
   /* Neighbor MUST exist! */
   neighbor = olsr_lookup_neighbor_table(remote_main);
-  if(neighbor == NULL)
-    {
+  if (!neighbor) {
 #ifdef DEBUG
 #ifndef NODEBUG
-      struct ipaddr_str buf;
+    struct ipaddr_str buf;
 #endif
-      OLSR_PRINTF(3, "ADDING NEW NEIGHBOR ENTRY %s FROM LINK SET\n", olsr_ip_to_string(&buf, remote_main));
+    OLSR_PRINTF(3, "ADDING NEW NEIGHBOR ENTRY %s FROM LINK SET\n",
+               olsr_ip_to_string(&buf, remote_main));
 #endif
-      neighbor = olsr_insert_neighbor_table(remote_main);
-    }
+    neighbor = olsr_insert_neighbor_table(remote_main);
+  }
 
   neighbor->linkcount++;
   new_link->neighbor = neighbor;
@@ -633,37 +615,37 @@ check_neighbor_link(const union olsr_ip_addr *int_addr)
   struct link_entry *link;
 
   OLSR_FOR_ALL_LINK_ENTRIES(link) {
-    if (ipequal(int_addr, &link->neighbor_iface_addr))
+    if (ipequal(int_addr, &link->neighbor_iface_addr)) {
       return lookup_link_status(link);
+    }
   } OLSR_FOR_ALL_LINK_ENTRIES_END(link);
 
   return UNSPEC_LINK;
 }
 
-
 /**
- *Lookup a link entry
- *
- *@param remote the remote interface address
- *@param remote_main the remote nodes main address
- *@param local the local interface address
+ * Lookup a link entry
  *
- *@return the link entry if found, NULL if not
+ * @param remote the remote interface address
+ * @param remote_main the remote nodes main address
+ * @param local the local interface address
+ * @return the link entry if found, NULL if not
  */
 struct link_entry *
 lookup_link_entry(const union olsr_ip_addr *remote,
-                  const union olsr_ip_addr *remote_main,
-                  const struct interface *local)
+                 const union olsr_ip_addr *remote_main,
+                 const struct interface *local)
 {
   struct link_entry *link;
 
   OLSR_FOR_ALL_LINK_ENTRIES(link) {
-    if(ipequal(remote, &link->neighbor_iface_addr) &&
-       (link->if_name ? !strcmp(link->if_name, local->int_name)
-        : ipequal(&local->ip_addr, &link->local_iface_addr)) &&
+    if (ipequal(remote, &link->neighbor_iface_addr) &&
+       (link->if_name ? !strcmp(link->if_name, local->int_name)
+        : ipequal(&local->ip_addr, &link->local_iface_addr)) &&
 
-       /* check the remote-main address only if there is one given */
-       (!remote_main || ipequal(remote_main, &link->neighbor->neighbor_main_addr))) {
+       /* check the remote-main address only if there is one given */
+       (!remote_main
+        || ipequal(remote_main, &link->neighbor->neighbor_main_addr))) {
       return link;
     }
   } OLSR_FOR_ALL_LINK_ENTRIES_END(link);
@@ -671,99 +653,80 @@ lookup_link_entry(const union olsr_ip_addr *remote,
   return NULL;
 }
 
-
-
-
-
-
-
 /**
- *Update a link entry. This is the "main entrypoint" in
- *the link-sensing. This function is called from the HELLO
- *parser function.
- *It makes sure a entry is updated or created.
+ * Update a link entry. This is the "main entrypoint" in
+ * the link-sensing. This function is called from the HELLO
+ * parser function. It makes sure a entry is updated or created.
  *
- *@param local the local IP address
- *@param remote the remote IP address
- *@param message the HELLO message
- *@param in_if the interface on which this HELLO was received
- *
- *@return the link_entry struct describing this link entry
+ * @param local the local IP address
+ * @param remote the remote IP address
+ * @param message the HELLO message
+ * @param in_if the interface on which this HELLO was received
+ * @return the link_entry struct describing this link entry
  */
 struct link_entry *
-update_link_entry(const union olsr_ip_addr *local, 
-                 const union olsr_ip_addr *remote, 
-                 const struct hello_message *message, 
+update_link_entry(const union olsr_ip_addr *local,
+                 const union olsr_ip_addr *remote,
+                 const struct hello_message *message,
                  const struct interface *in_if)
 {
   struct link_entry *entry;
 
   /* Add if not registered */
-  entry = add_link_entry(local, remote, &message->source_addr, message->vtime, message->htime, in_if);
+  entry =
+    add_link_entry(local, remote, &message->source_addr, message->vtime,
+                  message->htime, in_if);
 
   /* Update ASYM_time */
-  //printf("Vtime is %f\n", message->vtime);
-  /* L_ASYM_time = current time + validity time */
   entry->vtime = message->vtime;
-  entry->ASYM_time = GET_TIMESTAMP(message->vtime*1000);
-  
+  entry->ASYM_time = GET_TIMESTAMP(message->vtime);
+
   entry->prev_status = check_link_status(message, in_if);
-  
-  //printf("Status %d\n", status);
-  
-  switch(entry->prev_status)
-    {
-    case(LOST_LINK):
-      olsr_stop_timer(entry->link_sym_timer);
-      entry->link_sym_timer = NULL;
-      break;
-    case(SYM_LINK):
-    case(ASYM_LINK):
-      /* L_SYM_time = current time + validity time */
-      olsr_set_timer(&entry->link_sym_timer, message->vtime * MSEC_PER_SEC,
-                     OLSR_LINK_SYM_JITTER, OLSR_TIMER_ONESHOT,
-                     &olsr_expire_link_sym_timer, entry, 0);
-
-      /* L_time = L_SYM_time + NEIGHB_HOLD_TIME */
-      olsr_set_link_timer(entry, (message->vtime + NEIGHB_HOLD_TIME) *
-                          MSEC_PER_SEC);
-      break;
-    default:;
-    }
+
+  switch (entry->prev_status) {
+  case (LOST_LINK):
+    olsr_stop_timer(entry->link_sym_timer);
+    entry->link_sym_timer = NULL;
+    break;
+  case (SYM_LINK):
+  case (ASYM_LINK):
+
+    /* L_SYM_time = current time + validity time */
+    olsr_set_timer(&entry->link_sym_timer, message->vtime,
+                  OLSR_LINK_SYM_JITTER, OLSR_TIMER_ONESHOT,
+                  &olsr_expire_link_sym_timer, entry, 0);
+
+    /* L_time = L_SYM_time + NEIGHB_HOLD_TIME */
+    olsr_set_link_timer(entry, message->vtime + NEIGHB_HOLD_TIME *
+                       MSEC_PER_SEC);
+    break;
+  default:;
+  }
 
   /* L_time = max(L_time, L_ASYM_time) */
-  if(entry->link_timer && (entry->link_timer->timer_clock < entry->ASYM_time)) {
+  if (entry->link_timer && (entry->link_timer->timer_clock < entry->ASYM_time)) {
     olsr_set_link_timer(entry, TIME_DUE(entry->ASYM_time));
   }
 
-
-  /*
-  printf("Updating link LOCAL: %s ", olsr_ip_to_string(local));
-  printf("REMOTE: %s\n", olsr_ip_to_string(remote));
-  printf("VTIME: %f ", message->vtime);
-  printf("STATUS: %d\n", status);
-  */
-
   /* Update hysteresis values */
-  if(olsr_cnf->use_hysteresis)
+  if (olsr_cnf->use_hysteresis)
     olsr_process_hysteresis(entry);
 
   /* Update neighbor */
   update_neighbor_status(entry->neighbor, get_neighbor_status(remote));
 
-  return entry;  
+  return entry;
 }
 
 
 /**
- * Fuction that updates all registered pointers to
+ * Function that updates all registered pointers to
  * one neighbor entry with another pointer
  * Used by MID updates.
  *
- *@old the pointer to replace
- *@new the pointer to use instead of "old"
- *
- *@return the number of entries updated
+ * @old the pointer to replace
+ * @new the pointer to use instead of "old"
+ * @return the number of entries updated
  */
 int
 replace_neighbor_link_set(const struct neighbor_entry *old,
@@ -775,7 +738,7 @@ replace_neighbor_link_set(const struct neighbor_entry *old,
   if (list_is_empty(&link_entry_head)) {
     return retval;
   }
-      
+
   OLSR_FOR_ALL_LINK_ENTRIES(link) {
 
     if (link->neighbor == old) {
@@ -797,76 +760,78 @@ replace_neighbor_link_set(const struct neighbor_entry *old,
  *@return the link status
  */
 static int
-check_link_status(const struct hello_message *message, const struct interface *in_if)
+check_link_status(const struct hello_message *message,
+                 const struct interface *in_if)
 {
   int ret = UNSPEC_LINK;
-  struct hello_neighbor  *neighbors;
+  struct hello_neighbor *neighbors;
 
   neighbors = message->neighbors;
-  
-  while(neighbors!=NULL)
-    {
-      /*
-       * Note: If a neigh has 2 cards we can reach, the neigh
-       * will send a Hello with the same IP mentined twice
-       */
-      if(ipequal(&neighbors->address, &in_if->ip_addr))
-        {
-         //printf("ok");
-         ret = neighbors->link;
-         if (SYM_LINK == ret) break;
-       }
-
-      neighbors = neighbors->next; 
+  while (neighbors) {
+
+    /*
+     * Note: If a neigh has 2 cards we can reach, the neigh
+     * will send a Hello with the same IP mentined twice
+     */
+    if (ipequal(&neighbors->address, &in_if->ip_addr)) {
+      ret = neighbors->link;
+      if (SYM_LINK == ret) {
+       break;
+      }
     }
-
+    neighbors = neighbors->next;
+  }
 
   return ret;
 }
 
-void olsr_print_link_set(void)
+void
+olsr_print_link_set(void)
 {
 #ifndef NODEBUG
   /* The whole function makes no sense without it. */
   struct link_entry *walker;
   const int addrsize = olsr_cnf->ip_version == AF_INET ? 15 : 39;
 
-  OLSR_PRINTF(0, "\n--- %s ---------------------------------------------------- LINKS\n\n",
-              olsr_wallclock_string());
-  OLSR_PRINTF(1, "%-*s  %-6s %-6s %-6s %-6s %-6s %s\n", addrsize,
-              "IP address", "hyst", "LQ", "lost", "total","NLQ", "ETX");
+  OLSR_PRINTF(0,
+             "\n--- %s ---------------------------------------------------- LINKS\n\n",
+             olsr_wallclock_string());
+  OLSR_PRINTF(1, "%-*s  %-6s %-14s %s\n", addrsize, "IP address", "hyst",
+             "      LQ      ", "ETX");
 
   OLSR_FOR_ALL_LINK_ENTRIES(walker) {
 
     struct ipaddr_str buf;
     struct lqtextbuffer lqbuffer1, lqbuffer2;
-    OLSR_PRINTF(1, "%-*s  %5.3f  %-13s %s\n",
-                addrsize, olsr_ip_to_string(&buf, &walker->neighbor_iface_addr),
-                walker->L_link_quality,
-                get_link_entry_text(walker, &lqbuffer1),
-                get_linkcost_text(walker->linkcost, OLSR_FALSE, &lqbuffer2));
+    OLSR_PRINTF(1, "%-*s  %5.3f  %-14s %s\n",
+               addrsize, olsr_ip_to_string(&buf, &walker->neighbor_iface_addr),
+               walker->L_link_quality,
+               get_link_entry_text(walker, &lqbuffer1),
+               get_linkcost_text(walker->linkcost, OLSR_FALSE, &lqbuffer2));
   } OLSR_FOR_ALL_LINK_ENTRIES_END(walker);
 #endif
 }
 
-void olsr_update_packet_loss_hello_int(struct link_entry *entry,
-                                       double loss_hello_int)
+/*
+ * called for every LQ HELLO message.
+ * update the timeout with the htime value from the message
+ */
+void
+olsr_update_packet_loss_hello_int(struct link_entry *entry,
+                                 olsr_reltime loss_hello_int)
 {
-  // called for every LQ HELLO message - update the timeout
-  // with the htime value from the message
-
-  entry->loss_hello_int = loss_hello_int;
+  entry->loss_helloint = loss_hello_int;
 }
 
-void olsr_update_packet_loss(struct link_entry *entry)
+void
+olsr_update_packet_loss(struct link_entry *entry)
 {
   olsr_update_packet_loss_worker(entry, OLSR_FALSE);
 
-  // timeout for the first lost packet is 1.5 x htime
-
-  olsr_set_timer(&entry->link_loss_timer, entry->loss_hello_int * 1500,
-                 OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC,
-                 &olsr_expire_link_loss_timer, entry, 0);
+  /* timeout for the first lost packet is 1.5 x htime */
+  olsr_set_timer(&entry->link_loss_timer, entry->loss_helloint + entry->loss_helloint/2,
+                OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC,
+                &olsr_expire_link_loss_timer, entry, 0);
 }
 
 /*
index 26a58b1..34731eb 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas TÃ\83¸nnesen(andreto@olsr.org)
@@ -38,7 +39,6 @@
  *
  */
 
-
 /*
  * Link sensing database for the OLSR routing daemon
  */
 #include "lq_plugin.h"
 #include "packet.h"
 #include "common/list.h"
+#include "mantissa.h"
 
 #define MID_ALIAS_HACK_VTIME  10.0
 
-struct link_entry
-{
+struct link_entry {
   union olsr_ip_addr local_iface_addr;
   union olsr_ip_addr neighbor_iface_addr;
   const struct interface *inter;
@@ -61,43 +61,44 @@ struct link_entry
   struct timer_entry *link_timer;
   struct timer_entry *link_sym_timer;
   clock_t ASYM_time;
-  unsigned int vtime;
+  olsr_reltime vtime;
   struct neighbor_entry *neighbor;
   olsr_u8_t prev_status;
 
   /*
-   *Hysteresis
+   * Hysteresis
    */
   float L_link_quality;
   int L_link_pending;
   clock_t L_LOST_LINK_time;
-  struct timer_entry *link_hello_timer; /* When we should receive a new HELLO */
-  double last_htime;
+  struct timer_entry *link_hello_timer;        /* When we should receive a new HELLO */
+  olsr_reltime last_htime;
   olsr_bool olsr_seqno_valid;
   olsr_u16_t olsr_seqno;
 
   /*
    * packet loss
    */
-  double loss_hello_int;
+  olsr_reltime loss_helloint;
   struct timer_entry *link_loss_timer;
 
-  float loss_link_multiplier; // user defined multiplies for link quality
-  
-  // cost of this link
+  /* user defined multiplies for link quality, multiplied with 65536 */
+  olsr_u32_t loss_link_multiplier;
+
+  /* cost of this link */
   olsr_linkcost linkcost;
 
-  struct list_node link_list; /* double linked list of all link entries */
-  char                  linkquality[0];
+  struct list_node link_list;         /* double linked list of all link entries */
+  char linkquality[0];
 };
 
 /* inline to recast from link_list back to link_entry */
 LISTNODE2STRUCT(list2link, struct link_entry, link_list);
 
-#define OLSR_LINK_JITTER       5 /* percent */
-#define OLSR_LINK_HELLO_JITTER 0 /* percent jitter */
-#define OLSR_LINK_SYM_JITTER   0 /* percent jitter */
-#define OLSR_LINK_LOSS_JITTER  0 /* percent jitter */
+#define OLSR_LINK_JITTER       5       /* percent */
+#define OLSR_LINK_HELLO_JITTER 0       /* percent jitter */
+#define OLSR_LINK_SYM_JITTER   0       /* percent jitter */
+#define OLSR_LINK_LOSS_JITTER  0       /* percent jitter */
 
 /* deletion safe macro for link entry traversal */
 #define OLSR_FOR_ALL_LINK_ENTRIES(link) \
@@ -116,41 +117,32 @@ extern olsr_bool link_changes;
 
 /* Function prototypes */
 
-void olsr_set_link_timer(struct link_entry *, unsigned int );
+void olsr_set_link_timer(struct link_entry *, unsigned int);
 void olsr_init_link_set(void);
 void olsr_delete_link_entry_by_ip(const union olsr_ip_addr *);
 void olsr_expire_link_hello_timer(void *);
 void olsr_update_packet_loss_worker(struct link_entry *, olsr_bool);
-void signal_link_changes(olsr_bool); /* XXX ugly */
-
-
-struct link_entry *
-get_best_link_to_neighbor(const union olsr_ip_addr *);
-
-struct link_entry *
-lookup_link_entry(const union olsr_ip_addr *, const union olsr_ip_addr *remote_main, const struct interface *);
-
-struct link_entry *
-update_link_entry(const union olsr_ip_addr *, const union olsr_ip_addr *, const struct hello_message *, const struct interface *);
-
-int
-check_neighbor_link(const union olsr_ip_addr *);
+void signal_link_changes(olsr_bool);   /* XXX ugly */
 
-int
-replace_neighbor_link_set(const struct neighbor_entry *,
-                         struct neighbor_entry *);
 
-int
-lookup_link_status(const struct link_entry *);
+struct link_entry *get_best_link_to_neighbor(const union olsr_ip_addr *);
 
-void 
-olsr_update_packet_loss_hello_int(struct link_entry *, double);
+struct link_entry *lookup_link_entry(const union olsr_ip_addr *,
+                                    const union olsr_ip_addr *remote_main,
+                                    const struct interface *);
 
-void 
-olsr_update_packet_loss(struct link_entry *entry);
+struct link_entry *update_link_entry(const union olsr_ip_addr *,
+                                    const union olsr_ip_addr *,
+                                    const struct hello_message *,
+                                    const struct interface *);
 
-void 
-olsr_print_link_set(void);
+int check_neighbor_link(const union olsr_ip_addr *);
+int replace_neighbor_link_set(const struct neighbor_entry *,
+                           struct neighbor_entry *);
+int lookup_link_status(const struct link_entry *);
+void olsr_update_packet_loss_hello_int(struct link_entry *, olsr_reltime);
+void olsr_update_packet_loss(struct link_entry *entry);
+void olsr_print_link_set(void);
 
 #endif
 
index 46b93b2..b3f5be7 100644 (file)
@@ -70,7 +70,7 @@ create_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
   // initialize the static fields
 
   lq_hello->comm.type = LQ_HELLO_MESSAGE;
-  lq_hello->comm.vtime = me_to_double(outif->valtimes.hello);
+  lq_hello->comm.vtime = me_to_reltime(outif->valtimes.hello);
   lq_hello->comm.size = 0;
 
   lq_hello->comm.orig = olsr_cnf->main_addr;
@@ -123,7 +123,6 @@ create_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
     neigh->addr = walker->neighbor_iface_addr;
       
     // queue the neighbour entry
-
     neigh->next = lq_hello->neigh;
     lq_hello->neigh = neigh;
 
@@ -162,7 +161,7 @@ create_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
   // initialize the static fields
 
   lq_tc->comm.type = LQ_TC_MESSAGE;
-  lq_tc->comm.vtime = me_to_double(outif->valtimes.tc);
+  lq_tc->comm.vtime = me_to_reltime(outif->valtimes.tc);
   lq_tc->comm.size = 0;
 
   lq_tc->comm.orig = olsr_cnf->main_addr;
@@ -241,8 +240,29 @@ create_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
     }
 
     /* Queue the neighbour entry. */
-    neigh->next = lq_tc->neigh;
-    lq_tc->neigh = neigh;
+
+    // TODO: ugly hack until neighbor table is ported to avl tree
+    
+    if (lq_tc->neigh == NULL || avl_comp_default(&lq_tc->neigh->address, &neigh->address) > 0) {
+      neigh->next = lq_tc->neigh;
+      lq_tc->neigh = neigh;
+    }
+    else {
+      struct tc_mpr_addr *last = lq_tc->neigh, *n = last->next;
+      
+      while (n) {
+        if (avl_comp_default(&n->address, &neigh->address) > 0) {
+          break;
+        }
+        last = n;
+        n = n->next;
+      }
+      neigh->next = n;
+      last->next = neigh;
+    }
+
+    // neigh->next = lq_tc->neigh;
+    // lq_tc->neigh = neigh;
 
   } OLSR_FOR_ALL_NBR_ENTRIES_END(walker);
 }
@@ -277,7 +297,7 @@ static void serialize_common(struct olsr_common *comm)
       struct olsr_header_v4 *olsr_head_v4 = (struct olsr_header_v4 *)msg_buffer;
 
       olsr_head_v4->type = comm->type;
-      olsr_head_v4->vtime = double_to_me(comm->vtime);
+      olsr_head_v4->vtime = reltime_to_me(comm->vtime);
       olsr_head_v4->size = htons(comm->size);
 
       olsr_head_v4->orig = comm->orig.v4.s_addr;
@@ -292,7 +312,7 @@ static void serialize_common(struct olsr_common *comm)
       struct olsr_header_v6 *olsr_head_v6 = (struct olsr_header_v6 *)msg_buffer;
 
       olsr_head_v6->type = comm->type;
-      olsr_head_v6->vtime = double_to_me(comm->vtime);
+      olsr_head_v6->vtime = reltime_to_me(comm->vtime);
       olsr_head_v6->size = htons(comm->size);
 
       memcpy(&olsr_head_v6->orig, &comm->orig.v6.s6_addr, sizeof(olsr_head_v6->orig));
@@ -322,7 +342,7 @@ serialize_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
   struct lq_hello_header *head = (struct lq_hello_header *)(msg_buffer + off);
 
   head->reserved = 0;
-  head->htime = double_to_me(lq_hello->htime);
+  head->htime = reltime_to_me(lq_hello->htime);
   head->will = lq_hello->will; 
 
   // 'off' is the offset of the byte following the LQ_HELLO header
@@ -471,6 +491,35 @@ serialize_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
   net_outbuffer_push(outif, msg_buffer, size + off);
 }
 
+static olsr_u8_t
+calculate_border_flag(void *lower_border, void *higher_border) {
+       olsr_u8_t *lower = lower_border;
+       olsr_u8_t *higher = higher_border;
+       olsr_u8_t bitmask;
+       olsr_u8_t part, bitpos;
+       
+       for (part = 0; part < olsr_cnf->ipsize; part ++) {
+               if (lower[part] != higher[part]) {
+                       break;
+               }
+       }
+       
+       if (part == olsr_cnf->ipsize) { // same IPs ?
+               return 0;
+       }
+       
+       // look for first bit of difference
+       bitmask = 0xfe;
+       for (bitpos = 0; bitpos < 8; bitpos++, bitmask <<= 1) {
+               if ((lower[part] & bitmask) == (higher[part] & bitmask)) {
+                       break;
+               }
+       }
+       
+  bitpos += 8 * (olsr_cnf->ipsize - part - 1);
+       return bitpos + 1;
+}
+
 static void
 serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
 {
@@ -479,6 +528,9 @@ serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
   struct tc_mpr_addr *neigh;
   unsigned char *buff;
 
+  union olsr_ip_addr *last_ip = NULL;
+  olsr_u8_t left_border_flag = 0xff;
+  
   // leave space for the OLSR header
 
   off = common_size();
@@ -488,8 +540,9 @@ serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
   head = (struct lq_tc_header *)(msg_buffer + off);
 
   head->ansn = htons(lq_tc->ansn);
-  head->reserved = 0;
-
+  head->lower_border = 0;
+  head->upper_border = 0;
+  
   // 'off' is the offset of the byte following the LQ_TC header
 
   off += sizeof (struct lq_tc_header);
@@ -534,6 +587,10 @@ serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
     // TODO sizeof_tc_lq function required
       if ((int)(size + olsr_cnf->ipsize + 4) > rem)
         {
+         head->lower_border = left_border_flag;
+         head->upper_border = calculate_border_flag(last_ip, &neigh->address);
+         left_border_flag = head->upper_border;
+         
           // finalize the OLSR header
 
           lq_tc->comm.size = size + off;
@@ -554,6 +611,10 @@ serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
 
       // add the current neighbor's IP address
       genipcopy(buff + size, &neigh->address);
+      
+      // remember last ip
+      last_ip = (union olsr_ip_addr *)(buff+size);
+      
       size += olsr_cnf->ipsize;
 
       // add the corresponding link quality
@@ -562,6 +623,8 @@ serialize_lq_tc(struct lq_tc_message *lq_tc, struct interface *outif)
 
   // finalize the OLSR header
 
+  head->lower_border = left_border_flag;
+  head->upper_border = 0xff;
   lq_tc->comm.size = size + off;
 
   serialize_common((struct olsr_common *)lq_tc);
index 2b0670f..db4b0e2 100644 (file)
@@ -54,7 +54,7 @@
 struct olsr_common
 {
   olsr_u8_t          type;
-  double             vtime;
+  olsr_reltime       vtime;
   olsr_u16_t         size;
   union olsr_ip_addr orig;
   olsr_u8_t          ttl;
@@ -102,7 +102,7 @@ struct lq_hello_neighbor
 struct lq_hello_message
 {
   struct olsr_common       comm;
-  double                   htime;
+  olsr_reltime             htime;
   olsr_u8_t                will;
   struct lq_hello_neighbor *neigh;
 };
@@ -137,7 +137,8 @@ struct lq_tc_message
 struct lq_tc_header
 {
   olsr_u16_t ansn;
-  olsr_u16_t reserved;
+  olsr_u8_t lower_border;
+  olsr_u8_t upper_border;
 };
 
 static INLINE void        pkt_get_u8(const olsr_u8_t **p, olsr_u8_t  *var)         { *var =       *(const olsr_u8_t *)(*p);          *p += sizeof(olsr_u8_t); }
@@ -146,10 +147,9 @@ static INLINE void       pkt_get_u32(const olsr_u8_t **p, olsr_u32_t *var)
 static INLINE void        pkt_get_s8(const olsr_u8_t **p, olsr_8_t  *var)          { *var =       *(const olsr_8_t *)(*p);           *p += sizeof(olsr_8_t); }
 static INLINE void       pkt_get_s16(const olsr_u8_t **p, olsr_16_t *var)          { *var = ntohs(*(const olsr_16_t *)(*p));         *p += sizeof(olsr_16_t); }
 static INLINE void       pkt_get_s32(const olsr_u8_t **p, olsr_32_t *var)          { *var = ntohl(*(const olsr_32_t *)(*p));         *p += sizeof(olsr_32_t); }
-static INLINE void    pkt_get_double(const olsr_u8_t **p, double *var)             { *var = me_to_double(**p);                       *p += sizeof(olsr_u8_t); }
+static INLINE void   pkt_get_reltime(const olsr_u8_t **p, olsr_reltime *var)       { *var = me_to_reltime(**p);                       *p += sizeof(olsr_u8_t); }
 static INLINE void pkt_get_ipaddress(const olsr_u8_t **p, union olsr_ip_addr *var) { memcpy(var, *p, olsr_cnf->ipsize);              *p += olsr_cnf->ipsize; }
 static INLINE void pkt_get_prefixlen(const olsr_u8_t **p, olsr_u8_t *var)          { *var = netmask_to_prefix(*p, olsr_cnf->ipsize); *p += olsr_cnf->ipsize; }
-static INLINE void        pkt_get_lq(const olsr_u8_t **p, float *var)              { *var = (const float)**p / 255.0;               *p += sizeof(olsr_u8_t); }
 
 static INLINE void        pkt_ignore_u8(const olsr_u8_t **p) { *p += sizeof(olsr_u8_t); }
 static INLINE void       pkt_ignore_u16(const olsr_u8_t **p) { *p += sizeof(olsr_u16_t); }
@@ -166,10 +166,9 @@ static INLINE void       pkt_put_u32(olsr_u8_t **p, olsr_u32_t var)
 static INLINE void        pkt_put_s8(olsr_u8_t **p, olsr_8_t  var)                 { *(olsr_8_t *)(*p)   = var;          *p += sizeof(olsr_8_t); }
 static INLINE void       pkt_put_s16(olsr_u8_t **p, olsr_16_t var)                 { *(olsr_16_t *)(*p)  = htons(var);   *p += sizeof(olsr_16_t); }
 static INLINE void       pkt_put_s32(olsr_u8_t **p, olsr_32_t var)                 { *(olsr_32_t *)(*p)  = htonl(var);   *p += sizeof(olsr_32_t); }
-static INLINE void    pkt_put_double(olsr_u8_t **p, double var)                    { **p = double_to_me(var);            *p += sizeof(olsr_u8_t); }
+static INLINE void   pkt_put_reltime(olsr_u8_t **p, olsr_reltime var)              { **p = reltime_to_me(var);           *p += sizeof(olsr_u8_t); }
 static INLINE void pkt_put_ipaddress(olsr_u8_t **p, const union olsr_ip_addr *var) { memcpy(*p, var, olsr_cnf->ipsize); *p += olsr_cnf->ipsize; }
 static INLINE void pkt_put_prefixlen(olsr_u8_t **p, olsr_u8_t var)                 { prefix_to_netmask(*p, olsr_cnf->ipsize, var); *p += olsr_cnf->ipsize; }
-static INLINE void        pkt_put_lq(olsr_u8_t **p, float var)                     { **p  = var * 255.0;                 *p += sizeof(olsr_u8_t); }
 
 void olsr_output_lq_hello(void *para);
 
index b4e8ee0..06588ff 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
 
 #include "tc_set.h"
 #include "link_set.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "lq_packet.h"
 #include "packet.h"
 #include "olsr.h"
 #include "two_hop_neighbor_table.h"
+#include "common/avl.h"
+
+#include "lq_plugin_default_float.h"
+#include "lq_plugin_default_fpm.h"
+
+struct avl_tree lq_handler_tree;
+struct lq_handler *active_lq_handler = NULL;
+
+int
+avl_strcasecmp(const void *str1, const void *str2)
+{
+  return strcasecmp(str1, str2);
+}
 
-#include "lq_plugin_default.h"
-#include "lq_plugin.h"
-
-/* Default lq plugin settings */
-struct lq_handler default_lq_handler = {
-    &default_calc_cost,
-    &default_calc_cost,
-               
-    &default_olsr_is_relevant_costchange,
-               
-    &default_packet_loss_worker,
-    &default_olsr_memorize_foreign_hello_lq,
-    &default_olsr_copy_link_lq_into_tc,
-    &default_olsr_clear_lq,
-    &default_olsr_clear_lq,
-               
-    &default_olsr_serialize_hello_lq_pair,
-    &default_olsr_serialize_tc_lq_pair,
-    &default_olsr_deserialize_hello_lq_pair,
-    &default_olsr_deserialize_tc_lq_pair,
-               
-    &default_olsr_print_lq,
-    &default_olsr_print_lq,
-    &default_olsr_print_cost, 
-               
-    sizeof(struct default_lq),
-    sizeof(struct default_lq)
-};
-
-struct lq_handler *active_lq_handler = &default_lq_handler;
+
+void
+init_lq_handler_tree(void)
+{
+  avl_init(&lq_handler_tree, &avl_strcasecmp);
+  register_lq_handler(&lq_etx_float_handler, LQ_ALGORITHM_ETX_FLOAT_NAME);
+  register_lq_handler(&lq_etx_fpm_handler, LQ_ALGORITHM_ETX_FPM_NAME);
+  
+  if (activate_lq_handler(olsr_cnf->lq_algorithm)) {
+    activate_lq_handler(LQ_ALGORITHM_ETX_FPM_NAME);
+  }
+}
 
 /*
  * set_lq_handler
@@ -83,19 +79,45 @@ struct lq_handler *active_lq_handler = &default_lq_handler;
  * this function is used by routing metric plugins to activate their link
  * quality handler
  * 
+ * The name parameter is marked as "unused" to squelch a compiler warning if debug
+ * output is not active
+ * 
  * @param pointer to lq_handler structure
  * @param name of the link quality handler for debug output
  */
-void set_lq_handler(struct lq_handler *handler, const char *name) {
-  if (handler) {
-    OLSR_PRINTF(1, "Activated lq_handler: %s\n", name);
-    active_lq_handler = handler;
-  } else {
-    OLSR_PRINTF(1, "Activated lq_handler: default\n");
-    active_lq_handler = &default_lq_handler;
-  }
+void
+register_lq_handler(struct lq_handler *handler, const char *name)
+{
+  struct lq_handler_node *node;
+  
+  node = olsr_malloc(sizeof(struct lq_handler) + strlen(name) + 1, "olsr lq handler");
+  
+  strcpy(node->name, name);
+  node->node.key = node->name;
+  node->handler = handler;
+  
+  avl_insert(&lq_handler_tree, &node->node, OLSR_FALSE); 
+}
 
-  name = NULL; /* squelch compiler warning */
+int
+activate_lq_handler(const char *name)
+{
+  struct lq_handler_node *node;
+  if (name == NULL) {
+    return 1;
+  }
+  
+  node = (struct lq_handler_node *) avl_find(&lq_handler_tree, name);
+  if (node == NULL) {
+    OLSR_PRINTF(1, "Error, unknown lq_handler '%s'\n", name);
+    return 1;
+  }
+  
+  OLSR_PRINTF(1, "Using '%s' algorithm for lq calculation.\n", name);
+  active_lq_handler = node->handler;
+  active_lq_handler->initialize();
+  
+  return 0;
 }
 
 /*
@@ -106,7 +128,8 @@ void set_lq_handler(struct lq_handler *handler, const char *name) {
  * @param pointer to the tc_edge_entry
  * @return linkcost
  */
-olsr_linkcost olsr_calc_tc_cost(const struct tc_edge_entry *tc_edge)
+olsr_linkcost
+olsr_calc_tc_cost(const struct tc_edge_entry *tc_edge)
 {
   return active_lq_handler->calc_tc_cost(tc_edge->linkquality);
 }
@@ -121,7 +144,9 @@ olsr_linkcost olsr_calc_tc_cost(const struct tc_edge_entry *tc_edge)
  * @param second linkcost value
  * @return boolean
  */
-olsr_bool olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
+olsr_bool
+olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2)
+{
   return active_lq_handler->is_relevant_costchange(c1, c2);
 }
 
@@ -135,8 +160,11 @@ olsr_bool olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
  * @param pointer to lq_hello_neighbor
  * @return number of bytes that have been written
  */
-int olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neigh) {
-       return active_lq_handler->serialize_hello_lq(buff, neigh->linkquality);
+int
+olsr_serialize_hello_lq_pair(unsigned char *buff,
+                            struct lq_hello_neighbor *neigh)
+{
+  return active_lq_handler->serialize_hello_lq(buff, neigh->linkquality);
 }
 
 /*
@@ -148,9 +176,12 @@ int olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *
  * @param pointer to the current buffer pointer
  * @param pointer to hello_neighbor
  */
-void olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, struct hello_neighbor *neigh) {
-       active_lq_handler->deserialize_hello_lq(curr, neigh->linkquality);
-       neigh->cost = active_lq_handler->calc_hello_cost(neigh->linkquality);
+void
+olsr_deserialize_hello_lq_pair(const olsr_u8_t ** curr,
+                              struct hello_neighbor *neigh)
+{
+  active_lq_handler->deserialize_hello_lq(curr, neigh->linkquality);
+  neigh->cost = active_lq_handler->calc_hello_cost(neigh->linkquality);
 }
 
 /*
@@ -163,8 +194,10 @@ void olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, struct hello_neighbo
  * @param pointer to olsr_serialize_tc_lq_pair
  * @return number of bytes that have been written
  */
-int olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh) {
-       return active_lq_handler->serialize_tc_lq(buff, neigh->linkquality);
+int
+olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh)
+{
+  return active_lq_handler->serialize_tc_lq(buff, neigh->linkquality);
 }
 
 /*
@@ -175,8 +208,10 @@ int olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh) {
  * @param pointer to the current buffer pointer
  * @param pointer to tc_edge_entry
  */
-void olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, struct tc_edge_entry *edge) {
-       active_lq_handler->deserialize_tc_lq(curr, edge->linkquality);
+void
+olsr_deserialize_tc_lq_pair(const olsr_u8_t ** curr, struct tc_edge_entry *edge)
+{
+  active_lq_handler->deserialize_tc_lq(curr, edge->linkquality);
 }
 
 /*
@@ -189,14 +224,15 @@ void olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, struct tc_edge_entry *e
  * @param pointer to link_entry
  * @param OLSR_TRUE if hello package was lost
  */
-void olsr_update_packet_loss_worker(struct link_entry *entry, olsr_bool lost)
+void
+olsr_update_packet_loss_worker(struct link_entry *entry, olsr_bool lost)
 {
-       olsr_linkcost lq;
-       lq = active_lq_handler->packet_loss_handler(entry->linkquality, lost);
-  
-       if (olsr_is_relevant_costchange(lq, entry->linkcost)) {
+  olsr_linkcost lq;
+  lq = active_lq_handler->packet_loss_handler(entry, entry->linkquality, lost);
+
+  if (olsr_is_relevant_costchange(lq, entry->linkcost)) {
     entry->linkcost = lq;
-    
+
     if (olsr_cnf->lq_dlimit > 0) {
       changes_neighborhood = OLSR_TRUE;
       changes_topology = OLSR_TRUE;
@@ -204,9 +240,8 @@ void olsr_update_packet_loss_worker(struct link_entry *entry, olsr_bool lost)
 
     else
       OLSR_PRINTF(3, "Skipping Dijkstra (1)\n");
-    
-    // XXX - we should check whether we actually
-    // announce this neighbour
+
+    /* XXX - we should check whether we actually announce this neighbour */
     signal_link_changes(OLSR_TRUE);
   }
 }
@@ -221,11 +256,14 @@ void olsr_update_packet_loss_worker(struct link_entry *entry, olsr_bool lost)
  * @param pointer to hello_neighbor, if NULL the neighbor link quality information
  * of the link entry has to be reset to "zero"
  */
-void olsr_memorize_foreign_hello_lq(struct link_entry *local, struct hello_neighbor *foreign) {
+void
+olsr_memorize_foreign_hello_lq(struct link_entry *local,
+                              struct hello_neighbor *foreign)
+{
   if (foreign) {
-    active_lq_handler->memorize_foreign_hello(local->linkquality, foreign->linkquality);
-  }
-  else {
+    active_lq_handler->memorize_foreign_hello(local->linkquality,
+                                             foreign->linkquality);
+  else {
     active_lq_handler->memorize_foreign_hello(local->linkquality, NULL);
   }
 }
@@ -241,7 +279,9 @@ void olsr_memorize_foreign_hello_lq(struct link_entry *local, struct hello_neigh
  * @param buffer for output
  * @return pointer to a buffer with the text representation
  */
-const char *get_link_entry_text(struct link_entry *entry, struct lqtextbuffer *buffer) {
+const char *
+get_link_entry_text(struct link_entry *entry, struct lqtextbuffer *buffer)
+{
   return active_lq_handler->print_hello_lq(entry->linkquality, buffer);
 }
 
@@ -256,7 +296,9 @@ const char *get_link_entry_text(struct link_entry *entry, struct lqtextbuffer *b
  * @param pointer to buffer
  * @return pointer to the buffer with the text representation
  */
-const char *get_tc_edge_entry_text(struct tc_edge_entry *entry, struct lqtextbuffer *buffer) {
+const char *
+get_tc_edge_entry_text(struct tc_edge_entry *entry, struct lqtextbuffer *buffer)
+{
   return active_lq_handler->print_tc_lq(entry->linkquality, buffer);
 }
 
@@ -271,15 +313,17 @@ const char *get_tc_edge_entry_text(struct tc_edge_entry *entry, struct lqtextbuf
  * @param pointer to buffer
  * @return pointer to buffer filled with text
  */
-const char *get_linkcost_text(olsr_linkcost cost, olsr_bool route, struct lqtextbuffer *buffer) {
+const char *
+get_linkcost_text(olsr_linkcost cost, olsr_bool route,
+                 struct lqtextbuffer *buffer)
+{
   static const char *infinite = "INFINITE";
-  
+
   if (route) {
     if (cost == ROUTE_COST_BROKEN) {
       return infinite;
     }
-  }
-  else {
+  } else {
     if (cost >= LINK_COST_BROKEN) {
       return infinite;
     }
@@ -296,8 +340,11 @@ const char *get_linkcost_text(olsr_linkcost cost, olsr_bool route, struct lqtext
  * @param pointer to target lq_hello_neighbor
  * @param pointer to source link_entry
  */
-void olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source) {
-  memcpy(target->linkquality, source->linkquality, active_lq_handler->hello_lq_size);
+void
+olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source)
+{
+  memcpy(target->linkquality, source->linkquality,
+        active_lq_handler->hello_lq_size);
 }
 
 /*
@@ -309,8 +356,12 @@ void olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *sou
  * @param pointer to tc_mpr_addr
  * @param pointer to link_entry
  */
-void olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source) {
-  active_lq_handler->copy_link_lq_into_tc(target->linkquality, source->linkquality);
+void
+olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target,
+                                    struct link_entry *source)
+{
+  active_lq_handler->copy_link_lq_into_tc(target->linkquality,
+                                         source->linkquality);
 }
 
 /*
@@ -322,8 +373,12 @@ void olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct lin
  * @param pointer to tc_edge_entry
  * @param pointer to link_entry
  */
-void olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source) {
-  active_lq_handler->copy_link_lq_into_tc(target->linkquality, source->linkquality);
+void
+olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target,
+                                      struct link_entry *source)
+{
+  active_lq_handler->copy_link_lq_into_tc(target->linkquality,
+                                         source->linkquality);
 }
 
 /*
@@ -333,7 +388,9 @@ void olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target, struct
  * 
  * @param pointer to tc_mpr_addr
  */
-void olsr_clear_tc_lq(struct tc_mpr_addr *target) {
+void
+olsr_clear_tc_lq(struct tc_mpr_addr *target)
+{
   active_lq_handler->clear_tc(target->linkquality);
 }
 
@@ -347,13 +404,17 @@ void olsr_clear_tc_lq(struct tc_mpr_addr *target) {
  * 
  * @return pointer to hello_neighbor
  */
-struct hello_neighbor *olsr_malloc_hello_neighbor(const char *id) {
-       struct hello_neighbor *h;
-       
-       h = olsr_malloc(sizeof(struct hello_neighbor) + active_lq_handler->hello_lq_size, id);
-       
-       active_lq_handler->clear_hello(h->linkquality);
-       return h;
+struct hello_neighbor *
+olsr_malloc_hello_neighbor(const char *id)
+{
+  struct hello_neighbor *h;
+
+  h =
+    olsr_malloc(sizeof(struct hello_neighbor) +
+               active_lq_handler->hello_lq_size, id);
+
+  active_lq_handler->clear_hello(h->linkquality);
+  return h;
 }
 
 /*
@@ -366,11 +427,14 @@ struct hello_neighbor *olsr_malloc_hello_neighbor(const char *id) {
  * 
  * @return pointer to tc_mpr_addr
  */
-struct tc_mpr_addr *olsr_malloc_tc_mpr_addr(const char *id) {
+struct tc_mpr_addr *
+olsr_malloc_tc_mpr_addr(const char *id)
+{
   struct tc_mpr_addr *t;
-  
-   t = olsr_malloc(sizeof(struct tc_mpr_addr) + active_lq_handler->tc_lq_size, id);
-  
+
+  t =
+    olsr_malloc(sizeof(struct tc_mpr_addr) + active_lq_handler->tc_lq_size, id);
+
   active_lq_handler->clear_tc(t->linkquality);
   return t;
 }
@@ -385,11 +449,15 @@ struct tc_mpr_addr *olsr_malloc_tc_mpr_addr(const char *id) {
  * 
  * @return pointer to lq_hello_neighbor
  */
-struct lq_hello_neighbor *olsr_malloc_lq_hello_neighbor(const char *id) {
+struct lq_hello_neighbor *
+olsr_malloc_lq_hello_neighbor(const char *id)
+{
   struct lq_hello_neighbor *h;
-  
-  h = olsr_malloc(sizeof(struct lq_hello_neighbor) + active_lq_handler->hello_lq_size, id);
-  
+
+  h =
+    olsr_malloc(sizeof(struct lq_hello_neighbor) +
+               active_lq_handler->hello_lq_size, id);
+
   active_lq_handler->clear_hello(h->linkquality);
   return h;
 }
@@ -404,11 +472,15 @@ struct lq_hello_neighbor *olsr_malloc_lq_hello_neighbor(const char *id) {
  * 
  * @return pointer to link_entry
  */
-struct link_entry *olsr_malloc_link_entry(const char *id) {
+struct link_entry *
+olsr_malloc_link_entry(const char *id)
+{
   struct link_entry *h;
-  
-  h =  olsr_malloc(sizeof(struct link_entry) + active_lq_handler->hello_lq_size, id);
-  
+
+  h =
+    olsr_malloc(sizeof(struct link_entry) + active_lq_handler->hello_lq_size,
+               id);
+
   active_lq_handler->clear_hello(h->linkquality);
   return h;
 }
@@ -423,11 +495,15 @@ struct link_entry *olsr_malloc_link_entry(const char *id) {
  * 
  * @return pointer to tc_edge_entry
  */
-struct tc_edge_entry *olsr_malloc_tc_edge_entry(const char *id) {
+struct tc_edge_entry *
+olsr_malloc_tc_edge_entry(const char *id)
+{
   struct tc_edge_entry *t;
-  
-  t = olsr_malloc(sizeof(struct tc_edge_entry) + active_lq_handler->tc_lq_size, id);
-  
+
+  t =
+    olsr_malloc(sizeof(struct tc_edge_entry) + active_lq_handler->tc_lq_size,
+               id);
+
   active_lq_handler->clear_tc(t);
   return t;
 }
index a7b8cfa..af91cf6 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
 
 #include "tc_set.h"
 #include "link_set.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "lq_packet.h"
 #include "packet.h"
+#include "common/avl.h"
 
 #define LINK_COST_BROKEN (1<<22)
 #define ROUTE_COST_BROKEN (0xffffffff)
 #define ZERO_ROUTE_COST 0
 
+#define MINIMAL_USEFUL_LQ 0.1
+
+#define LQ_QUICKSTART_STEPS 12
+#define LQ_QUICKSTART_AGING 0.25
+
 struct lqtextbuffer {
   char buf[16];
 };
 
 struct lq_handler {
-  olsr_linkcost (*calc_hello_cost)(const void *lq);
-  olsr_linkcost (*calc_tc_cost)(const void *lq);
-  
-  olsr_bool (*is_relevant_costchange)(olsr_linkcost c1, olsr_linkcost c2);
-  
-  olsr_linkcost (*packet_loss_handler)(void *lq, olsr_bool lost);
-  
-  void (*memorize_foreign_hello)(void *local, void *foreign);
-  void (*copy_link_lq_into_tc)(void *target, void *source);
-  void (*clear_hello)(void *target);
-  void (*clear_tc)(void *target);
-  
-  int (*serialize_hello_lq)(unsigned char *buff, void *lq);
-  int (*serialize_tc_lq)(unsigned char *buff, void *lq);
-  void (*deserialize_hello_lq)(const olsr_u8_t **curr, void *lq);
-  void (*deserialize_tc_lq)(const olsr_u8_t **curr, void *lq);
-  
-  const char *(*print_hello_lq)(void *ptr, struct lqtextbuffer *buffer);
-  const char *(*print_tc_lq)(void *ptr, struct lqtextbuffer *buffer);
-  const char *(*print_cost)(olsr_linkcost cost, struct lqtextbuffer *buffer);
+  void (*initialize)(void);
   
+  olsr_linkcost(*calc_hello_cost) (const void *lq);
+  olsr_linkcost(*calc_tc_cost) (const void *lq);
+
+  olsr_bool(*is_relevant_costchange) (olsr_linkcost c1, olsr_linkcost c2);
+
+  olsr_linkcost(*packet_loss_handler) (struct link_entry * entry, void *lq,
+                                      olsr_bool lost);
+
+  void (*memorize_foreign_hello) (void *local, void *foreign);
+  void (*copy_link_lq_into_tc) (void *target, void *source);
+  void (*clear_hello) (void *target);
+  void (*clear_tc) (void *target);
+
+  int (*serialize_hello_lq) (unsigned char *buff, void *lq);
+  int (*serialize_tc_lq) (unsigned char *buff, void *lq);
+  void (*deserialize_hello_lq) (const olsr_u8_t ** curr, void *lq);
+  void (*deserialize_tc_lq) (const olsr_u8_t ** curr, void *lq);
+
+  const char *(*print_hello_lq) (void *ptr, struct lqtextbuffer * buffer);
+  const char *(*print_tc_lq) (void *ptr, struct lqtextbuffer * buffer);
+  const char *(*print_cost) (olsr_linkcost cost, struct lqtextbuffer * buffer);
+
   size_t hello_lq_size;
   size_t tc_lq_size;
 };
 
-void set_lq_handler(struct lq_handler *handler, const char *name);
+struct lq_handler_node {
+  struct avl_node node;
+  struct lq_handler *handler; 
+  char name[0];
+};
+
+AVLNODE2STRUCT(lq_handler_tree2lq_handler_node, struct lq_handler_node, node);
+
+#define OLSR_FOR_ALL_LQ_HANDLERS(lq) \
+{ \
+  struct avl_node *lq_tree_node, *next_lq_tree_node; \
+  for (lq_tree_node = avl_walk_first(&lq_handler_tree); \
+    lq_tree_node; lq_tree_node = next_lq_tree_node) { \
+    next_lq_tree_node = avl_walk_next(lq_tree_node); \
+    lq = lq_handler_tree2lq_handler_node(lq_tree_node);
+#define OLSR_FOR_ALL_LQ_HANDLERS_END(tc) }}
+
+int avl_strcasecmp(const void *str1, const void *str2);
+void init_lq_handler_tree(void);
+
+void register_lq_handler(struct lq_handler *handler, const char *name);
+int activate_lq_handler(const char *name);
 
 olsr_linkcost olsr_calc_tc_cost(const struct tc_edge_entry *);
 olsr_bool olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
 
-int olsr_serialize_hello_lq_pair(unsigned char *buff, struct lq_hello_neighbor *neigh);
-void olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, struct hello_neighbor *neigh);
+int olsr_serialize_hello_lq_pair(unsigned char *buff,
+                                struct lq_hello_neighbor *neigh);
+void olsr_deserialize_hello_lq_pair(const olsr_u8_t ** curr,
+                                   struct hello_neighbor *neigh);
 int olsr_serialize_tc_lq_pair(unsigned char *buff, struct tc_mpr_addr *neigh);
-void olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, struct tc_edge_entry *edge);
+void olsr_deserialize_tc_lq_pair(const olsr_u8_t ** curr,
+                                struct tc_edge_entry *edge);
 
 void olsr_update_packet_loss_worker(struct link_entry *entry, olsr_bool lost);
-void olsr_memorize_foreign_hello_lq(struct link_entry *local, struct hello_neighbor *foreign);
+void olsr_memorize_foreign_hello_lq(struct link_entry *local,
+                                   struct hello_neighbor *foreign);
 
-const char *get_link_entry_text(struct link_entry *entry, struct lqtextbuffer *buffer);
-const char *get_tc_edge_entry_text(struct tc_edge_entry *entry, struct lqtextbuffer *buffer);
-const char *get_linkcost_text(olsr_linkcost cost, olsr_bool route, struct lqtextbuffer *buffer);
+const char *get_link_entry_text(struct link_entry *entry,
+                               struct lqtextbuffer *buffer);
+const char *get_tc_edge_entry_text(struct tc_edge_entry *entry,
+                                  struct lqtextbuffer *buffer);
+const char *get_linkcost_text(olsr_linkcost cost, olsr_bool route,
+                             struct lqtextbuffer *buffer);
 
-void olsr_copy_hello_lq(struct lq_hello_neighbor *target, struct link_entry *source);
-void olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target, struct link_entry *source);
-void olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target, struct link_entry *source);
+void olsr_copy_hello_lq(struct lq_hello_neighbor *target,
+                       struct link_entry *source);
+void olsr_copylq_link_entry_2_tc_mpr_addr(struct tc_mpr_addr *target,
+                                         struct link_entry *source);
+void olsr_copylq_link_entry_2_tc_edge_entry(struct tc_edge_entry *target,
+                                           struct link_entry *source);
 void olsr_clear_tc_lq(struct tc_mpr_addr *target);
 
 struct hello_neighbor *olsr_malloc_hello_neighbor(const char *id);
@@ -112,7 +153,7 @@ struct tc_edge_entry *olsr_malloc_tc_edge_entry(const char *id);
 /* Externals. */
 extern struct lq_handler *active_lq_handler;
 
-#endif /*LQPLUGIN_H_*/
+#endif /*LQPLUGIN_H_ */
 
 /*
  * Local Variables:
diff --git a/src/lq_plugin_default.c b/src/lq_plugin_default.c
deleted file mode 100644 (file)
index b1445cd..0000000
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
- * are met:
- *
- * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in 
- *   the documentation and/or other materials provided with the 
- *   distribution.
- * * Neither the name of olsr.org, olsrd nor the names of its 
- *   contributors may be used to endorse or promote products derived 
- *   from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Visit http://www.olsr.org for more information.
- *
- * If you find this software useful feel free to make a donation
- * to the project. For more information see the website or contact
- * the copyright holders.
- *
- */
-
-#include "tc_set.h"
-#include "link_set.h"
-#include "lq_route.h"
-#include "lq_packet.h"
-#include "packet.h"
-#include "olsr.h"
-#include "lq_plugin_default.h"
-
-olsr_linkcost default_calc_cost(const void *ptr) {
-  const struct default_lq *lq = ptr;
-  
-  float etx = (lq->lq < 0.1 || lq->nlq < 0.1 ? LINK_COST_BROKEN : 1.0/(lq->lq * lq->nlq));
-  olsr_linkcost cost = (olsr_linkcost)(etx  * LQ_PLUGIN_LC_MULTIPLIER);
-  
-  if (cost > LINK_COST_BROKEN)
-    return LINK_COST_BROKEN;
-  if (cost == 0)
-    return 1;
-  return cost;
-}
-
-int default_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
-  struct default_lq *lq = ptr;
-  
-  buff[0] = (unsigned char)(lq->lq * 255);
-  buff[1] = (unsigned char)(lq->nlq * 255);
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
-  
-  return 4;
-}
-
-void default_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct default_lq *lq = ptr;
-  
-  pkt_get_lq(curr, &lq->lq);
-  pkt_get_lq(curr, &lq->nlq);
-  pkt_ignore_u16(curr);
-}
-
-olsr_bool default_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
-  if (c1 > c2) {
-    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
-  }
-  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
-}
-
-int default_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
-  struct default_lq *lq = ptr;
-  
-  buff[0] = (unsigned char)(lq->lq * 255);
-  buff[1] = (unsigned char)(lq->nlq * 255);
-  buff[2] = (unsigned char)(0);
-  buff[3] = (unsigned char)(0);
-  
-  return 4;
-}
-
-void default_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct default_lq *lq = ptr;
-  
-  pkt_get_lq(curr, &lq->lq);
-  pkt_get_lq(curr, &lq->nlq);
-  pkt_ignore_u16(curr);
-}
-
-olsr_linkcost default_packet_loss_worker(void *ptr, olsr_bool lost) {
-  struct default_lq *tlq = ptr;
-  float alpha;
-  
-  // calculate exponental factor for the new link quality, could be directly done in configuration !
-  alpha = 1 / (float)(olsr_cnf->lq_wsize);
-  
-  // exponential moving average
-  tlq->lq *= (1 - alpha);
-  if (lost == 0) {
-    tlq->lq += alpha;
-  }
-  return default_calc_cost(ptr);
-}
-
-void default_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign) {
-  struct default_lq *local = ptrLocal;
-  struct default_lq *foreign = ptrForeign;
-  
-  if (foreign) {
-    local->nlq = foreign->lq;
-  }
-  else {
-    local->nlq = 0;
-  }
-}
-
-void default_olsr_copy_link_lq_into_tc(void *target, void *source) {
-  memcpy(target, source, sizeof(struct default_lq));
-}
-
-void default_olsr_clear_lq(void *target) {
-  memset(target, 0, sizeof(struct default_lq));
-}
-
-const char *default_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer) {
-  struct default_lq *lq = ptr;
-  
-  sprintf(buffer->buf, "%2.3f/%2.3f", lq->lq, lq->nlq);
-  return buffer->buf;
-}
-
-const char *default_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer) {
-  sprintf(buffer->buf, "%2.3f", ((float)cost)/LQ_PLUGIN_LC_MULTIPLIER);
-  return buffer->buf;
-}
diff --git a/src/lq_plugin_default_float.c b/src/lq_plugin_default_float.c
new file mode 100644 (file)
index 0000000..5a574ff
--- /dev/null
@@ -0,0 +1,216 @@
+/*
+ * The olsr.org Optimized Link-State Routing daemon(olsrd)
+ * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright 
+ *   notice, this list of conditions and the following disclaimer in 
+ *   the documentation and/or other materials provided with the 
+ *   distribution.
+ * * Neither the name of olsr.org, olsrd nor the names of its 
+ *   contributors may be used to endorse or promote products derived 
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Visit http://www.olsr.org for more information.
+ *
+ * If you find this software useful feel free to make a donation
+ * to the project. For more information see the website or contact
+ * the copyright holders.
+ *
+ */
+
+#include "tc_set.h"
+#include "link_set.h"
+#include "olsr_spf.h"
+#include "lq_packet.h"
+#include "packet.h"
+#include "olsr.h"
+#include "lq_plugin_default_float.h"
+
+/* Default lq plugin settings */
+struct lq_handler lq_etx_float_handler = {
+  &default_lq_initialize_float,
+  
+  &default_lq_calc_cost_float,
+  &default_lq_calc_cost_float,
+
+  &default_lq_is_relevant_costchange_float,
+
+  &default_lq_packet_loss_worker_float,
+  &default_lq_memorize_foreign_hello_float,
+  &default_lq_copy_link2tc_float,
+  &default_lq_clear_float,
+  &default_lq_clear_float,
+
+  &default_lq_serialize_hello_lq_pair_float,
+  &default_lq_serialize_tc_lq_pair_float,
+  &default_lq_deserialize_hello_lq_pair_float,
+  &default_lq_deserialize_tc_lq_pair_float,
+
+  &default_lq_print_float,
+  &default_lq_print_float,
+  &default_lq_print_cost_float,
+
+  sizeof(struct default_lq_float),
+  sizeof(struct default_lq_float)
+};
+
+void default_lq_initialize_float(void) {
+  return;
+}
+
+olsr_linkcost default_lq_calc_cost_float(const void *ptr) {
+  const struct default_lq_float *lq = ptr;
+  olsr_linkcost cost;
+  
+  if (lq->lq < MINIMAL_USEFUL_LQ || lq->nlq < MINIMAL_USEFUL_LQ) {
+    return LINK_COST_BROKEN;
+  }
+  
+  cost = (olsr_linkcost)(1.0/(lq->lq * lq->nlq) * LQ_PLUGIN_LC_MULTIPLIER);
+  
+  if (cost > LINK_COST_BROKEN)
+    return LINK_COST_BROKEN;
+  if (cost == 0) {
+    return 1;
+  }
+  return cost;
+}
+
+int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *ptr) {
+  struct default_lq_float *lq = ptr;
+  
+  olsr_u16_t lq_value = (olsr_u16_t)(lq->lq * 65535);
+  olsr_u16_t nlq_value = (olsr_u16_t)(lq->nlq * 65535);
+  
+  buff[0] = (unsigned char)(lq_value / 256);
+  buff[1] = (unsigned char)(nlq_value / 256);
+  buff[2] = (unsigned char)(lq_value & 255);
+  buff[3] = (unsigned char)(nlq_value & 255);
+  
+  return 4;
+}
+
+void default_lq_deserialize_hello_lq_pair_float(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_float *lq = ptr;
+  
+  olsr_u8_t lq_high, lq_low, nlq_high, nlq_low;
+  olsr_u16_t lq_value, nlq_value;
+  
+  pkt_get_u8(curr, &lq_high);
+  pkt_get_u8(curr, &nlq_high);
+  pkt_get_u8(curr, &lq_low);
+  pkt_get_u8(curr, &nlq_low);
+  
+  lq_value = 256 * (olsr_u16_t)lq_high + (olsr_u16_t)lq_low;
+  nlq_value = 256 * (olsr_u16_t)nlq_high + (olsr_u16_t)nlq_low;
+  
+  lq->lq = (float)lq_value / 65535.0;
+  lq->nlq = (float)nlq_value / 65535.0;
+}
+
+olsr_bool default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2) {
+  if (c1 > c2) {
+    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
+  }
+  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
+}
+
+int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *ptr) {
+  struct default_lq_float *lq = ptr;
+  
+  olsr_u16_t lq_value = (olsr_u16_t)(lq->lq * 65535);
+  olsr_u16_t nlq_value = (olsr_u16_t)(lq->nlq * 65535);
+  
+  buff[0] = (unsigned char)(lq_value / 256);
+  buff[1] = (unsigned char)(nlq_value / 256);
+  buff[2] = (unsigned char)(lq_value & 255);
+  buff[3] = (unsigned char)(nlq_value & 255);
+  
+  return 4;
+}
+
+void default_lq_deserialize_tc_lq_pair_float(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_float *lq = ptr;
+  
+  olsr_u8_t lq_high, lq_low, nlq_high, nlq_low;
+  olsr_u16_t lq_value, nlq_value;
+  
+  pkt_get_u8(curr, &lq_high);
+  pkt_get_u8(curr, &nlq_high);
+  pkt_get_u8(curr, &lq_low);
+  pkt_get_u8(curr, &nlq_low);
+  
+  lq_value = 256 * (olsr_u16_t)lq_high + (olsr_u16_t)lq_low;
+  nlq_value = 256 * (olsr_u16_t)nlq_high + (olsr_u16_t)nlq_low;
+  
+  lq->lq = (float)lq_value / 65535.0;
+  lq->nlq = (float)nlq_value / 65535.0;
+}
+
+olsr_linkcost default_lq_packet_loss_worker_float(struct link_entry *link, void *ptr, olsr_bool lost) {
+  struct default_lq_float *tlq = ptr;
+  float alpha = olsr_cnf->lq_aging;
+  
+  if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
+    alpha = LQ_QUICKSTART_AGING; /* fast enough to get the LQ value within 6 Hellos up to 0.9 */
+    tlq->quickstart++;
+  }
+  // exponential moving average
+  tlq->lq *= (1 - alpha);
+  if (lost == 0) {
+    tlq->lq += (alpha * link->loss_link_multiplier / 65536);
+  }
+  return default_lq_calc_cost_float(ptr);
+}
+
+void default_lq_memorize_foreign_hello_float(void *ptrLocal, void *ptrForeign) {
+  struct default_lq_float *local = ptrLocal;
+  struct default_lq_float *foreign = ptrForeign;
+  
+  if (foreign) {
+    local->nlq = foreign->lq;
+  }
+  else {
+    local->nlq = 0;
+  }
+}
+
+void default_lq_copy_link2tc_float(void *target, void *source) {
+  memcpy(target, source, sizeof(struct default_lq_float));
+}
+
+void default_lq_clear_float(void *target) {
+  memset(target, 0, sizeof(struct default_lq_float));
+}
+
+const char *default_lq_print_float(void *ptr, struct lqtextbuffer *buffer) {
+  struct default_lq_float *lq = ptr;
+  
+  sprintf(buffer->buf, "%2.3f/%2.3f", lq->lq, lq->nlq);
+  return buffer->buf;
+}
+
+const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer) {
+  sprintf(buffer->buf, "%2.3f", ((float)cost)/LQ_PLUGIN_LC_MULTIPLIER);
+  return buffer->buf;
+}
similarity index 65%
rename from src/lq_plugin_default.h
rename to src/lq_plugin_default_float.h
index aec7def..09b8aaa 100644 (file)
 #include "olsr_types.h"
 #include "lq_plugin.h"
 
+#define LQ_ALGORITHM_ETX_FLOAT_NAME "etx_float"
+
 #define LQ_PLUGIN_LC_MULTIPLIER 1024
 #define LQ_PLUGIN_RELEVANT_COSTCHANGE 8
 
-struct default_lq {
-       float lq, nlq;
+struct default_lq_float {
+  float lq, nlq;
+  olsr_u16_t quickstart;
 };
 
-olsr_linkcost default_calc_cost(const void *lq);
+void default_lq_initialize_float(void);
+
+olsr_linkcost default_lq_calc_cost_float(const void *lq);
+
+olsr_bool default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2);
 
-olsr_bool default_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
+olsr_linkcost default_lq_packet_loss_worker_float(struct link_entry *link, void *lq, olsr_bool lost);
+void default_lq_memorize_foreign_hello_float(void *local, void *foreign);
 
-olsr_linkcost default_packet_loss_worker(void *lq, olsr_bool lost);
-void default_olsr_memorize_foreign_hello_lq(void *local, void *foreign);
+int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *lq);
+void default_lq_deserialize_hello_lq_pair_float(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *lq);
+void default_lq_deserialize_tc_lq_pair_float(const olsr_u8_t **curr, void *lq);
 
-int default_olsr_serialize_hello_lq_pair(unsigned char *buff, void *lq);
-void default_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *lq);
-int default_olsr_serialize_tc_lq_pair(unsigned char *buff, void *lq);
-void default_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *lq);
+void default_lq_copy_link2tc_float(void *target, void *source);
+void default_lq_clear_float(void *target);
 
-void default_olsr_copy_link_lq_into_tc(void *target, void *source);
-void default_olsr_clear_lq(void *target);
+const char *default_lq_print_float(void *ptr, struct lqtextbuffer *buffer);
+const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer);
 
-const char *default_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer);
-const char *default_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer);
+extern struct lq_handler lq_etx_float_handler;
 
 #endif /*LQ_PLUGIN_DEFAULT_H_*/
similarity index 53%
rename from lib/lq_etx_fpm/src/lq_etx_fpm.c
rename to src/lq_plugin_default_fpm.c
index 48248a7..bb901a5 100644 (file)
 #include "tc_set.h"
 #include "link_set.h"
 #include "lq_plugin.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "lq_packet.h"
 #include "packet.h"
 #include "olsr.h"
-#include "lq_etx_fpm.h"
+#include "lq_plugin_default_fpm.h"
 #include "fpm.h"
 
 /* etx lq plugin (fpm version) settings */
 struct lq_handler lq_etx_fpm_handler = {
-    &lq_etx_fpm_calc_cost,
-    &lq_etx_fpm_calc_cost,
+    &default_lq_initialize_fpm,
     
-    &lq_etx_fpm_olsr_is_relevant_costchange,
+    &default_lq_calc_cost_fpm,
+    &default_lq_calc_cost_fpm,
     
-    &lq_etx_fpm_packet_loss_worker,
-    &lq_etx_fpm_olsr_memorize_foreign_hello_lq,
-    &lq_etx_fpm_olsr_copy_link_lq_into_tc,
-    &lq_etx_fpm_olsr_clear_lq,
-    &lq_etx_fpm_olsr_clear_lq,
+    &default_lq_is_relevant_costchange_fpm,
     
-    &lq_etx_fpm_olsr_serialize_hello_lq_pair,
-    &lq_etx_fpm_olsr_serialize_tc_lq_pair,
-    &lq_etx_fpm_olsr_deserialize_hello_lq_pair,
-    &lq_etx_fpm_olsr_deserialize_tc_lq_pair,
+    &default_lq_packet_loss_worker_fpm,
+    &default_lq_memorize_foreign_hello_fpm,
+    &default_lq_copy_link2tc_fpm,
+    &default_lq_clear_fpm,
+    &default_lq_clear_fpm,
     
-    &lq_etx_fpm_olsr_print_lq,
-    &lq_etx_fpm_olsr_print_lq,
-    &lq_etx_fpm_olsr_print_cost, 
+    &default_lq_serialize_hello_lq_pair_fpm,
+    &default_lq_serialize_tc_lq_pair_fpm,
+    &default_lq_deserialize_hello_lq_pair_fpm,
+    &default_lq_deserialize_tc_lq_pair_fpm,
     
-    sizeof(struct lq_etx_fpm),
-    sizeof(struct lq_etx_fpm)
+    &default_lq_print_fpm,
+    &default_lq_print_fpm,
+    &default_lq_print_cost_fpm, 
+    
+    sizeof(struct default_lq_fpm),
+    sizeof(struct default_lq_fpm)
 };
 
-fpm MINIMAL_LQ;
-fpm aging_factor1, aging_factor2;
-
-void set_lq_etx_fpm_alpha(fpm alpha) {
-  OLSR_PRINTF(3, "lq_etx_fpm: Set alpha to %s\n", fpmtoa(alpha));
-  aging_factor1 = alpha;
-  aging_factor2 = fpmsub(itofpm(1), alpha);
-}
+fpm minimal_lq;
+fpm aging_factor_new, aging_factor_old;
+fpm aging_quickstart_new, aging_quickstart_old;
 
-int init_lq_etx_fpm(void) {
-  if (aging_factor1 == 0 && aging_factor2 == 0) {
-    OLSR_PRINTF(1, "Alpha factor for lq_etx_fgm not set !\n");
-    return 0; // error
-  }
+void default_lq_initialize_fpm(void) {
+  aging_factor_new = ftofpm(olsr_cnf->lq_aging);
+  aging_factor_old = fpmsub(itofpm(1), aging_factor_new);
   
-  MINIMAL_LQ = ftofpm(0.1);
+  aging_quickstart_new = ftofpm(LQ_QUICKSTART_AGING);
+  aging_quickstart_old = fpmsub(itofpm(1), aging_quickstart_new);
   
-  // activate plugin
-  set_lq_handler(&lq_etx_fpm_handler, LQ_ETX_FPM_HANDLER_NAME);
-  return 1;
+  minimal_lq = ftofpm(MINIMAL_USEFUL_LQ);
 }
 
-olsr_linkcost lq_etx_fpm_calc_cost(const void *ptr) {
-  const struct lq_etx_fpm *lq = ptr;
+olsr_linkcost default_lq_calc_cost_fpm(const void *ptr) {
+  const struct default_lq_fpm *lq = ptr;
   olsr_linkcost cost;
   
-  if (lq->lq < MINIMAL_LQ || lq->nlq < MINIMAL_LQ) {
+  if (lq->lq < minimal_lq || lq->nlq < minimal_lq) {
     return LINK_COST_BROKEN;
   }
   
@@ -113,8 +107,8 @@ olsr_linkcost lq_etx_fpm_calc_cost(const void *ptr) {
   return cost;
 }
 
-int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   
   buff[0] = (unsigned char)fpmtoi(fpmmuli(lq->lq, 255));
   buff[1] = (unsigned char)fpmtoi(fpmmuli(lq->nlq, 255));
@@ -124,8 +118,8 @@ int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+void default_lq_deserialize_hello_lq_pair_fpm(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   olsr_u8_t valueLq, valueNlq;
   
   pkt_get_u8(curr, &valueLq);
@@ -136,15 +130,15 @@ void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr
   lq->nlq = fpmidiv(itofpm((int)valueNlq), 255);
 }
 
-olsr_bool lq_etx_fpm_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
+olsr_bool default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2) {
   if (c1 > c2) {
-    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
+    return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM;
   }
-  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
+  return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM;
 }
 
-int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   
   buff[0] = (unsigned char)fpmtoi(fpmmuli(lq->lq, 255));
   buff[1] = (unsigned char)fpmtoi(fpmmuli(lq->nlq, 255));
@@ -154,8 +148,8 @@ int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+void default_lq_deserialize_tc_lq_pair_fpm(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   olsr_u8_t valueLq, valueNlq;
   
   pkt_get_u8(curr, &valueLq);
@@ -166,20 +160,30 @@ void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
   lq->nlq = fpmidiv(itofpm(valueNlq), 255);
 }
 
-olsr_linkcost lq_etx_fpm_packet_loss_worker(void *ptr, olsr_bool lost) {
-  struct lq_etx_fpm *tlq = ptr;
+olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *ptr, olsr_bool lost) {
+  struct default_lq_fpm *tlq = ptr;
+  fpm alpha_old = aging_factor_old;
+  fpm alpha_new = aging_factor_new;
+  
+  fpm link_loss_factor = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
+  
+  if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
+    alpha_new = aging_quickstart_new;
+    alpha_old = aging_quickstart_old;
+    tlq->quickstart++;
+  }
   
   // exponential moving average
-  tlq->lq = fpmmul(tlq->lq, aging_factor2);
+  tlq->lq = fpmmul(tlq->lq, alpha_old);
   if (lost == 0) {
-    tlq->lq = fpmadd(tlq->lq, aging_factor1);
+    tlq->lq = fpmadd(tlq->lq, fpmmul(alpha_new, link_loss_factor));
   }
-  return lq_etx_fpm_calc_cost(ptr);
+  return default_lq_calc_cost_fpm(ptr);
 }
 
-void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign) {
-  struct lq_etx_fpm *local = ptrLocal;
-  struct lq_etx_fpm *foreign = ptrForeign;
+void default_lq_memorize_foreign_hello_fpm(void *ptrLocal, void *ptrForeign) {
+  struct default_lq_fpm *local = ptrLocal;
+  struct default_lq_fpm *foreign = ptrForeign;
   
   if (foreign) {
     local->nlq = foreign->lq;
@@ -189,22 +193,22 @@ void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign)
   }
 }
 
-void lq_etx_fpm_olsr_copy_link_lq_into_tc(void *target, void *source) {
-  memcpy(target, source, sizeof(struct lq_etx_fpm));
+void default_lq_copy_link2tc_fpm(void *target, void *source) {
+  memcpy(target, source, sizeof(struct default_lq_fpm));
 }
 
-void lq_etx_fpm_olsr_clear_lq(void *target) {
-  memset(target, 0, sizeof(struct lq_etx_fpm));
+void default_lq_clear_fpm(void *target) {
+  memset(target, 0, sizeof(struct default_lq_fpm));
 }
 
-const char *lq_etx_fpm_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer) {
-  struct lq_etx_fpm *lq = ptr;
+const char *default_lq_print_fpm(void *ptr, struct lqtextbuffer *buffer) {
+  struct default_lq_fpm *lq = ptr;
   
   sprintf(buffer->buf, "%s/%s", fpmtoa(lq->lq), fpmtoa(lq->nlq));
   return buffer->buf;
 }
 
-const char *lq_etx_fpm_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer) {
+const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer) {
   sprintf(buffer->buf, "%s", fpmtoa(cost));
   return buffer->buf;
 }
similarity index 65%
rename from lib/lq_etx_fpm/src/lq_etx_fpm.h
rename to src/lq_plugin_default_fpm.h
index 97b049c..30ccebe 100644 (file)
 #include "lq_plugin.h"
 
 #define LQ_PLUGIN_LC_MULTIPLIER 1024
-#define LQ_PLUGIN_RELEVANT_COSTCHANGE 16
+#define LQ_PLUGIN_RELEVANT_COSTCHANGE_FPM 16
 
-#define LQ_ETX_FPM_HANDLER_NAME "ETX metric with FPM"
-struct lq_etx_fpm {
+#define LQ_ALGORITHM_ETX_FPM_NAME "etx_fpm"
+struct default_lq_fpm {
        fpm lq, nlq;
+       olsr_u16_t quickstart;
 };
 
-void set_lq_etx_fpm_alpha(fpm alpha);
-int init_lq_etx_fpm(void);
+void default_lq_initialize_fpm(void);
 
-olsr_linkcost lq_etx_fpm_calc_cost(const void *lq);
+olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
 
-olsr_bool lq_etx_fpm_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
+olsr_bool default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2);
 
-olsr_linkcost lq_etx_fpm_packet_loss_worker(void *lq, olsr_bool lost);
-void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *local, void *foreign);
+olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *lq, olsr_bool lost);
+void default_lq_memorize_foreign_hello_fpm(void *local, void *foreign);
 
-int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *lq);
-void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *lq);
-int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *lq);
-void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *lq);
+void default_lq_deserialize_hello_lq_pair_fpm(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *lq);
+void default_lq_deserialize_tc_lq_pair_fpm(const olsr_u8_t **curr, void *lq);
 
-void lq_etx_fpm_olsr_copy_link_lq_into_tc(void *target, void *source);
-void lq_etx_fpm_olsr_clear_lq(void *target);
+void default_lq_copy_link2tc_fpm(void *target, void *source);
+void default_lq_clear_fpm(void *target);
 
-const char *lq_etx_fpm_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer);
-const char *lq_etx_fpm_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer);
+const char *default_lq_print_fpm(void *ptr, struct lqtextbuffer *buffer);
+const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer);
+
+extern struct lq_handler lq_etx_fpm_handler;
 
 #endif /*LQ_ETX_FPM_*/
index cc3f56f..9c3776b 100644 (file)
@@ -404,7 +404,7 @@ main(int argc, char *argv[])
   signal(SIGQUIT, olsr_shutdown);
   signal(SIGILL,  olsr_shutdown);
   signal(SIGABRT, olsr_shutdown);
-  signal(SIGSEGV, olsr_shutdown);
+//  signal(SIGSEGV, olsr_shutdown);
   signal(SIGTERM, olsr_shutdown);
   signal(SIGPIPE, SIG_IGN);
 #endif
@@ -502,6 +502,9 @@ olsr_shutdown(int signal __attribute__((unused)))
   close(olsr_cnf->rts);
 #endif
 
+  /* Free cookies and memory pools attached. */
+  olsr_delete_all_cookies();
+
   olsr_syslog(OLSR_LOG_INFO, "%s stopped", olsrd_version);
 
   OLSR_PRINTF(1, "\n <<<< %s - terminating >>>>\n           http://www.olsr.org\n", olsrd_version);
@@ -525,7 +528,7 @@ print_usage(void)
           "  [-hint <hello interval (secs)>] [-tcint <tc interval (secs)>]\n"
           "  [-midint <mid interval (secs)>] [-hnaint <hna interval (secs)>]\n"
           "  [-T <Polling Rate (secs)>] [-nofork] [-hemu <ip_address>]\n"
-          "  [-lql <LQ level>] [-lqw <LQ winsize>]\n");
+          "  [-lql <LQ level>] [-lqa <LQ aging factor>]\n");
 }
 
 
@@ -643,21 +646,21 @@ olsr_process_arguments(int argc, char *argv[],
       /*
        * Set LQ winsize
        */
-      if (strcmp(*argv, "-lqw") == 0) 
+      if (strcmp(*argv, "-lqa") == 0) 
        {
-         int tmp_lq_wsize;
+         float tmp_lq_aging;
          NEXT_ARG;
           CHECK_ARGC;
          
-         sscanf(*argv, "%d", &tmp_lq_wsize);
+         sscanf(*argv, "%f", &tmp_lq_aging);
 
-         if(tmp_lq_wsize < MIN_LQ_WSIZE || tmp_lq_wsize > MAX_LQ_WSIZE)
+         if(tmp_lq_aging < MIN_LQ_AGING || tmp_lq_aging > MAX_LQ_AGING)
            {
-             printf("LQ winsize %d not allowed. Range [%d-%d]\n", 
-                    tmp_lq_wsize, MIN_LQ_WSIZE, MAX_LQ_WSIZE);
+             printf("LQ aging factor %f not allowed. Range [%f-%f]\n", 
+                    tmp_lq_aging, MIN_LQ_AGING, MAX_LQ_AGING);
              olsr_exit(__func__, EXIT_FAILURE);
            }
-         olsr_cnf->lq_wsize = tmp_lq_wsize;
+         olsr_cnf->lq_aging = tmp_lq_aging;
          continue;
        }
       
index 83654a6..e178c00 100644 (file)
  *
  *@return a 8-bit mantissa/exponent product
  */
-
-olsr_u8_t
-double_to_me(const double interval)
-{
-    olsr_u8_t a, b;
-
-    /* It is sufficent to compare the integer part since we test on >=.
-     * So we have now only a floating point division and the rest of the loop
-     * are only integer operations.
-     */
-    const unsigned int unscaled_interval = interval / VTIME_SCALE_FACTOR;
+olsr_u8_t reltime_to_me(const olsr_reltime interval) {
+  olsr_u8_t a, b;
+  
+  /* It is sufficent to compare the integer part since we test on >=.
+   * So we have now only a floating point division and the rest of the loop
+   * are only integer operations.
+   * 
+   * const unsigned int unscaled_interval = interval / VTIME_SCALE_FACTOR;
+   * 
+   * VTIME_SCALE_FACTOR = 1/16
+   * 
+   * => unscaled_interval = interval(ms) / 1000 * 16
+   *                      = interval(ms) / 125 * 2
+   */
+  const unsigned int unscaled_interval = interval / 125 * 2;
+  b = 0;
+  while (unscaled_interval >= (1U << b)) {
+    b++;
+  }
+  
+  if (b == 0) {
+    a = 1;
     b = 0;
-    while (unscaled_interval >= (1U << b)) {
-        b++;
-    }
-
-    if(b == 0) {
-        a = 1;
-        b = 0;
+  } else {
+    b--;
+    if (b > 15) {
+      a = 15;
+      b = 15;
     } else {
-        b--;
-        if (b > 15) {
-            a = 15;
-            b = 15;
-        } else {
-            /* And again some maths simplification from the former version:
-             *    a = 16 * ((double)interval / (VTIME_SCALE_FACTOR * (double)(1 << b)) - 1)
-             * Since interval is already double:
-             *    a = 16 * (interval / (VTIME_SCALE_FACTOR * (double)(1 << b)) - 1)
-             * first, we can get rid of parentheses and change the * to a /
-             *    a = 16 * (interval / VTIME_SCALE_FACTOR / (double)(1 << b) - 1)
-             * then we make an integer addition from the floating point addition
-             *    a = (int)(16.0 * interval / VTIME_SCALE_FACTOR / (double)(1 << b)) - 16
-             * and we loose an unnecessary cast
-             *    a = (int)(16.0 * interval / VTIME_SCALE_FACTOR / (1 << b)) - 16
-             */
-            a = (int)(16.0 * interval / VTIME_SCALE_FACTOR / (1 << b)) - 16;
-            b += a >> 4;
-            a &= 0x0f;
-        }
+      /* And again some maths simplification from the former version:
+       *    a = 16 * ((double)interval / (VTIME_SCALE_FACTOR * (double)(1 << b)) - 1)
+       * Since interval is already double:
+       *    a = 16 * (interval / (VTIME_SCALE_FACTOR * (double)(1 << b)) - 1)
+       * first, we can get rid of parentheses and change the * to a /
+       *    a = 16 * (interval / VTIME_SCALE_FACTOR / (double)(1 << b) - 1)
+       * then we make an integer addition from the floating point addition
+       *    a = (int)(16.0 * interval / VTIME_SCALE_FACTOR / (double)(1 << b)) - 16
+       * and we loose an unnecessary cast
+       *    a = (int)(16.0 * interval / VTIME_SCALE_FACTOR / (1 << b)) - 16
+       * 
+       * VTIME_SCALE_FACTOR = 1/16
+       * 
+       * => a = (16 * interval(ms) / 1000 * 16 / (1 << b)) - 16
+       *      = (interval(ms) * 256 / 1000 / (1 << b)) - 16
+       *      = (interval(ms) * 32 / 125 / (1<<b)) - 16
+       *      = (interval(ms) - 16/32*125*(1<<b)) * 32 / 125 / (1<<b)
+       *      = (interval(ms) - 125*(1<<(b-1))) * 32 / 125 / (1<<b)
+       * 
+       * 1. case: b >= 5
+       *      = (interval(ms) - (125 << (b-1))) / 125 / (1 << (b-5))
+       *      = (interval(ms) - (125 << (b-1))) / (125  << (b-5))
+       * 
+       * 2. case: b <= 5
+       *      = (interval(ms) - (125 << (b-1))) / 125 * (1 << (5-b))
+       *      = (interval(ms) - (125 << (b-1))) * (1 << (5-b)) / 125
+       */
+
+      if (b >= 5) {
+        a = (interval - (125 << (b-1))) / (125 << (b-5));
+      }
+      else {
+        a = (interval - (125 << (b-1))) * (1 << (5-b)) / 125;
+      }
+      
+      b += a >> 4;
+      a &= 0x0f;
     }
-    //printf("Generated mantissa/exponent(%d/%d): %d from %f\n", a, b, (olsr_u8_t) (a*16+b), interval);  //printf("Resolves back to: %f\n", me_to_double(((a<<4)|(b&0x0F))));
-    return (a << 4) | (b & 0x0F);
+  }
+  
+  return (a << 4) | (b & 0x0F);
 }
 
 /**
@@ -123,47 +150,23 @@ double_to_me(const double interval)
  *     value = C * ((16 + a) << b) / 16
  * and sionce C and 16 are constants
  *     value = ((16 + a) << b) * C / 16
+ * 
+ * VTIME_SCALE_FACTOR = 1/16
+ * 
+ * =>  value(ms) = ((16 + a) << b) / 256 * 1000
+ * 
+ * 1. case: b >= 8
+ *           = ((16 + a) << (b-8)) * 1000
+ * 
+ * 2. case: b <= 8
+ *           = ((16 + a) * 1000) >> (8-b)
  */
-double me_to_double(const olsr_u8_t me)
-{
-    const olsr_u8_t a = me >> 4;
-    const olsr_u8_t b = me & 0x0F;
-    return ((16 + a) << b) * VTIME_SCALE_FACTOR / 16.0;
-}
-
-#if 0
-/*
- * Since the original VTIME_SCALE_FACTOR simply divides
- * values by 16 (equals >> 4), we can shorten calculations.
- * For details refer to RFC 3626 (search for "mantissa").
- */
-olsr_u8_t fpm_to_me(const fpm interval)
-{
-  olsr_u8_t a = 0, b = 0; /* Underflow defaults */
-  const unsigned int unscaled_interval = (sfpm)interval >> (FPM_BIT - 4);
-
-  while (unscaled_interval >= (1U << b)) b++;
-
-  if (0 < b) {
-    b--;
-    if (15 < b) {
-      a = 15; /* Overflow defaults */
-      b = 15;
-    }
-    else
-    {
-      assert(FPM_BIT >= 8);
-      a = ((sfpm)interval >> (FPM_BIT + b - 8)) - 16;
-    }
-  }
-  return (a << 4) | (b & 0x0F);
-}
-
-fpm me_to_fpm(const olsr_u8_t me)
-{
+olsr_reltime me_to_reltime(const olsr_u8_t me) {
   const olsr_u8_t a = me >> 4;
   const olsr_u8_t b = me & 0x0F;
-  assert(FPM_BIT >= 8);
-  return (fpm)(((sfpm)a + 16) << (b + FPM_BIT - 8));
+  
+  if (b >= 8) {
+    return ((16 + a) << (b-8)) * 1000;
+  }
+  return ((16 + a) * 1000) >> (8-b);
 }
-#endif
index 918ec44..7764b1a 100644 (file)
 #define _OLSR_MANTISSA
 
 #include "olsr_types.h"
-#include "olsr_protocol.h"
 
+/* olsr_reltime is a relative timestamp measured in microseconds */
+typedef olsr_u32_t olsr_reltime;
 
 /**
  * Macro for converting a mantissa/exponent 8bit value back
- * to double as described in RFC3626:
+ * to an integer (measured in microseconds) as described in RFC3626:
  *
  * value = C*(1+a/16)*2^b [in seconds]
  *
@@ -59,8 +60,8 @@
  * me is the 8 bit mantissa/exponent value
  *
  */
-double me_to_double(const olsr_u8_t);
+olsr_reltime me_to_reltime(const olsr_u8_t);
 
-olsr_u8_t double_to_me(const double);
+olsr_u8_t reltime_to_me(const olsr_reltime);
 
 #endif
index 9148d35..753f310 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
@@ -47,7 +48,7 @@
 #include "neighbor_table.h"
 #include "link_set.h"
 #include "tc_set.h"
-#include "packet.h" /* struct mid_alias */
+#include "packet.h"            /* struct mid_alias */
 #include "net_olsr.h"
 
 
@@ -60,7 +61,6 @@ struct mid_entry *mid_lookup_entry_bymain(const union olsr_ip_addr *adr);
  * Initialize the MID set
  *
  */
-
 int
 olsr_init_mid_set(void)
 {
@@ -68,14 +68,13 @@ olsr_init_mid_set(void)
 
   OLSR_PRINTF(5, "MID: init\n");
 
-  for(idx=0;idx<HASHSIZE;idx++)
-    {
-      mid_set[idx].next = &mid_set[idx];
-      mid_set[idx].prev = &mid_set[idx];
+  for (idx = 0; idx < HASHSIZE; idx++) {
+    mid_set[idx].next = &mid_set[idx];
+    mid_set[idx].prev = &mid_set[idx];
 
-      reverse_mid_set[idx].next = &reverse_mid_set[idx];
-      reverse_mid_set[idx].prev = &reverse_mid_set[idx];
-    }
+    reverse_mid_set[idx].next = &reverse_mid_set[idx];
+    reverse_mid_set[idx].prev = &reverse_mid_set[idx];
+  }
 
   return 1;
 }
@@ -96,10 +95,10 @@ olsr_expire_mid_entry(void *context)
 
 #ifdef DEBUG
   OLSR_PRINTF(1, "MID info for %s timed out.. deleting it\n",
-              olsr_ip_to_string(&buf, &mid->main_addr));
+             olsr_ip_to_string(&buf, &mid->main_addr));
 #endif
 
-  mid_delete_node(mid);
+  olsr_delete_mid_entry(mid);
 }
 
 
@@ -110,27 +109,27 @@ olsr_expire_mid_entry(void *context)
  * The timer param is a relative timer expressed in milliseconds.
  */
 static void
-olsr_set_mid_timer(struct mid_entry *mid, unsigned int rel_timer)
+olsr_set_mid_timer(struct mid_entry *mid, olsr_reltime rel_timer)
 {
 
   olsr_set_timer(&mid->mid_timer, rel_timer, OLSR_MID_JITTER,
-                 OLSR_TIMER_ONESHOT, &olsr_expire_mid_entry, mid, 0);
+                OLSR_TIMER_ONESHOT, &olsr_expire_mid_entry, mid, 0);
 }
 
 
 /**
- *Insert a new interface alias to the interface association set.
- *If the main interface of the association is not yet registered
- *in the set a new entry is created.
- *
- *@param m_addr the main address of the node
- *@param alias the alias address to insert
+ * Insert a new interface alias to the interface association set.
+ * If the main interface of the association is not yet registered
+ * in the set a new entry is created.
  *
- *@return nada
+ * @param m_addr the main address of the node
+ * @param alias the alias address to insert
+ * @return nada
  */
 
-void 
-insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias, float vtime)
+void
+insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias,
+                olsr_reltime vtime)
 {
   struct mid_entry *tmp;
   struct mid_address *tmp_adr;
@@ -141,52 +140,48 @@ insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias, float vt
   alias_hash = olsr_ip_hashing(&alias->alias);
 
   /* Check for registered entry */
-  for(tmp = mid_set[hash].next;
-      tmp != &mid_set[hash];
-      tmp = tmp->next)
-    {
-      if(ipequal(&tmp->main_addr, m_addr))
-       break;
-     }
+  for (tmp = mid_set[hash].next; tmp != &mid_set[hash]; tmp = tmp->next) {
+    if (ipequal(&tmp->main_addr, m_addr))
+      break;
+  }
 
   /* Check if alias is already registered with m_addr */
   registered_m_addr = mid_lookup_main_addr(&alias->alias);
-  if (registered_m_addr != NULL && ipequal(registered_m_addr, m_addr))
-    {
-      /* Alias is already registered with main address. Nothing to do here. */
-      return;
-    }
+  if (registered_m_addr != NULL && ipequal(registered_m_addr, m_addr)) {
+
+    /* Alias is already registered with main address. Nothing to do here. */
+    return;
+  }
 
   /*
    * Add a rt_path for the alias.
    */
   olsr_insert_routing_table(&alias->alias, olsr_cnf->maxplen, m_addr,
-                            OLSR_RT_ORIGIN_MID);
+                           OLSR_RT_ORIGIN_MID);
+
+  /*If the address was registered */
+  if (tmp != &mid_set[hash]) {
+    tmp_adr = tmp->aliases;
+    tmp->aliases = alias;
+    alias->main_entry = tmp;
+    QUEUE_ELEM(reverse_mid_set[alias_hash], alias);
+    alias->next_alias = tmp_adr;
+    olsr_set_mid_timer(tmp, vtime);
+  } else {
+
+    /*Create new node */
+    tmp = olsr_malloc(sizeof(struct mid_entry), "MID new alias");
+
+    tmp->aliases = alias;
+    alias->main_entry = tmp;
+    QUEUE_ELEM(reverse_mid_set[alias_hash], alias);
+    tmp->main_addr = *m_addr;
+    olsr_set_mid_timer(tmp, vtime);
+
+    /* Queue */
+    QUEUE_ELEM(mid_set[hash], tmp);
+  }
 
-  /*If the address was registered*/ 
-  if(tmp != &mid_set[hash])
-    {
-      tmp_adr = tmp->aliases;
-      tmp->aliases = alias;
-      alias->main_entry = tmp;
-      QUEUE_ELEM(reverse_mid_set[alias_hash], alias);
-      alias->next_alias = tmp_adr;
-      olsr_set_mid_timer(tmp, vtime * MSEC_PER_SEC);
-    }
-  else
-    {
-      /*Create new node*/
-      tmp = olsr_malloc(sizeof(struct mid_entry), "MID new alias");
-
-      tmp->aliases = alias;
-      alias->main_entry = tmp;
-      QUEUE_ELEM(reverse_mid_set[alias_hash], alias);
-      tmp->main_addr = *m_addr;
-      olsr_set_mid_timer(tmp, vtime * MSEC_PER_SEC);
-      /* Queue */
-      QUEUE_ELEM(mid_set[hash], tmp);
-    }
-  
 
 
   /*
@@ -199,66 +194,64 @@ insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias, float vt
 
   tmp_adr = alias;
 
-  while(tmp_adr)
-    {
-      struct neighbor_2_entry *tmp_2_neighbor;
-      struct neighbor_entry *tmp_neigh, *real_neigh;
+  while (tmp_adr) {
+    struct neighbor_2_entry *tmp_2_neighbor;
+    struct neighbor_entry *tmp_neigh, *real_neigh;
 
-      /* Delete possible 2 hop neighbor */
-      if((tmp_2_neighbor = olsr_lookup_two_hop_neighbor_table_mid(&tmp_adr->alias)) != NULL)
-       {
+    /* Delete possible 2 hop neighbor */
+    if ((tmp_2_neighbor =
+        olsr_lookup_two_hop_neighbor_table_mid(&tmp_adr->alias)) != NULL) {
 #ifndef NODEBUG
-          struct ipaddr_str buf;
+      struct ipaddr_str buf;
 #endif
-         OLSR_PRINTF(1, "Deleting 2 hop node from MID: %s to ", olsr_ip_to_string(&buf, &tmp_adr->alias));
-         OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf, m_addr));
-
-         olsr_delete_two_hop_neighbor_table(tmp_2_neighbor);
+      OLSR_PRINTF(1, "Deleting 2 hop node from MID: %s to ",
+                 olsr_ip_to_string(&buf, &tmp_adr->alias));
+      OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf, m_addr));
 
-         changes_neighborhood = OLSR_TRUE;
-       }
+      olsr_delete_two_hop_neighbor_table(tmp_2_neighbor);
 
-      /* Delete a possible neighbor entry */
-      if(((tmp_neigh = olsr_lookup_neighbor_table_alias(&tmp_adr->alias)) != NULL)
-        && ((real_neigh = olsr_lookup_neighbor_table_alias(m_addr)) != NULL))
+      changes_neighborhood = OLSR_TRUE;
+    }
 
-       {
+    /* Delete a possible neighbor entry */
+    if (((tmp_neigh =
+         olsr_lookup_neighbor_table_alias(&tmp_adr->alias)) != NULL)
+       && ((real_neigh = olsr_lookup_neighbor_table_alias(m_addr)) != NULL))
+    {
 #ifndef NODEBUG
-          struct ipaddr_str buf;
+      struct ipaddr_str buf;
 #endif
-         OLSR_PRINTF(1, "[MID]Deleting bogus neighbor entry %s real ", olsr_ip_to_string(&buf, &tmp_adr->alias));
-         OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf, m_addr));
+      OLSR_PRINTF(1, "[MID]Deleting bogus neighbor entry %s real ",
+                 olsr_ip_to_string(&buf, &tmp_adr->alias));
+      OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf, m_addr));
 
-         replace_neighbor_link_set(tmp_neigh, real_neigh);
+      replace_neighbor_link_set(tmp_neigh, real_neigh);
 
-         /* Dequeue */
-         DEQUEUE_ELEM(tmp_neigh);
-         /* Delete */
-         free(tmp_neigh);
+      /* Dequeue */
+      DEQUEUE_ELEM(tmp_neigh);
+      /* Delete */
+      free(tmp_neigh);
 
-         changes_neighborhood = OLSR_TRUE;
-       }
-      
-      tmp_adr = tmp_adr->next_alias;
+      changes_neighborhood = OLSR_TRUE;
     }
-
-
+    tmp_adr = tmp_adr->next_alias;
+  }
 }
 
 
 /**
- *Insert an alias address for a node.
- *If the main address is not registered
- *then a new entry is created.
+ * Insert an alias address for a node.
+ * If the main address is not registered
+ * then a new entry is created.
  *
- *@param main_add the main address of the node
- *@param alias the alias address to insert
- *@param seq the sequence number to register a new node with
- *
- *@return nada
+ * @param main_add the main address of the node
+ * @param alias the alias address to insert
+ * @param seq the sequence number to register a new node with
+ * @return nada
  */
 void
-insert_mid_alias(union olsr_ip_addr *main_add, const union olsr_ip_addr *alias, float vtime)
+insert_mid_alias(union olsr_ip_addr *main_add, const union olsr_ip_addr *alias,
+                olsr_reltime vtime)
 {
   struct neighbor_entry *ne_old, *ne_new;
   struct mid_entry *me_old;
@@ -267,8 +260,9 @@ insert_mid_alias(union olsr_ip_addr *main_add, const union olsr_ip_addr *alias,
   struct ipaddr_str buf1, buf2;
 #endif
   struct mid_address *adr;
-  if (!olsr_validate_address(alias)) return;
-  
+  if (!olsr_validate_address(alias))
+    return;
+
   OLSR_PRINTF(1, "Inserting alias %s for ", olsr_ip_to_string(&buf1, alias));
   OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf1, main_add));
 
@@ -276,47 +270,55 @@ insert_mid_alias(union olsr_ip_addr *main_add, const union olsr_ip_addr *alias,
 
   adr->alias = *alias;
   adr->next_alias = NULL;
-  
-  // If we have an entry for this alias in neighbortable, we better adjust it's
-  // main address, because otherwise a fatal inconsistency between
-  // neighbortable and link_set will be created by way of this mid entry.
+
+  /*
+   * If we have an entry for this alias in neighbortable, we better adjust it's
+   * main address, because otherwise a fatal inconsistency between
+   * neighbortable and link_set will be created by way of this mid entry.
+   */
   ne_old = olsr_lookup_neighbor_table_alias(alias);
   if (ne_old != NULL) {
-     OLSR_PRINTF(2, "Remote main address change detected. Mangling neighbortable to replace %s with %s.\n", olsr_ip_to_string(&buf1, alias), olsr_ip_to_string(&buf2, main_add));
-     olsr_delete_neighbor_table(alias);
-     ne_new = olsr_insert_neighbor_table(main_add);
-     // adjust pointers to neighbortable-entry in link_set
-     ne_ref_rp_count = replace_neighbor_link_set(ne_old, ne_new);
-     if (ne_ref_rp_count > 0)
-        OLSR_PRINTF(2, "Performed %d neighbortable-pointer replacements (%p -> %p) in link_set.\n", ne_ref_rp_count, ne_old, ne_new);
-     
-     me_old = mid_lookup_entry_bymain(alias);
-     if (me_old) {
-        // we knew aliases to the previous main address; better forget about
-        // them now.
-        OLSR_PRINTF(2, "I already have an mid entry mapping addresses to this alias address. Removing existing mid entry to preserve consistency of mid_set.\n");
-        mid_delete_node(me_old);
-     }
+    OLSR_PRINTF(2,
+               "Remote main address change detected. Mangling neighbortable to replace %s with %s.\n",
+               olsr_ip_to_string(&buf1, alias), olsr_ip_to_string(&buf2,
+                                                                  main_add));
+    olsr_delete_neighbor_table(alias);
+    ne_new = olsr_insert_neighbor_table(main_add);
+    /* adjust pointers to neighbortable-entry in link_set */
+    ne_ref_rp_count = replace_neighbor_link_set(ne_old, ne_new);
+    if (ne_ref_rp_count > 0)
+      OLSR_PRINTF(2,
+                 "Performed %d neighbortable-pointer replacements (%p -> %p) in link_set.\n",
+                 ne_ref_rp_count, ne_old, ne_new);
+
+    me_old = mid_lookup_entry_bymain(alias);
+    if (me_old) {
+
+      /* 
+       * we knew aliases to the previous main address;
+       * better forget about them now.
+       */
+      OLSR_PRINTF(2, "I already have an mid entry mapping addresses to this "
+                  "alias address. Removing existing mid entry to preserve consistency of mid_set.\n");
+      olsr_delete_mid_entry(me_old);
+    }
   }
-  
+
   insert_mid_tuple(main_add, adr, vtime);
-  
+
   /*
    *Recalculate topology
    */
   changes_neighborhood = OLSR_TRUE;
   changes_topology = OLSR_TRUE;
-  
-  //print_mid_list();
 }
 
 /**
- *Lookup the main address for a alias address
- *
- *@param adr the alias address to check
+ * Lookup the main address for a alias address
  *
- *@return the main address registered on the alias
- *or NULL if not found
+ * @param adr the alias address to check
+ * @return the main address registered on the alias
+ * or NULL if not found
  */
 union olsr_ip_addr *
 mid_lookup_main_addr(const union olsr_ip_addr *adr)
@@ -325,21 +327,21 @@ mid_lookup_main_addr(const union olsr_ip_addr *adr)
   struct mid_address *tmp_list;
 
   hash = olsr_ip_hashing(adr);
-  /*Traverse MID list*/
-  for(tmp_list = reverse_mid_set[hash].next; 
-      tmp_list != &reverse_mid_set[hash];
-      tmp_list = tmp_list->next)
-       {
-         if(ipequal(&tmp_list->alias, adr))
-           return &tmp_list->main_entry->main_addr;
-       }
+
+  /*Traverse MID list */
+  for (tmp_list = reverse_mid_set[hash].next;
+       tmp_list != &reverse_mid_set[hash]; tmp_list = tmp_list->next) {
+    if (ipequal(&tmp_list->alias, adr))
+      return &tmp_list->main_entry->main_addr;
+  }
   return NULL;
 
 }
 
-/* Find mid entry to an address.
- * @param adr the main address to search for
+/*
+ * Find mid entry to an address.
  *
+ * @param adr the main address to search for
  * @return a linked list of address structs
  */
 struct mid_entry *
@@ -348,27 +350,22 @@ mid_lookup_entry_bymain(const union olsr_ip_addr *adr)
   struct mid_entry *tmp_list;
   olsr_u32_t hash;
 
-  //OLSR_PRINTF(1, "MID: lookup entry...");
-
   hash = olsr_ip_hashing(adr);
 
-  /* Check all registered nodes...*/
-  for(tmp_list = mid_set[hash].next;
-      tmp_list != &mid_set[hash];
-      tmp_list = tmp_list->next)
-    {
-      if(ipequal(&tmp_list->main_addr, adr))
-       return tmp_list;
-    }
+  /* Check all registered nodes... */
+  for (tmp_list = mid_set[hash].next;
+       tmp_list != &mid_set[hash]; tmp_list = tmp_list->next) {
+    if (ipequal(&tmp_list->main_addr, adr))
+      return tmp_list;
+  }
   return NULL;
 }
 
 /*
- *Find all aliases for an address.
- *
- *@param adr the main address to search for
+ * Find all aliases for an address.
  *
- *@return a linked list of addresses structs
+ * @param adr the main address to search for
+ * @return a linked list of addresses structs
  */
 struct mid_address *
 mid_lookup_aliases(const union olsr_ip_addr *adr)
@@ -379,14 +376,13 @@ mid_lookup_aliases(const union olsr_ip_addr *adr)
 
 
 /**
- *Update the timer for an entry
+ * Update the timer for an MID entry
  *
- *@param adr the main address of the entry
- *
- *@return 1 if the node was updated, 0 if not
+ * @param adr the main address of the entry
+ * @return 1 if the node was updated, 0 if not
  */
 int
-olsr_update_mid_table(const union olsr_ip_addr *adr, float vtime)
+olsr_update_mid_table(const union olsr_ip_addr *adr, olsr_reltime vtime)
 {
   olsr_u32_t hash;
 #ifndef NODEBUG
@@ -397,34 +393,30 @@ olsr_update_mid_table(const union olsr_ip_addr *adr, float vtime)
   OLSR_PRINTF(3, "MID: update %s\n", olsr_ip_to_string(&buf, adr));
   hash = olsr_ip_hashing(adr);
 
-  /* Check all registered nodes...*/
-  for(tmp_list = mid_set[hash].next;
-      tmp_list != &mid_set[hash];
-      tmp_list = tmp_list->next)
-    {
-      /*find match*/
-      if(ipequal(&tmp_list->main_addr, adr))
-       {
-         // printf("MID: Updating timer for node %s\n", olsr_ip_to_string(&buf, &tmp_list->main_addr));
-          olsr_set_mid_timer(tmp_list, vtime * MSEC_PER_SEC);
-
-         return 1;
-       }
+  /* Check all registered nodes... */
+  for (tmp_list = mid_set[hash].next;
+       tmp_list != &mid_set[hash]; tmp_list = tmp_list->next) {
+    /*find match */
+    if (ipequal(&tmp_list->main_addr, adr)) {
+      olsr_set_mid_timer(tmp_list, vtime);
+
+      return 1;
     }
+  }
   return 0;
 }
 
 
 /**
- *Remove aliases from 'entry' which are not listed in 'declared_aliases'.
- *
- *@param entry the MID entry
- *@param declared_aliases the list of declared aliases for the MID entry
+ * Remove aliases from 'entry' which are not listed in 'declared_aliases'.
  *
- *@return nada
+ * @param entry the MID entry
+ * @param declared_aliases the list of declared aliases for the MID entry
+ * @return nada
  */
 void
-olsr_prune_aliases(const union olsr_ip_addr *m_addr, struct mid_alias *declared_aliases)
+olsr_prune_aliases(const union olsr_ip_addr *m_addr,
+                  struct mid_alias *declared_aliases)
 {
   struct mid_entry *entry;
   olsr_u32_t hash;
@@ -435,109 +427,95 @@ olsr_prune_aliases(const union olsr_ip_addr *m_addr, struct mid_alias *declared_
   hash = olsr_ip_hashing(m_addr);
 
   /* Check for registered entry */
-  for(entry = mid_set[hash].next;
-      entry != &mid_set[hash];
-      entry = entry->next)
-    {
-      if(ipequal(&entry->main_addr, m_addr))
-       break;
-    }
-  if(entry == &mid_set[hash])
-    {
-      /* MID entry not found, nothing to prune here */
-      return;
-    }
+  for (entry = mid_set[hash].next; entry != &mid_set[hash]; entry = entry->next) {
+    if (ipequal(&entry->main_addr, m_addr))
+      break;
+  }
+  if (entry == &mid_set[hash]) {
+    /* MID entry not found, nothing to prune here */
+    return;
+  }
 
   registered_aliases = entry->aliases;
   previous_alias = NULL;
 
-  while(registered_aliases != NULL)
-    {
-      struct mid_address *current_alias = registered_aliases;
-      registered_aliases = registered_aliases->next_alias;
+  while (registered_aliases != NULL) {
+    struct mid_address *current_alias = registered_aliases;
+    registered_aliases = registered_aliases->next_alias;
 
-      declared_aliases = save_declared_aliases;
+    declared_aliases = save_declared_aliases;
 
-      /* Go through the list of declared aliases to find the matching current alias */
-      while(declared_aliases != 0 &&
-            ! ipequal(&current_alias->alias, &declared_aliases->alias_addr))
-        {
-          declared_aliases = declared_aliases->next;
-        }
+    /* Go through the list of declared aliases to find the matching current alias */
+    while (declared_aliases != 0 &&
+          !ipequal(&current_alias->alias, &declared_aliases->alias_addr)) {
+      declared_aliases = declared_aliases->next;
+    }
 
-      if (declared_aliases == NULL)
-        {
+    if (declared_aliases == NULL) {
 #ifndef NODEBUG
-          struct ipaddr_str buf;
+      struct ipaddr_str buf;
 #endif
-          /* Current alias not found in list of declared aliases: free current alias */
-          OLSR_PRINTF(1, "MID remove: (%s, ", olsr_ip_to_string(&buf, &entry->main_addr));
-            OLSR_PRINTF(1, "%s)\n", olsr_ip_to_string(&buf, &current_alias->alias));
-
-          /* Update linked list as seen by 'entry' */
-          if (previous_alias != NULL)
-            {
-              previous_alias->next_alias = current_alias->next_alias;
-            }
-          else
-            {
-              entry->aliases = current_alias->next_alias;
-            }
-
-          /* Remove from hash table */
-          DEQUEUE_ELEM(current_alias);
-
-          /*
-           * Delete the rt_path for the alias.
-           */
-          olsr_delete_routing_table(&current_alias->alias, olsr_cnf->maxplen,
-                                    &entry->main_addr);
-          free(current_alias);
-
-          /*
-           *Recalculate topology
-           */
-          changes_neighborhood = OLSR_TRUE;
-          changes_topology = OLSR_TRUE;
-        }
-      else
-        {
-          previous_alias = current_alias;
-        }
+      /* Current alias not found in list of declared aliases: free current alias */
+      OLSR_PRINTF(1, "MID remove: (%s, ",
+                 olsr_ip_to_string(&buf, &entry->main_addr));
+      OLSR_PRINTF(1, "%s)\n", olsr_ip_to_string(&buf, &current_alias->alias));
+
+      /* Update linked list as seen by 'entry' */
+      if (previous_alias != NULL) {
+       previous_alias->next_alias = current_alias->next_alias;
+      } else {
+       entry->aliases = current_alias->next_alias;
+      }
+
+      /* Remove from hash table */
+      DEQUEUE_ELEM(current_alias);
+
+      /*
+       * Delete the rt_path for the alias.
+       */
+      olsr_delete_routing_table(&current_alias->alias, olsr_cnf->maxplen,
+                               &entry->main_addr);
+
+      free(current_alias);
+
+      /*
+       *Recalculate topology
+       */
+      changes_neighborhood = OLSR_TRUE;
+      changes_topology = OLSR_TRUE;
+    } else {
+      previous_alias = current_alias;
     }
+  }
 }
 
 
-/*
- *Delete an entry
- *
- *@param entry the entry to delete
+/**
+ * Delete a MID entry
  *
- *@return 1
+ * @param entry the entry to delete
  */
-int
-mid_delete_node(struct mid_entry *mid)
+void
+olsr_delete_mid_entry(struct mid_entry *mid)
 {
   struct mid_address *aliases;
 
   /* Free aliases */
   aliases = mid->aliases;
-  while(aliases)
-    {
-      struct mid_address *tmp_aliases = aliases;
-      aliases = aliases->next_alias;
-      DEQUEUE_ELEM(tmp_aliases);
+  while (aliases) {
+    struct mid_address *tmp_aliases = aliases;
+    aliases = aliases->next_alias;
+    DEQUEUE_ELEM(tmp_aliases);
 
 
-      /*
-       * Delete the rt_path for the alias.
-       */
-      olsr_delete_routing_table(&tmp_aliases->alias, olsr_cnf->maxplen,
-                                &mid->main_addr);
+    /*
+     * Delete the rt_path for the alias.
+     */
+    olsr_delete_routing_table(&tmp_aliases->alias, olsr_cnf->maxplen,
+                             &mid->main_addr);
 
-      free(tmp_aliases);
-    }
+    free(tmp_aliases);
+  }
 
   /*
    * Kill any pending timers.
@@ -550,42 +528,39 @@ mid_delete_node(struct mid_entry *mid)
   /* Dequeue */
   DEQUEUE_ELEM(mid);
   free(mid);
-  
-  return 0;
 }
 
 
 /**
- *Print all multiple interface info
- *For debuging purposes
+ * Print all MID entries
+ * For debuging purposes
  */
 void
 olsr_print_mid_set(void)
 {
   int idx;
 
-  OLSR_PRINTF(1, "\n--- %s ------------------------------------------------- MID\n\n",
-              olsr_wallclock_string());
+  OLSR_PRINTF(1,
+             "\n--- %s ------------------------------------------------- MID\n\n",
+             olsr_wallclock_string());
 
-  for(idx=0;idx<HASHSIZE;idx++)
-    {
-      struct mid_entry *tmp_list = mid_set[idx].next;
-      /*Traverse MID list*/
-      for(tmp_list = mid_set[idx].next; tmp_list != &mid_set[idx]; tmp_list = tmp_list->next)
-       {
-         struct mid_address *tmp_addr;
+  for (idx = 0; idx < HASHSIZE; idx++) {
+    struct mid_entry *tmp_list = mid_set[idx].next;
+    /*Traverse MID list */
+    for (tmp_list = mid_set[idx].next; tmp_list != &mid_set[idx];
+        tmp_list = tmp_list->next) {
+      struct mid_address *tmp_addr;
 #ifndef NODEBUG
-          struct ipaddr_str buf;
-#endif          
-         OLSR_PRINTF(1, "%s: ", olsr_ip_to_string(&buf, &tmp_list->main_addr));
-          for(tmp_addr = tmp_list->aliases;tmp_addr;tmp_addr = tmp_addr->next_alias)
-           {
-             OLSR_PRINTF(1, " %s ", olsr_ip_to_string(&buf, &tmp_addr->alias));
-           }
-         OLSR_PRINTF(1, "\n");
-       }
+      struct ipaddr_str buf;
+#endif
+      OLSR_PRINTF(1, "%s: ", olsr_ip_to_string(&buf, &tmp_list->main_addr));
+      for (tmp_addr = tmp_list->aliases; tmp_addr;
+          tmp_addr = tmp_addr->next_alias) {
+       OLSR_PRINTF(1, " %s ", olsr_ip_to_string(&buf, &tmp_addr->alias));
+      }
+      OLSR_PRINTF(1, "\n");
     }
-
+  }
 }
 
 /*
index 2b778b7..debacd9 100644 (file)
@@ -1,6 +1,7 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
  *
  */
 
-
 #ifndef _OLSR_MID
 #define _OLSR_MID
 
 #include "olsr_types.h"
 #include "hashing.h"
+#include "mantissa.h"
 
-
-struct mid_address
-{
-  union olsr_ip_addr  alias;
-  struct mid_entry   *main_entry;
+struct mid_address {
+  union olsr_ip_addr alias;
+  struct mid_entry *main_entry;
   struct mid_address *next_alias;
 
   /* These are for the reverse list */
@@ -58,56 +57,33 @@ struct mid_address
 };
 
 /*
- *Contains the main addr of a node and a list of aliases
+ * Contains the main addr of a node and a list of aliases
  */
-struct mid_entry
-{
-  union olsr_ip_addr  main_addr;
+struct mid_entry {
+  union olsr_ip_addr main_addr;
   struct mid_address *aliases;
-  struct mid_entry   *prev;
-  struct mid_entry   *next;
-  struct timer_entry  *mid_timer;
+  struct mid_entry *prev;
+  struct mid_entry *next;
+  struct timer_entry *mid_timer;
 };
 
-#define OLSR_MID_JITTER 5 /* percent */
+#define OLSR_MID_JITTER 5      /* percent */
 
 extern struct mid_entry mid_set[HASHSIZE];
 extern struct mid_address reverse_mid_set[HASHSIZE];
 
 struct mid_alias;
 
-int
-olsr_init_mid_set(void);
-
-void 
-insert_mid_tuple(union olsr_ip_addr *, struct mid_address *, float);
-
-void
-insert_mid_alias(union olsr_ip_addr *, const union olsr_ip_addr *, float);
-
-union olsr_ip_addr *
-mid_lookup_main_addr(const union olsr_ip_addr *);
-
-struct mid_address *
-mid_lookup_aliases(const union olsr_ip_addr *);
-
-struct mid_entry *
-mid_lookup_entry_bymain(const union olsr_ip_addr *);
-
-void
-olsr_print_mid_set(void);
-
-void
-olsr_time_out_mid_set(void *);
-
-void
-olsr_prune_aliases(const union olsr_ip_addr *m_addr, struct mid_alias *declared_aliases);
-
-int
-olsr_update_mid_table(const union olsr_ip_addr *, float);
-
-int
-mid_delete_node(struct mid_entry *);
+int olsr_init_mid_set(void);
+void insert_mid_tuple(union olsr_ip_addr *, struct mid_address *, olsr_reltime);
+void insert_mid_alias(union olsr_ip_addr *, const union olsr_ip_addr *, olsr_reltime);
+union olsr_ip_addr *mid_lookup_main_addr(const union olsr_ip_addr *);
+struct mid_address *mid_lookup_aliases(const union olsr_ip_addr *);
+struct mid_entry *mid_lookup_entry_bymain(const union olsr_ip_addr *);
+void olsr_print_mid_set(void);
+void olsr_prune_aliases(const union olsr_ip_addr *, struct mid_alias *);
+int olsr_update_mid_table(const union olsr_ip_addr *, olsr_reltime);
+void olsr_delete_mid_entry(struct mid_entry *);
 
 #endif
 
index f62c0ee..028608d 100644 (file)
@@ -127,7 +127,7 @@ olsr_expire_mpr_sel_entry(void *context)
  * The timer param is a relative timer expressed in milliseconds.
  */
 static void
-olsr_set_mpr_sel_timer(struct mpr_selector *mpr_sel, unsigned int rel_timer)
+olsr_set_mpr_sel_timer(struct mpr_selector *mpr_sel, olsr_reltime rel_timer)
 {
 
   olsr_set_timer(&mpr_sel->MS_timer, rel_timer, OLSR_MPR_SEL_JITTER,
@@ -144,7 +144,7 @@ olsr_set_mpr_sel_timer(struct mpr_selector *mpr_sel, unsigned int rel_timer)
  *@return a pointer to the new entry
  */
 struct mpr_selector *
-olsr_add_mpr_selector(const union olsr_ip_addr *addr, float vtime)
+olsr_add_mpr_selector(const union olsr_ip_addr *addr, olsr_reltime vtime)
 {
 #ifndef NODEBUG
   struct ipaddr_str buf;
@@ -154,11 +154,9 @@ olsr_add_mpr_selector(const union olsr_ip_addr *addr, float vtime)
   OLSR_PRINTF(1, "MPRS: adding %s\n", olsr_ip_to_string(&buf, addr));
 
   new_entry = olsr_malloc(sizeof(struct mpr_selector), "Add MPR selector");
-
   /* Fill struct */
   new_entry->MS_main_addr = *addr;
-  olsr_set_mpr_sel_timer(new_entry, vtime * MSEC_PER_SEC);
-
+  olsr_set_mpr_sel_timer(new_entry, vtime);
   /* Queue */
   QUEUE_ELEM(mprs_list, new_entry);
   /*
@@ -210,7 +208,7 @@ olsr_lookup_mprs_set(const union olsr_ip_addr *addr)
  *@return 1 if a new entry was added 0 if not
  */
 int
-olsr_update_mprs_set(const union olsr_ip_addr *addr, float vtime)
+olsr_update_mprs_set(const union olsr_ip_addr *addr, olsr_reltime vtime)
 {
 #ifndef NODEBUG
   struct ipaddr_str buf;
@@ -224,7 +222,7 @@ olsr_update_mprs_set(const union olsr_ip_addr *addr, float vtime)
     signal_link_changes(OLSR_TRUE);
     return 1;
   }
-  olsr_set_mpr_sel_timer(mprs, vtime * MSEC_PER_SEC);
+  olsr_set_mpr_sel_timer(mprs, vtime);
   return 0;
 }
 
index e00ccdc..4de554f 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
@@ -42,6 +42,7 @@
 #ifndef _OLSR_MPRS_SET
 #define _OLSR_MPRS_SET
 
+#include "mantissa.h"
 
 struct mpr_selector
 {
@@ -69,7 +70,7 @@ olsr_init_mprs_set(void);
 
 
 struct mpr_selector *
-olsr_add_mpr_selector(const union olsr_ip_addr *, float);
+olsr_add_mpr_selector(const union olsr_ip_addr *, olsr_reltime);
 
 
 struct mpr_selector *
@@ -77,7 +78,7 @@ olsr_lookup_mprs_set(const union olsr_ip_addr *);
 
 
 int
-olsr_update_mprs_set(const union olsr_ip_addr *, float);
+olsr_update_mprs_set(const union olsr_ip_addr *, olsr_reltime);
 
 
 void
index 5407958..aae15f7 100644 (file)
@@ -52,7 +52,7 @@
 #include "mid_set.h"
 #include "mpr.h"
 #include "lq_mpr.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "scheduler.h"
 #include "apm.h"
 #include "misc.h"
@@ -61,6 +61,7 @@
 #include "lq_packet.h"
 #include "common/avl.h"
 #include "net_olsr.h"
+#include "lq_plugin.h"
 
 #include <stdarg.h>
 #include <signal.h>
@@ -169,7 +170,7 @@ olsr_process_changes(void)
 
   /* calculate the routing table */
   if (changes_neighborhood || changes_topology || changes_hna) {
-    olsr_calculate_routing_table(NULL);
+    olsr_calculate_routing_table();
   }
   
   if (olsr_cnf->debug_level > 0)
@@ -211,9 +212,19 @@ olsr_process_changes(void)
   changes_force = OLSR_FALSE;
 }
 
+/*
+ * Callback for the periodic route calculation.
+ */
+void
+olsr_trigger_forced_update(void *unused __attribute__((unused))) {
 
-
-
+  changes_force = OLSR_TRUE;
+  changes_neighborhood = OLSR_TRUE;
+  changes_topology = OLSR_TRUE;
+  changes_hna = OLSR_TRUE;
+  
+  olsr_process_changes();
+}
 
 /**
  *Initialize all the tables used(neighbor,
@@ -229,13 +240,16 @@ olsr_init_tables(void)
 
   /* Set avl tree comparator */
   if (olsr_cnf->ipsize == 4) {
-    avl_comp_default = NULL;
+    avl_comp_default = avl_comp_ipv4;
     avl_comp_prefix_default = avl_comp_ipv4_prefix;
   } else {
     avl_comp_default = avl_comp_ipv6;
     avl_comp_prefix_default = avl_comp_ipv6_prefix;
   }
 
+  /* Initialize lq plugin set */
+  init_lq_handler_tree();
+  
   /* Initialize link set */
   olsr_init_link_set();
 
@@ -263,10 +277,15 @@ olsr_init_tables(void)
   /* Initialize HNA set */
   olsr_init_hna_set();  
 
+#if 0
+  /* Initialize Layer 1/2 database */
+  olsr_initialize_layer12();
+#endif
+  
   /* Start periodic SPF and RIB recalculation */
   if (olsr_cnf->lq_dinter > 0.0) {
     olsr_start_timer((unsigned int)(olsr_cnf->lq_dinter * MSEC_PER_SEC), 5,
-                     OLSR_TIMER_PERIODIC, &olsr_calculate_routing_table, NULL, 0);
+                     OLSR_TIMER_PERIODIC, &olsr_trigger_forced_update, NULL, 0);
   }
 }
 
index 46856d9..6f9b168 100644 (file)
@@ -99,4 +99,7 @@ olsr_malloc(size_t, const char *);
 int
 olsr_printf(int, const char *, ...) __attribute__((format(printf,2,3)));
 
+void
+olsr_trigger_forced_update(void *);
+
 #endif
index 54036b8..5003d5c 100644 (file)
@@ -67,7 +67,7 @@
 #define DEF_LQ_DIJK_LIMIT   255
 #define DEF_LQ_DIJK_INTER   0.0
 #define DEF_LQ_NAT_THRESH   1.0
-#define DEF_LQ_WSIZE        12
+#define DEF_LQ_AGING        0.1
 #define DEF_CLEAR_SCREEN    OLSR_FALSE
 
 /* Bounds */
@@ -92,8 +92,8 @@
 #define MIN_HYST_PARAM      0.0
 #define MAX_LQ_LEVEL        2
 #define MIN_LQ_LEVEL        0
-#define MAX_LQ_WSIZE        128
-#define MIN_LQ_WSIZE        3
+#define MAX_LQ_AGING        1.0
+#define MIN_LQ_AGING        0.01
 
 /* Option values */
 #define CFG_FIBM_FLAT          "flat"
@@ -115,7 +115,7 @@ struct olsr_msg_params
 struct olsr_lq_mult
 {
   union olsr_ip_addr addr;
-  float val;
+  olsr_u32_t value;
   struct olsr_lq_mult *next;
 };
 
@@ -220,7 +220,8 @@ struct olsrd_config
   olsr_u8_t                lq_level;
   olsr_u8_t                lq_fish;
   float                    lq_dinter;
-  olsr_u32_t               lq_wsize;
+  float                    lq_aging;
+  char                     *lq_algorithm;
   olsr_u8_t                lq_dlimit;
 
   /* Stuff set by olsrd */
index 848a7bb..628f54f 100644 (file)
@@ -88,6 +88,11 @@ olsr_alloc_cookie(const char *cookie_name, olsr_cookie_type cookie_type)
     ci->ci_name = strdup(cookie_name);
   }
 
+  /* Init the free list */
+  if (cookie_type == OLSR_COOKIE_TYPE_MEMORY) {
+    list_head_init(&ci->ci_free_list);
+  }
+
   return ci;
 }
 
@@ -97,6 +102,7 @@ olsr_alloc_cookie(const char *cookie_name, olsr_cookie_type cookie_type)
 void
 olsr_free_cookie(struct olsr_cookie_info *ci)
 {
+  struct list_node *memory_list;
 
   /* Mark the cookie as unused */
   cookies[ci->ci_id] = NULL;
@@ -105,9 +111,38 @@ olsr_free_cookie(struct olsr_cookie_info *ci)
   if (ci->ci_name) {
     free(ci->ci_name);
   }
+
+  /* Flush all the memory on the free list */
+  if (ci->ci_type == OLSR_COOKIE_TYPE_MEMORY) {
+    while (!list_is_empty(&ci->ci_free_list)) {
+      memory_list = ci->ci_free_list.next;
+      list_remove(memory_list);
+      free(memory_list);
+    }
+  }
+
   free(ci);
 }
 
+/*
+ * Flush all cookies. This is really only called upon shutdown.
+ */
+void
+olsr_delete_all_cookies(void)
+{
+  int ci_index;
+
+  /*
+   * Walk the full index range and kill 'em all.
+   */
+  for (ci_index = 1; ci_index < COOKIE_ID_MAX; ci_index++) {
+    if (!cookies[ci_index]) {
+      continue;
+    }
+    olsr_free_cookie(cookies[ci_index]);
+  }
+}
+
 /*
  * Set the size for fixed block allocations.
  * This is only allowed for memory cookies.
@@ -183,18 +218,37 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
 {
   void *ptr;
   struct olsr_cookie_mem_brand *branding;
+  struct list_node *free_list_node;
+  olsr_bool reuse = OLSR_FALSE;
 
   /*
-   * Not all the callers do a proper cleaning of memory.
-   * Clean it on behalf of those.
+   * Check first if we have reusable memory.
    */
-  ptr = calloc(1, ci->ci_size + sizeof(struct olsr_cookie_mem_brand));
-
-  if (!ptr) {
-    const char *const err_msg = strerror(errno);
-    OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", err_msg);
-    olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %s\n", err_msg);
-    olsr_exit(ci->ci_name, EXIT_FAILURE);
+  if (!ci->ci_free_list_usage) {
+
+    /*
+     * No reusable memory block on the free_list.
+     */
+    ptr = calloc(1, ci->ci_size + sizeof(struct olsr_cookie_mem_brand));
+
+    if (!ptr) {
+      const char *const err_msg = strerror(errno);
+      OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", err_msg);
+      olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %s\n", err_msg);
+      olsr_exit(ci->ci_name, EXIT_FAILURE);
+    }
+  } else {
+
+    /*
+     * There is a memory block on the free list.
+     * Carve it out of the list, and clean.
+     */
+    free_list_node = ci->ci_free_list.next;
+    list_remove(free_list_node);
+    ptr = (void *)free_list_node;
+    memset(ptr, 0, ci->ci_size);
+    ci->ci_free_list_usage--;
+    reuse = OLSR_TRUE;
   }
 
   /*
@@ -210,9 +264,9 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
   /* Stats keeping */
   olsr_cookie_usage_incr(ci->ci_id);
 
-#if 1
-  olsr_printf(1, "MEMORY: alloc %s, %p, %u bytes\n",
-             ci->ci_name, ptr, ci->ci_size);
+#if 0
+  OLSR_PRINTF(1, "MEMORY: alloc %s, %p, %u bytes%s\n",
+             ci->ci_name, ptr, ci->ci_size, reuse ? ", reuse" : "");
 #endif
 
   return ptr;
@@ -226,6 +280,8 @@ void
 olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
 {
   struct olsr_cookie_mem_brand *branding;
+  struct list_node *free_list_node;
+  olsr_bool reuse = OLSR_FALSE;
 
   branding = (struct olsr_cookie_mem_brand *)
     ((unsigned char *)ptr + ci->ci_size);
@@ -240,15 +296,36 @@ olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
   /* Kill the brand */
   memset(branding, 0, sizeof(*branding));
 
+  /*
+   * Rather than freeing the memory right away, try to reuse at a later
+   * point. Keep at least ten percent of the active used blocks or at least
+   * ten blocks on the free list.
+   */
+  if ((ci->ci_free_list_usage < COOKIE_FREE_LIST_THRESHOLD) ||
+      (ci->ci_free_list_usage < ci->ci_usage / COOKIE_FREE_LIST_THRESHOLD)) {
+
+    free_list_node = (struct list_node *)ptr;
+    list_node_init(free_list_node);
+    list_add_before(&ci->ci_free_list, free_list_node);
+    ci->ci_free_list_usage++;
+    reuse = OLSR_TRUE;
+
+  } else {
+
+    /*
+     * No interest in reusing memory.
+     */
+    free(ptr);
+  }
+
   /* Stats keeping */
   olsr_cookie_usage_decr(ci->ci_id);
 
-#if 1
-  olsr_printf(1, "MEMORY: free %s, %p, %u bytes\n",
-             ci->ci_name, ptr, ci->ci_size);
+#if 0
+  OLSR_PRINTF(1, "MEMORY: free %s, %p, %u bytes%s\n",
+             ci->ci_name, ptr, ci->ci_size, reuse ? ", reuse" : "");
 #endif
 
-  free(ptr);
 }
 
 /*
index 06014fc..24a38d1 100644 (file)
@@ -39,6 +39,7 @@
  */
 
 #include "olsr_types.h"
+#include "common/list.h"
 
 #ifndef _OLSR_COOKIE_H
 #define _OLSR_COOKIE_H
@@ -63,9 +64,13 @@ struct olsr_cookie_info {
   olsr_cookie_type ci_type;           /* Type of cookie */
   size_t ci_size;                     /* Fixed size for block allocations */
   unsigned int ci_usage;              /* Stats, resource usage */
-  unsigned int ci_changes;             /* Stats, resource churn */
+  unsigned int ci_changes;            /* Stats, resource churn */
+  struct list_node ci_free_list;       /* List head for recyclable blocks */
+  unsigned int ci_free_list_usage;     /* Length of free list */
 };
 
+#define COOKIE_FREE_LIST_THRESHOLD 10  /* Blocks / Percent  */
+
 /*
  * Small brand which gets appended on the end of every block allocation.
  * Helps to detect memory corruption, like overruns, double frees.
@@ -79,6 +84,7 @@ struct olsr_cookie_mem_brand {
 extern struct olsr_cookie_info *olsr_alloc_cookie(const char *,
                                                  olsr_cookie_type);
 extern void olsr_free_cookie(struct olsr_cookie_info *);
+extern void olsr_delete_all_cookies(void);
 extern char *olsr_cookie_name(olsr_cookie_t);
 extern void olsr_cookie_set_memory_size(struct olsr_cookie_info *, size_t);
 extern void olsr_cookie_usage_incr(olsr_cookie_t);
index 9ebcfa1..ed3ae04 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
+ * Copyright (c) 2004, Andreas Tnnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
 #define MID_HOLD_TIME         3 * MID_INTERVAL
 #define HNA_HOLD_TIME         3 * HNA_INTERVAL
 
-/*
- * Scaling factor
- */
-
-#define VTIME_SCALE_FACTOR    0.0625
-
 /*
  *Message Types
  */
similarity index 99%
rename from src/lq_route.c
rename to src/olsr_spf.c
index 9795815..1418ea4 100644 (file)
@@ -62,7 +62,7 @@
 #include "hna_set.h"
 #include "common/list.h"
 #include "common/avl.h"
-#include "lq_route.h"
+ #include "olsr_spf.h"
 #include "net_olsr.h"
 #include "lq_plugin.h"
 
@@ -316,7 +316,7 @@ olsr_expire_spf_backoff(void *context __attribute__((unused)))
 }
 
 void
-olsr_calculate_routing_table (void *context __attribute__((unused)))
+olsr_calculate_routing_table (void)
 {
 #ifdef SPF_PROFILING
   struct timeval t1, t2, t3, t4, t5, spf_init, spf_run, route, kernel, total;
similarity index 95%
rename from src/lq_route.h
rename to src/olsr_spf.h
index 8aaba2d..a496ac6 100644 (file)
@@ -38,9 +38,9 @@
  *
  */
 
-#ifndef _LQ_ROUTE_H
-#define _LQ_ROUTE_H
+#ifndef _OLSR_SPF_H
+#define _OLSR_SPF_H
 
-void olsr_calculate_routing_table(void *);
+void olsr_calculate_routing_table(void);
 
 #endif
index ff9f7d8..24bb1cb 100644 (file)
@@ -220,7 +220,7 @@ olsr_build_hello_packet(struct hello_message *message, struct interface *outif)
       continue;
     }
            
-    message_neighbor = olsr_malloc_hello_neighbor("Build HELLO 2");
+         message_neighbor = olsr_malloc_hello_neighbor("Build HELLO 2");
            
     message_neighbor->link = UNSPEC_LINK;
            
@@ -340,9 +340,9 @@ olsr_build_tc_packet(struct tc_message *message)
     switch (olsr_cnf->tc_redundancy) {
     case(2):
     {
-      /* 2 = Add all neighbors */
-      //printf("\t%s\n", olsr_ip_to_string(&mprs->mpr_selector_addr));
-      message_mpr = olsr_malloc_tc_mpr_addr("Build TC");
+               /* 2 = Add all neighbors */
+               //printf("\t%s\n", olsr_ip_to_string(&mprs->mpr_selector_addr));
+                 message_mpr = olsr_malloc_tc_mpr_addr("Build TC");
                
       message_mpr->address = entry->neighbor_main_addr;
       message_mpr->next = message->multipoint_relay_selector_address;
index 9cce21b..4cd2883 100644 (file)
@@ -43,6 +43,7 @@
 
 #include "olsr_protocol.h"
 #include "interfaces.h"
+#include "mantissa.h"
 
 struct hello_neighbor
 {
@@ -57,8 +58,8 @@ struct hello_neighbor
 
 struct hello_message
 {
-  double                 vtime;
-  double                 htime;
+  olsr_reltime           vtime;
+  olsr_reltime           htime;
   union olsr_ip_addr     source_addr;
   olsr_u16_t             packet_seq_number;
   olsr_u8_t              hop_count;
@@ -77,7 +78,7 @@ struct tc_mpr_addr
 
 struct tc_message
 {
-  double              vtime;
+  olsr_reltime        vtime;
   union olsr_ip_addr  source_addr;
   union olsr_ip_addr  originator;
   olsr_u16_t          packet_seq_number;
@@ -104,7 +105,7 @@ struct mid_alias
 
 struct mid_message
 {
-  double             vtime;
+  olsr_reltime       vtime;
   union olsr_ip_addr mid_origaddr;  /* originator's address */
   olsr_u8_t          mid_hopcnt;    /* number of hops to destination */
   olsr_u8_t          mid_ttl;       /* ttl */
@@ -116,7 +117,7 @@ struct mid_message
 
 struct unknown_message
 {
-  olsr_u16_t          seqno;
+  olsr_u16_t         seqno;
   union olsr_ip_addr originator;
   olsr_u8_t          type;
 };
index ce80eca..0f1aa40 100644 (file)
@@ -110,10 +110,10 @@ print_olsr_serialized_message(FILE *handle, union olsr_message *msg)
   fprintf(handle, "   ------------ OLSR MESSAGE ------------\n");
   fprintf(handle, "    Sender main addr: %s\n", 
          olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->v4.originator));
-  fprintf(handle, "    Type: %s, size: %d, vtime: %0.2f\n", 
+  fprintf(handle, "    Type: %s, size: %d, vtime: %u ms\n", 
          olsr_msgtype_to_string(msg->v4.olsr_msgtype), 
          ntohs(msg->v4.olsr_msgsize),
-         me_to_double(msg->v4.olsr_vtime));
+         me_to_reltime(msg->v4.olsr_vtime));
   fprintf(handle, "    TTL: %d, Hopcnt: %d, seqno: %d\n",
          (olsr_cnf->ip_version == AF_INET) ? msg->v4.ttl : msg->v6.ttl,
          (olsr_cnf->ip_version == AF_INET) ? msg->v4.hopcnt : msg->v6.hopcnt,
@@ -196,7 +196,7 @@ print_hellomsg(FILE *handle, olsr_u8_t *data, olsr_16_t totsize)
   union olsr_ip_addr *haddr;
   int hellosize = totsize - ((olsr_cnf->ip_version == AF_INET) ? OLSR_MSGHDRSZ_IPV4 : OLSR_MSGHDRSZ_IPV6);
 
-  fprintf(handle, "    +Htime: %0.2f\n", me_to_double(data[2]));
+  fprintf(handle, "    +Htime: %u ms\n", me_to_reltime(data[2]));
 
   fprintf(handle, "    +Willingness: %d\n", data[3]);
 
@@ -264,7 +264,7 @@ print_hellomsg_lq(FILE *handle, olsr_u8_t *data, olsr_16_t totsize)
   union olsr_ip_addr *haddr;
   int hellosize = totsize - ((olsr_cnf->ip_version == AF_INET) ? OLSR_MSGHDRSZ_IPV4 : OLSR_MSGHDRSZ_IPV6);
 
-  fprintf(handle, "    +Htime: %0.2f\n", me_to_double(data[2]));
+  fprintf(handle, "    +Htime: %u ms\n", me_to_reltime(data[2]));
 
   fprintf(handle, "    +Willingness: %d\n", data[3]);
 
index 1e0a2cf..6a664fe 100644 (file)
@@ -61,7 +61,7 @@ static void process_message_neighbors(struct neighbor_entry *,
                                       const struct hello_message *);
 
 static void linking_this_2_entries(struct neighbor_entry *,
-                                   struct neighbor_2_entry *, float);
+                                   struct neighbor_2_entry *, olsr_reltime);
 
 static olsr_bool lookup_mpr_status(const struct hello_message *,
                                    const struct interface *);
@@ -116,7 +116,7 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
             {
               /* Updating the holding time for this neighbor */
               olsr_set_timer(&two_hop_neighbor_yet->nbr2_list_timer,
-                             message->vtime * MSEC_PER_SEC, OLSR_NBR2_LIST_JITTER,
+                             message->vtime, OLSR_NBR2_LIST_JITTER,
                              OLSR_TIMER_ONESHOT, &olsr_expire_nbr2_list,
                              two_hop_neighbor_yet, 0);
               two_hop_neighbor = two_hop_neighbor_yet->neighbor_2;
@@ -293,7 +293,7 @@ process_message_neighbors(struct neighbor_entry *neighbor, const struct hello_me
  *@return nada
  */
 static void
-linking_this_2_entries(struct neighbor_entry *neighbor, struct neighbor_2_entry *two_hop_neighbor, float vtime)
+linking_this_2_entries(struct neighbor_entry *neighbor, struct neighbor_2_entry *two_hop_neighbor, olsr_reltime vtime)
 {
   struct neighbor_list_entry    *list_of_1_neighbors = olsr_malloc(sizeof(struct neighbor_list_entry), "Link entries 1");
   struct neighbor_2_list_entry  *list_of_2_neighbors = olsr_malloc(sizeof(struct neighbor_2_list_entry), "Link entries 2");
@@ -313,7 +313,7 @@ linking_this_2_entries(struct neighbor_entry *neighbor, struct neighbor_2_entry
   list_of_2_neighbors->neighbor_2 = two_hop_neighbor;
   list_of_2_neighbors->nbr2_nbr = neighbor; /* XXX refcount */
   
-  olsr_change_timer(list_of_2_neighbors->nbr2_list_timer, vtime * MSEC_PER_SEC,
+  olsr_change_timer(list_of_2_neighbors->nbr2_list_timer, vtime,
                     OLSR_NBR2_LIST_JITTER, OLSR_TIMER_ONESHOT);
 
   /* Queue */
@@ -366,7 +366,7 @@ static int deserialize_hello(struct hello_message *hello, const void *ser) {
                /* No need to do anything more */
                return 1;
        }
-       pkt_get_double(&curr, &hello->vtime);
+       pkt_get_reltime(&curr, &hello->vtime);
        pkt_get_u16(&curr, &size);
        pkt_get_ipaddress(&curr, &hello->source_addr);
        
@@ -375,7 +375,7 @@ static int deserialize_hello(struct hello_message *hello, const void *ser) {
        pkt_get_u16(&curr, &hello->packet_seq_number);
        pkt_ignore_u16(&curr);
        
-       pkt_get_double(&curr, &hello->htime);
+       pkt_get_reltime(&curr, &hello->htime);
        pkt_get_u8(&curr, &hello->willingness);
        
        hello->neighbors = NULL;
@@ -564,7 +564,7 @@ olsr_process_received_mid(union olsr_message *m,
     }
 
     /* Update the timeout of the MID */
-    olsr_update_mid_table(&message.mid_origaddr, (float)message.vtime);
+    olsr_update_mid_table(&message.mid_origaddr, message.vtime);
 
     while (tmp_adr) {
       if (!mid_lookup_main_addr(&tmp_adr->alias_addr)){
@@ -573,7 +573,7 @@ olsr_process_received_mid(union olsr_message *m,
 #endif
         OLSR_PRINTF(1, "MID new: (%s, ", olsr_ip_to_string(&buf, &message.mid_origaddr));
         OLSR_PRINTF(1, "%s)\n", olsr_ip_to_string(&buf, &tmp_adr->alias_addr));
-        insert_mid_alias(&message.mid_origaddr, &tmp_adr->alias_addr, (float)message.vtime);
+        insert_mid_alias(&message.mid_origaddr, &tmp_adr->alias_addr, message.vtime);
       }
       tmp_adr = tmp_adr->next;
     } 
@@ -601,7 +601,7 @@ olsr_process_received_hna(union olsr_message *m,
 {
 
   olsr_u8_t          olsr_msgtype;
-  double             vtime;
+  olsr_reltime       vtime;
   olsr_u16_t         olsr_msgsize;
   union olsr_ip_addr originator;
   //olsr_u8_t          ttl; unused
@@ -628,7 +628,7 @@ olsr_process_received_hna(union olsr_message *m,
     return;
   }
   /* Get vtime */
-  pkt_get_double(&curr, &vtime);
+  pkt_get_reltime(&curr, &vtime);
 
   /* olsr_msgsize */
   pkt_get_u16(&curr, &olsr_msgsize);
index e5af19e..4983a7a 100644 (file)
@@ -50,6 +50,7 @@
 #include "common/avl.h"
 #include "net_olsr.h"
 #include "tc_set.h"
+#include "olsr_cookie.h"
 
 #ifdef WIN32
 #undef strerror
@@ -108,13 +109,12 @@ olsr_init_export_route(void)
 }
 
 /**
- *Deletes all OLSR routes
+ * Delete all OLSR routes.
  *
  * This is extremely simple - Just increment the version of the
  * tree and then olsr_update_rib_routes() will see all routes in the tree
  * as outdated and olsr_update_kernel_routes() will finally flush it.
  *
- *@return 1
  */
 void
 olsr_delete_all_kernel_routes(void)
@@ -281,7 +281,7 @@ olsr_del_kernel_routes(struct list_node *head_node)
     olsr_delete_kernel_route(rt);
 
     list_remove(&rt->rt_change_node);
-    free(rt);
+    olsr_cookie_free(rt_mem_cookie, rt);
   }
 }
 
index a3498b3..af159ec 100644 (file)
@@ -87,7 +87,7 @@ mid_chgestruct(struct mid_message *mmsg, const union olsr_message *m)
       mmsg->mid_addr = NULL;
 
       /* Get vtime */
-      mmsg->vtime = me_to_double(m->v4.olsr_vtime);
+      mmsg->vtime = me_to_reltime(m->v4.olsr_vtime);
 
       //printf("Sequencenuber of MID from %s is %d\n", ip_to_string(&mmsg->addr), mmsg->mid_seqno);
 
@@ -138,7 +138,7 @@ mid_chgestruct(struct mid_message *mmsg, const union olsr_message *m)
       mmsg->mid_addr = NULL;
 
       /* Get vtime */
-      mmsg->vtime = me_to_double(m->v6.olsr_vtime);
+      mmsg->vtime = me_to_reltime(m->v6.olsr_vtime);
 
       //printf("Sequencenuber of MID from %s is %d\n", ip_to_string(&mmsg->addr), mmsg->mid_seqno);
 
index 7f0aa23..036a442 100644 (file)
 #include "olsr.h"
 #include "link_set.h"
 #include "common/avl.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "net_olsr.h"
 
 #include <assert.h>
 
+/* Cookies */
+struct olsr_cookie_info *rt_mem_cookie = NULL;
+struct olsr_cookie_info *rtp_mem_cookie = NULL;
+
 /*
  * Sven-Ola: if the current internet gateway is switched, the
  * NAT connection info is lost for any active TCP/UDP session.
@@ -148,9 +152,20 @@ avl_comp_ipv6_prefix (const void *prefix1, const void *prefix2)
 void
 olsr_init_routing_table(void)
 {
+  OLSR_PRINTF(5, "RIB: init routing tree\n");
+
   /* the routing tree */
   avl_init(&routingtree, avl_comp_prefix_default);
   routingtree_version = 0;
+
+  /*
+   * Get some cookies for memory stats and memory recycling.
+   */
+  rt_mem_cookie = olsr_alloc_cookie("rt_entry", OLSR_COOKIE_TYPE_MEMORY);
+  olsr_cookie_set_memory_size(rt_mem_cookie, sizeof(struct rt_entry));
+
+  rtp_mem_cookie = olsr_alloc_cookie("rt_path", OLSR_COOKIE_TYPE_MEMORY);
+  olsr_cookie_set_memory_size(rtp_mem_cookie, sizeof(struct rt_path));
 }
 
 /**
@@ -202,7 +217,7 @@ olsr_update_rt_path(struct rt_path *rtp, struct tc_entry *tc,
 static struct rt_entry *
 olsr_alloc_rt_entry(struct olsr_ip_prefix *prefix)
 {
-  struct rt_entry *rt = olsr_malloc(sizeof(struct rt_entry), __FUNCTION__);
+  struct rt_entry *rt = olsr_cookie_malloc(rt_mem_cookie);
   if (!rt) {
     return NULL;
   }
@@ -231,7 +246,7 @@ static struct rt_path *
 olsr_alloc_rt_path(struct tc_entry *tc,
                    struct olsr_ip_prefix *prefix, olsr_u8_t origin)
 {
-  struct rt_path *rtp = olsr_malloc(sizeof(struct rt_path), __FUNCTION__);
+  struct rt_path *rtp = olsr_cookie_malloc(rtp_mem_cookie);
 
   if (!rtp) {
     return NULL;
@@ -342,7 +357,7 @@ olsr_delete_rt_path(struct rt_path *rtp)
     current_inetgw = NULL;
   }
 
-  free(rtp);
+  olsr_cookie_free(rtp_mem_cookie, rtp);
 }
 
 #if 0
index cb255a4..626a3fd 100644 (file)
@@ -49,6 +49,7 @@
 #include <net/route.h>
 #include "hna_set.h"
 #include "link_set.h"
+#include "olsr_cookie.h"
 #include "common/avl.h"
 #include "common/list.h"
 
@@ -202,6 +203,7 @@ union olsr_kernel_route
 
 extern struct avl_tree routingtree;
 extern unsigned int routingtree_version;
+extern struct olsr_cookie_info *rt_mem_cookie;
 
 void
 olsr_init_routing_table(void);
index 2dff42a..5d83bfd 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
@@ -39,7 +40,6 @@
  *
  */
 
-
 #include "defs.h"
 #include "scheduler.h"
 #include "log.h"
 #include "build_msg.h"
 #include "net_olsr.h"
 #include "socket_parser.h"
-#include "lq_route.h"
+#include "olsr_spf.h"
 #include "link_set.h"
 #include "olsr_cookie.h"
 
 /* Timer data, global. Externed in defs.h */
-clock_t now_times;  /* current idea of times(2) reported uptime */
+clock_t now_times;                    /* current idea of times(2) reported uptime */
 
 /* Hashed root of all timers */
 struct list_node timer_wheel[TIMER_WHEEL_SLOTS];
-clock_t timer_last_run; /* remember the last timeslot walk */
-struct list_node *timer_walk_list_node = NULL; /* used for timeslot walk */
+clock_t timer_last_run;                       /* remember the last timeslot walk */
+struct list_node *timer_walk_list_node = NULL; /* used for timeslot walk */
 
 /* Pool of timers to avoid malloc() churn */
 struct list_node free_timer_list;
@@ -98,10 +98,10 @@ olsr_scheduler_sleep(clock_t scheduler_runtime)
 
   if (timercmp(&time_used, &next_interval, <)) {
     timersub(&next_interval, &time_used, &sleeptime_val);
-         
+
     sleeptime_spec.tv_sec = sleeptime_val.tv_sec;
     sleeptime_spec.tv_nsec = sleeptime_val.tv_usec * NSEC_PER_USEC;
-         
+
     while (nanosleep(&sleeptime_spec, &remainder_spec) < 0)
       sleeptime_spec = remainder_spec;
   }
@@ -119,15 +119,16 @@ olsr_scheduler_sleep(clock_t scheduler_runtime)
 void
 olsr_scheduler(void)
 {
-  struct tms tms_buf;   /* Buffer for times(2) calls. */
+  struct tms tms_buf;                 /* Buffer for times(2) calls. */
   struct interface *ifn;
 
-  OLSR_PRINTF(1, "Scheduler started - polling every %0.2f seconds\n", olsr_cnf->pollrate);
+  OLSR_PRINTF(1, "Scheduler started - polling every %0.2f seconds\n",
+             olsr_cnf->pollrate);
   OLSR_PRINTF(3, "Max jitter is %f\n\n", olsr_cnf->max_jitter);
 
   /* Main scheduler loop */
   for (;;) {
+
     /*
      * Update the global timestamp. We are using a non-wallclock timer here
      * to avoid any undesired side effects if the system clock changes.
@@ -137,10 +138,10 @@ olsr_scheduler(void)
     /* Read incoming data */
     olsr_poll_sockets();
 
-    /* Process timers (before packet generation) */      
+    /* Process timers (before packet generation) */
     olsr_walk_timers(&timer_last_run);
 
-    /* Update */      
+    /* Update */
     olsr_process_changes();
 
     /* Check for changes in topology */
@@ -151,9 +152,9 @@ olsr_scheduler(void)
     }
 
     /* looping trough interfaces and emmitting pending data */
-    for (ifn = ifnet; ifn ; ifn = ifn->int_next) { 
+    for (ifn = ifnet; ifn; ifn = ifn->int_next) {
       if (net_output_pending(ifn) && TIMED_OUT(ifn->fwdtimer)) {
-        net_output(ifn);
+       net_output(ifn);
       }
     }
 
@@ -165,7 +166,7 @@ olsr_scheduler(void)
     if (olsr_win32_end_request) {
       break;
     }
-#endif      
+#endif
   }
 
 #if defined WIN32
@@ -177,7 +178,7 @@ olsr_scheduler(void)
    * and hence also kill us.
    */
   while (1) {
-    Sleep(1000); /* milliseconds */
+    Sleep(1000);               /* milliseconds */
   }
 #endif
 }
@@ -191,10 +192,10 @@ olsr_scheduler(void)
  * @param cached result of random() at system init.
  * @return the absolute timer in system clock tick units
  */
-static clock_t 
+static clock_t
 olsr_jitter(unsigned int rel_time, olsr_u8_t jitter_pct, unsigned int random)
 {
-  unsigned int jitter_time, factorial;
+  unsigned int jitter_time;
 
   /*
    * No jitter or, jitter larger than 99% does not make sense.
@@ -208,12 +209,11 @@ olsr_jitter(unsigned int rel_time, olsr_u8_t jitter_pct, unsigned int random)
    * Play some tricks to avoid overflows with integer arithmetic.
    */
   jitter_time = (jitter_pct * rel_time) / 100;
-  factorial = random / (RAND_MAX / jitter_time);
-  jitter_time = (jitter_time * factorial) / (RAND_MAX / jitter_time);
+  jitter_time = random / (RAND_MAX / jitter_time);
 
 #if 0
-  OLSR_PRINTF(3, "TIMER: jitter %u%% rel_time %u%% to %u\n",
-              rel_time, jitter_pct, rel_time - jitter_time);
+  OLSR_PRINTF(3, "TIMER: jitter %u%% rel_time %ums to %ums\n",
+             jitter_pct, rel_time, rel_time - jitter_time);
 #endif
 
   return GET_TIMESTAMP(rel_time - jitter_time);
@@ -240,7 +240,7 @@ olsr_get_timer(void)
    */
   if (!list_is_empty(&free_timer_list)) {
     timer_list_node = free_timer_list.next;
-    
+
     /* carve it out of the pool, do not memset overwrite timer->timer_random */
     list_remove(timer_list_node);
     timer = list2timer(timer_list_node);
@@ -251,14 +251,14 @@ olsr_get_timer(void)
   /*
    * Nothing in the pool, allocate a new chunk.
    */
-  timer_block = olsr_malloc(sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
-                            "timer chunk");
-  memset(timer_block, 0, sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK); 
+  timer_block =
+    olsr_malloc(sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
+               "timer chunk");
 
 #if 0
   OLSR_PRINTF(3, "TIMER: alloc %u bytes chunk at %p\n",
-              sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
-              timer_block);
+             sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
+             timer_block);
 #endif
 
   /*
@@ -299,7