Refactoring: floating point timer to unsigned integer
authorHenning Rogge <rogge@fgan.de>
Tue, 20 May 2008 08:32:49 +0000 (10:32 +0200)
committerHenning Rogge <rogge@fgan.de>
Tue, 20 May 2008 08:32:49 +0000 (10:32 +0200)
new datatype: olsr_reltime (olsr_u32_t)

30 files changed:
lib/nameservice/src/nameservice.c
lib/nameservice/src/nameservice.h
src/build_msg.c
src/cfgparser/cfgfile_gen.c
src/cfgparser/olsrd_conf.c
src/cfgparser/oparse.y
src/hna_set.c
src/hna_set.h
src/hysteresis.c
src/hysteresis.h
src/interfaces.h
src/link_set.c
src/link_set.h
src/lq_packet.c
src/lq_packet.h
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_cfg.h
src/olsr_protocol.h
src/packet.h
src/print_packet.c
src/process_package.c
src/rebuild_packet.c
src/tc_set.c
src/unix/ifnet.c
src/win32/ifnet.c

index 645dc64..cd5f872 100644 (file)
@@ -588,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;
@@ -603,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;
@@ -641,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;
 
@@ -656,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;
        }
@@ -893,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;
@@ -957,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;
@@ -985,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);
 
@@ -1007,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);
 
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 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 9c0e22e..24e5fb5 100644 (file)
@@ -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;
                }
            }
@@ -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 293d3d0..a4ec8bc 100644 (file)
@@ -631,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 9f99078..03944ae 100644 (file)
@@ -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;
index 86ba3a1..02cfa2a 100644 (file)
@@ -250,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;
@@ -268,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 450298d..776dc77 100644 (file)
@@ -44,6 +44,7 @@
 
 #include "hashing.h"
 #include "olsr_types.h"
+#include "mantissa.h"
 
 #include <time.h>
 
@@ -97,7 +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);
+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 6f1419a..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"
 
@@ -160,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 9cf614c..6aa14d3 100644 (file)
@@ -72,8 +72,8 @@ 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 *);
+                                        const union olsr_ip_addr *, olsr_reltime,
+                                        olsr_reltime, const struct interface *);
 static int get_neighbor_status(const union olsr_ip_addr *);
 
 void
@@ -295,7 +295,7 @@ 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 */
@@ -321,17 +321,17 @@ set_loss_link_multiplier(struct link_entry *entry)
      */
     if ((ipequal(&mult->addr, &null_addr) && val < 0.0) ||
        ipequal(&mult->addr, &entry->neighbor_iface_addr)) {
-      val = mult->val;
+      val = mult->value;
     }
   }
 
   /* if we have not found an entry, then use the default multiplier */
-  if (val < 0) {
-    val = 1.0;
+  if (val == 0) {
+    val = 65536;
   }
 
   /* store the multiplier */
-  entry->loss_link_multiplier = (olsr_u32_t) (val * 65536);
+  entry->loss_link_multiplier = val;
 }
 
 /*
@@ -397,7 +397,7 @@ olsr_expire_link_loss_timer(void *context)
   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_change_timer(link->link_loss_timer, link->loss_helloint,
                    OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC);
 }
 
@@ -442,7 +442,7 @@ olsr_expire_link_hello_timer(void *context)
              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_change_timer(link->link_hello_timer, link->last_htime,
                    OLSR_LINK_JITTER, OLSR_TIMER_PERIODIC);
 
   /* Update hysteresis values */
@@ -496,7 +496,7 @@ 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)
+              olsr_reltime vtime, olsr_reltime htime, const struct interface *local_if)
 {
   struct link_entry *new_link;
   struct neighbor_entry *neighbor;
@@ -548,14 +548,14 @@ add_link_entry(const union olsr_ip_addr *local,
   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);
+    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;
@@ -565,9 +565,9 @@ add_link_entry(const union olsr_ip_addr *local,
   new_link->L_link_quality = 0.0;
 
   if (olsr_cnf->lq_level > 0) {
-    new_link->loss_hello_int = htime;
+    new_link->loss_helloint = htime;
 
-    olsr_set_timer(&new_link->link_loss_timer, htime * 1500,
+    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);
 
@@ -679,7 +679,7 @@ update_link_entry(const union olsr_ip_addr *local,
 
   /* Update ASYM_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);
 
@@ -692,12 +692,12 @@ update_link_entry(const union olsr_ip_addr *local,
   case (ASYM_LINK):
 
     /* L_SYM_time = current time + validity time */
-    olsr_set_timer(&entry->link_sym_timer, message->vtime * MSEC_PER_SEC,
+    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) *
+    olsr_set_link_timer(entry, message->vtime + NEIGHB_HOLD_TIME *
                        MSEC_PER_SEC);
     break;
   default:;
@@ -818,9 +818,9 @@ olsr_print_link_set(void)
  */
 void
 olsr_update_packet_loss_hello_int(struct link_entry *entry,
-                                 double loss_hello_int)
+                                 olsr_reltime loss_hello_int)
 {
-  entry->loss_hello_int = loss_hello_int;
+  entry->loss_helloint = loss_hello_int;
 }
 
 void
@@ -829,7 +829,7 @@ 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_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 f8d15c3..34731eb 100644 (file)
@@ -49,6 +49,7 @@
 #include "lq_plugin.h"
 #include "packet.h"
 #include "common/list.h"
+#include "mantissa.h"
 
 #define MID_ALIAS_HACK_VTIME  10.0
 
@@ -60,7 +61,7 @@ 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;
 
@@ -71,14 +72,14 @@ struct link_entry {
   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;
+  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;
 
   /* user defined multiplies for link quality, multiplied with 65536 */
@@ -139,7 +140,7 @@ 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 *, double);
+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);
 
index 88e1d3c..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;
@@ -161,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;
@@ -297,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;
@@ -312,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));
@@ -342,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
index de8952f..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;
 };
@@ -147,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); }
@@ -167,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 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 7b01072..753f310 100644 (file)
@@ -109,7 +109,7 @@ 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,
@@ -129,7 +129,7 @@ olsr_set_mid_timer(struct mid_entry *mid, unsigned int rel_timer)
 
 void
 insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias,
-                float vtime)
+                olsr_reltime vtime)
 {
   struct mid_entry *tmp;
   struct mid_address *tmp_adr;
@@ -166,7 +166,7 @@ insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *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);
+    olsr_set_mid_timer(tmp, vtime);
   } else {
 
     /*Create new node */
@@ -176,7 +176,7 @@ insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *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);
+    olsr_set_mid_timer(tmp, vtime);
 
     /* Queue */
     QUEUE_ELEM(mid_set[hash], tmp);
@@ -251,7 +251,7 @@ insert_mid_tuple(union olsr_ip_addr *m_addr, struct mid_address *alias,
  */
 void
 insert_mid_alias(union olsr_ip_addr *main_add, const union olsr_ip_addr *alias,
-                float vtime)
+                olsr_reltime vtime)
 {
   struct neighbor_entry *ne_old, *ne_new;
   struct mid_entry *me_old;
@@ -382,7 +382,7 @@ mid_lookup_aliases(const union olsr_ip_addr *adr)
  * @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
@@ -398,7 +398,7 @@ olsr_update_mid_table(const union olsr_ip_addr *adr, float vtime)
        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 * MSEC_PER_SEC);
+      olsr_set_mid_timer(tmp_list, vtime);
 
       return 1;
     }
@@ -528,8 +528,6 @@ olsr_delete_mid_entry(struct mid_entry *mid)
   /* Dequeue */
   DEQUEUE_ELEM(mid);
   free(mid);
-
-  return 0;
 }
 
 
index af202ac..debacd9 100644 (file)
@@ -1,7 +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 
@@ -44,6 +44,7 @@
 
 #include "olsr_types.h"
 #include "hashing.h"
+#include "mantissa.h"
 
 struct mid_address {
   union olsr_ip_addr alias;
@@ -74,14 +75,14 @@ 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);
+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 *, float);
+int olsr_update_mid_table(const union olsr_ip_addr *, olsr_reltime);
 void olsr_delete_mid_entry(struct mid_entry *);
 
 #endif
index 7b58fe9..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;
@@ -156,7 +156,7 @@ olsr_add_mpr_selector(const union olsr_ip_addr *addr, float vtime)
   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);
   /*
@@ -208,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;
@@ -222,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 3166fbc..5003d5c 100644 (file)
@@ -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;
 };
 
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
  */
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 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 841e0ab..2f77585 100644 (file)
@@ -795,8 +795,7 @@ olsr_input_tc(union olsr_message *msg,
 #endif
   olsr_u16_t size, msg_seq, ansn;
   olsr_u8_t type, ttl, msg_hops, lower_border, upper_border;
-  double vtime;
-  unsigned int vtime_s;
+  olsr_reltime vtime;
   union olsr_ip_addr originator;
   const unsigned char *limit, *curr;
   struct tc_entry *tc;
@@ -815,8 +814,7 @@ olsr_input_tc(union olsr_message *msg,
     return;
   }
 
-  pkt_get_double(&curr, &vtime);
-  vtime_s = (unsigned int)vtime;
+  pkt_get_reltime(&curr, &vtime);
   pkt_get_u16(&curr, &size);
 
   pkt_get_ipaddress(&curr, &originator);
@@ -933,7 +931,7 @@ olsr_input_tc(union olsr_message *msg,
   /*
    * Set or change the expiration timer accordingly.
    */
-  olsr_set_timer(&tc->validity_timer, vtime_s * MSEC_PER_SEC,
+  olsr_set_timer(&tc->validity_timer, vtime,
                 OLSR_TC_VTIME_JITTER, OLSR_TIMER_ONESHOT,
                 &olsr_expire_tc_entry, tc, tc_validity_timer_cookie->ci_id);
 
index f0ca9e2..8d4be67 100644 (file)
@@ -644,11 +644,11 @@ add_hemu_if(struct olsr_if *iface)
   if(olsr_cnf->max_tc_vtime < iface->cnf->tc_params.emission_interval)
     olsr_cnf->max_tc_vtime = iface->cnf->tc_params.emission_interval;
 
-  ifp->hello_etime = iface->cnf->hello_params.emission_interval;
-  ifp->valtimes.hello = double_to_me(iface->cnf->hello_params.validity_time);
-  ifp->valtimes.tc = double_to_me(iface->cnf->tc_params.validity_time);
-  ifp->valtimes.mid = double_to_me(iface->cnf->mid_params.validity_time);
-  ifp->valtimes.hna = double_to_me(iface->cnf->hna_params.validity_time);
+  ifp->hello_etime = (olsr_reltime)(iface->cnf->hello_params.emission_interval * MSEC_PER_SEC);
+  ifp->valtimes.hello = reltime_to_me(iface->cnf->hello_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.tc = reltime_to_me(iface->cnf->tc_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.mid = reltime_to_me(iface->cnf->mid_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.hna = reltime_to_me(iface->cnf->hna_params.validity_time * MSEC_PER_SEC);
 
   return 1;
 }
@@ -995,11 +995,11 @@ chk_if_up(struct olsr_if *iface, int debuglvl __attribute__((unused)))
   if(olsr_cnf->max_tc_vtime < iface->cnf->tc_params.emission_interval) {
     olsr_cnf->max_tc_vtime = iface->cnf->tc_params.emission_interval;
   }
-  ifp->hello_etime = iface->cnf->hello_params.emission_interval;
-  ifp->valtimes.hello = double_to_me(iface->cnf->hello_params.validity_time);
-  ifp->valtimes.tc = double_to_me(iface->cnf->tc_params.validity_time);
-  ifp->valtimes.mid = double_to_me(iface->cnf->mid_params.validity_time);
-  ifp->valtimes.hna = double_to_me(iface->cnf->hna_params.validity_time);
+  ifp->hello_etime = (olsr_reltime)(iface->cnf->hello_params.emission_interval * MSEC_PER_SEC);
+  ifp->valtimes.hello = reltime_to_me(iface->cnf->hello_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.tc = reltime_to_me(iface->cnf->tc_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.mid = reltime_to_me(iface->cnf->mid_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.hna = reltime_to_me(iface->cnf->hna_params.validity_time * MSEC_PER_SEC);
 
 
   /*
index 57ea038..ca4288a 100644 (file)
@@ -725,11 +725,11 @@ int add_hemu_if(struct olsr_if *iface)
   if(olsr_cnf->max_tc_vtime < iface->cnf->tc_params.emission_interval)
     olsr_cnf->max_tc_vtime = iface->cnf->tc_params.emission_interval;
 
-  ifp->hello_etime = iface->cnf->hello_params.emission_interval;
-  ifp->valtimes.hello = double_to_me(iface->cnf->hello_params.validity_time);
-  ifp->valtimes.tc = double_to_me(iface->cnf->tc_params.validity_time);
-  ifp->valtimes.mid = double_to_me(iface->cnf->mid_params.validity_time);
-  ifp->valtimes.hna = double_to_me(iface->cnf->hna_params.validity_time);
+  ifp->hello_etime = (olsr_reltime)(iface->cnf->hello_params.emission_interval * MSEC_PER_SEC);
+  ifp->valtimes.hello = reltime_to_me(iface->cnf->hello_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.tc = reltime_to_me(iface->cnf->tc_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.mid = reltime_to_me(iface->cnf->mid_params.validity_time * MSEC_PER_SEC);
+  ifp->valtimes.hna = reltime_to_me(iface->cnf->hna_params.validity_time * MSEC_PER_SEC);
 
   return 1;
 }
@@ -1021,12 +1021,11 @@ int chk_if_up(struct olsr_if *IntConf, int DebugLevel __attribute__((unused)))
   if(olsr_cnf->max_tc_vtime < IntConf->cnf->tc_params.emission_interval)
     olsr_cnf->max_tc_vtime = IntConf->cnf->tc_params.emission_interval;
 
-  New->hello_etime = IntConf->cnf->hello_params.emission_interval;
-
-  New->valtimes.hello = double_to_me(IntConf->cnf->hello_params.validity_time);
-  New->valtimes.tc = double_to_me(IntConf->cnf->tc_params.validity_time);
-  New->valtimes.mid = double_to_me(IntConf->cnf->mid_params.validity_time);
-  New->valtimes.hna = double_to_me(IntConf->cnf->hna_params.validity_time);
+  New->hello_etime = (olsr_reltime)(IntConf->cnf->hello_params.emission_interval * MSEC_PER_SEC);
+  New->valtimes.hello = reltime_to_me(IntConf->cnf->hello_params.validity_time * MSEC_PER_SEC);
+  New->valtimes.tc = reltime_to_me(IntConf->cnf->tc_params.validity_time * MSEC_PER_SEC);
+  New->valtimes.mid = reltime_to_me(IntConf->cnf->mid_params.validity_time * MSEC_PER_SEC);
+  New->valtimes.hna = reltime_to_me(IntConf->cnf->hna_params.validity_time * MSEC_PER_SEC);
 
   run_ifchg_cbs(New, IFCHG_IF_ADD);