stop links from NEVER timing out. && optional vtime output in txtinfo
authorMarkus Kittenberger <Markus.Kittenberger@gmx.at>
Sat, 22 Aug 2009 20:03:37 +0000 (22:03 +0200)
committerMarkus Kittenberger <Markus.Kittenberger@gmx.at>
Sat, 22 Aug 2009 20:03:37 +0000 (22:03 +0200)
contains backported system_time handling from tiptip which is safe against jumps of local time
and adaptions in txtinfo to show the remaining validity time of links and tc-edges
theese can be enabled in olsrd_txtinfo.h at compile time

18 files changed:
lib/bmf/src/PacketHistory.c
lib/bmf/src/PacketHistory.h
lib/secure/src/olsrd_secure.c
lib/txtinfo/src/olsrd_txtinfo.c
src/build_msg.c
src/build_msg.h
src/defs.h
src/duplicate_set.c
src/duplicate_set.h
src/hysteresis.c
src/interfaces.h
src/link_set.c
src/link_set.h
src/main.c
src/olsr_cfg.h
src/scheduler.c
src/scheduler.h
src/socket_parser.c

index 856ce51..2e8528e 100644 (file)
@@ -51,6 +51,7 @@
 /* OLSRD includes */
 #include "defs.h"               /* GET_TIMESTAMP, TIMED_OUT */
 #include "olsr.h"               /* olsr_printf */
+#include "scheduler.h"
 
 /* Plugin includes */
 #include "Packet.h"
@@ -245,7 +246,7 @@ CheckAndMarkRecentPacket(u_int32_t crc32)
       /* Found duplicate entry */
 
       /* Always mark as "seen recently": refresh time-out */
-      walker->timeOut = GET_TIMESTAMP(HISTORY_HOLD_TIME);
+      walker->timeOut = olsr_getTimestamp(HISTORY_HOLD_TIME);
 
       return 1;
     }                           /* if */
index 0740312..d725bb3 100644 (file)
@@ -43,7 +43,6 @@
 
 /* System includes */
 #include <sys/types.h>          /* ssize_t */
-#include <sys/times.h>          /* clock_t */
 
 #define N_HASH_BITS 12
 #define HISTORY_HASH_SIZE (1 << N_HASH_BITS)
@@ -53,7 +52,7 @@
 
 struct TDupEntry {
   u_int32_t crc32;
-  clock_t timeOut;
+  u_int32_t timeOut;
   struct TDupEntry *next;
 };
 
index a6adfe3..d9a61bc 100644 (file)
@@ -117,8 +117,8 @@ struct stamp {
   int diff;
   uint32_t challenge;
   uint8_t validated;
-  clock_t valtime;                     /* Validity time */
-  clock_t conftime;                    /* Reconfiguration time */
+  uint32_t valtime;                     /* Validity time */
+  uint32_t conftime;                    /* Reconfiguration time */
   struct stamp *prev;
   struct stamp *next;
 };
index 149b2b7..50750d6 100644 (file)
@@ -353,11 +353,11 @@ ipc_print_link(struct autobuf *abuf)
   /* Link set */
   OLSR_FOR_ALL_LINK_ENTRIES(my_link) {
 #ifdef ACTIVATE_VTIME_TXTINFO
-    int diff = olsr_cnf->system_tick_divider * (unsigned int)(my_link->ASYM_time - now_times);
+    int diff = (unsigned int)(my_link->link_timer->timer_clock - now_times1);
 
     abuf_appendf(abuf, "%s\t%s\t%d.%03d\t%s\t%s\t\n", olsr_ip_to_string(&buf1, &my_link->local_iface_addr),
               olsr_ip_to_string(&buf2, &my_link->neighbor_iface_addr),
-              diff/1000, diff%1000,
+              diff/1000, abs(diff%1000),
               get_link_entry_text(my_link, '\t', &lqbuffer1),
               get_linkcost_text(my_link->linkcost, false, &lqbuffer2));
 #else
@@ -411,8 +411,8 @@ ipc_print_topology(struct autobuf *abuf)
         struct ipaddr_str dstbuf, addrbuf;
         struct lqtextbuffer lqbuffer1, lqbuffer2;
 #ifdef ACTIVATE_VTIME_TXTINFO
-        clock_t vt = tc->validity_timer != NULL ? (tc->validity_timer->timer_clock - now_times) : 0;
-        int diff = olsr_cnf->system_tick_divider * (int)(vt);
+        uint32_t vt = tc->validity_timer != NULL ? (tc->validity_timer->timer_clock - now_times1) : 0;
+        int diff = (int)(vt);
         abuf_appendf(abuf, "%s\t%s\t%s\t%s\t%d.%03d\n", olsr_ip_to_string(&dstbuf, &tc_edge->T_dest_addr),
             olsr_ip_to_string(&addrbuf, &tc->addr),
             get_tc_edge_entry_text(tc_edge, '\t', &lqbuffer1),
index 8430448..9830e10 100644 (file)
@@ -67,7 +67,7 @@ static void check_buffspace(int msgsize, int buffsize, const char *type);
 static uint32_t msg_buffer_align[(MAXMESSAGESIZE - OLSR_HEADERSIZE)/sizeof(uint32_t) + 1];
 static uint8_t *msg_buffer = (uint8_t *)msg_buffer_align;
 
-static clock_t send_empty_tc;          /* TC empty message sending */
+static uint32_t send_empty_tc;          /* TC empty message sending */
 
 /* Prototypes for internal functions */
 
@@ -96,7 +96,7 @@ static bool serialize_hna6(struct interface *);
  * empty TC messages
  */
 void
-set_empty_tc_timer(clock_t empty_tc_new)
+set_empty_tc_timer(uint32_t empty_tc_new)
 {
   send_empty_tc = empty_tc_new;
 }
@@ -105,7 +105,7 @@ set_empty_tc_timer(clock_t empty_tc_new)
  * Get the timer that controls the generation of
  * empty TC messages
  */
-clock_t
+uint32_t
 get_empty_tc_timer(void)
 {
   return send_empty_tc;
@@ -650,8 +650,8 @@ serialize_tc4(struct tc_message *message, struct interface *ifp)
   } else {
     if ((!partial_sent) && (!TIMED_OUT(send_empty_tc))) {
       if (!TIMED_OUT(send_empty_tc))
-        OLSR_PRINTF(1, "TC: Sending empty package - (%d/%d/%d/%d)\n", partial_sent, (int)send_empty_tc, (int)now_times,
-                    (int)((send_empty_tc) - now_times));
+        OLSR_PRINTF(1, "TC: Sending empty package - (%d/%d/%d/%d)\n", partial_sent, (int)send_empty_tc, (int)now_times1,
+                    (int)((send_empty_tc) - now_times1));
 
       m->v4.olsr_msgsize = htons(curr_size);
       m->v4.seqno = htons(get_msg_seqno());
index f9ce8d8..20103bb 100644 (file)
@@ -46,9 +46,9 @@
 #include "olsr_protocol.h"
 #include <time.h>               /* For clock_t */
 
-void set_empty_tc_timer(clock_t);
+void set_empty_tc_timer(uint32_t);
 
-clock_t get_empty_tc_timer(void);
+uint32_t get_empty_tc_timer(void);
 
 bool queue_hello(struct hello_message *, struct interface *);
 
index 8cbf110..c9eaa15 100644 (file)
@@ -94,13 +94,13 @@ extern FILE *debug_handle;
  * Provides a timestamp s1 milliseconds in the future according
  * to system ticks returned by times(2)
 */
-#define GET_TIMESTAMP(s1)      (now_times + ((s1) / olsr_cnf->system_tick_divider))
+#define GET_TIMESTAMP(s1)      olsr_getTimestamp(s1)
 
 /* Compute the time in milliseconds when a timestamp will expire. */
-#define TIME_DUE(s1)   ((int)((s1) * olsr_cnf->system_tick_divider) - now_times)
+#define TIME_DUE(s1)   olsr_getTimeDue(s1)
 
 /* Returns TRUE if a timestamp is expired */
-#define TIMED_OUT(s1)  ((int)((s1) - now_times) < 0)
+#define TIMED_OUT(s1)  olsr_isTimedOut(s1)
 
 #define ARRAYSIZE(x)   (sizeof(x)/sizeof(*(x)))
 #ifndef MAX
@@ -182,21 +182,14 @@ strscat(char *dest, const char *src, size_t size)
 extern struct olsrd_config *olsr_cnf;
 
 /* Timer data */
-extern clock_t now_times;              /* current idea of times(2) reported uptime */
+extern uint32_t now_times1;              /* current idea of times(2) reported uptime */
 
 #if defined WIN32
 extern bool olsr_win32_end_request;
 extern bool olsr_win32_end_flag;
 #endif
 
-/*
- * a wrapper around times(2). times(2) has the problem, that it may return -1
- * in case of an err (e.g. EFAULT on the parameter) or immediately before an
- * overrun (though it is not en error) just because the jiffies (or whatever
- * the underlying kernel calls the smallest accountable time unit) are
- * inherently "unsigned" (and always incremented).
- */
-clock_t olsr_times(void);
+uint32_t olsr_times(void);
 
 /*
  *IPC functions
index 556df3c..8812392 100644 (file)
@@ -96,7 +96,7 @@ olsr_message_is_duplicate(union olsr_message *m)
   struct dup_entry *entry;
   int diff;
   void *mainIp;
-  clock_t valid_until;
+  uint32_t valid_until;
   struct ipaddr_str buf;
   uint16_t seqnr;
   void *ip;
index cd239dc..d1883c8 100644 (file)
@@ -57,7 +57,7 @@ struct dup_entry {
   uint16_t seqnr;
   uint16_t too_low_counter;
   uint32_t array;
-  clock_t valid_until;
+  uint32_t valid_until;
 };
 
 AVLNODE2STRUCT(duptree2dupentry, struct dup_entry, avl);
index 37e3e80..9ae3c23 100644 (file)
@@ -83,7 +83,7 @@ olsr_process_hysteresis(struct link_entry *entry)
       changes_neighborhood = true;
 
     /* time = now -1 */
-    entry->L_LOST_LINK_time = now_times - 1;
+    entry->L_LOST_LINK_time = now_times1 - 1;
 
     return 1;
   }
index c5d3202..b0e638d 100644 (file)
@@ -162,7 +162,7 @@ struct interface {
   olsr_reltime hello_etime;
   struct vtimes valtimes;
 
-  clock_t fwdtimer;                    /* Timeout for OLSR forwarding on this if */
+  uint32_t fwdtimer;                    /* Timeout for OLSR forwarding on this if */
 
   struct olsr_netbuf netbuf;           /* the buffer to construct the packet data */
 
index bf6286e..e71d071 100644 (file)
@@ -50,6 +50,7 @@
 #include "mpr.h"
 #include "neighbor_table.h"
 #include "olsr.h"
+#include "log.h"
 #include "scheduler.h"
 #include "olsr_spf.h"
 #include "net_olsr.h"
@@ -557,6 +558,7 @@ add_link_entry(const union olsr_ip_addr *local, const union olsr_ip_addr *remote
     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);
   }
 
index bee9121..c578d3f 100644 (file)
@@ -62,7 +62,7 @@ struct link_entry {
   char *if_name;
   struct timer_entry *link_timer;
   struct timer_entry *link_sym_timer;
-  clock_t ASYM_time;
+  uint32_t ASYM_time;
   olsr_reltime vtime;
   struct neighbor_entry *neighbor;
   uint8_t prev_status;
@@ -72,7 +72,7 @@ struct link_entry {
    */
   float L_link_quality;
   int L_link_pending;
-  clock_t L_LOST_LINK_time;
+  uint32_t L_LOST_LINK_time;
   struct timer_entry *link_hello_timer; /* When we should receive a new HELLO */
   olsr_reltime last_htime;
   bool olsr_seqno_valid;
index 9eda27a..604cc23 100644 (file)
@@ -185,22 +185,6 @@ int main(int argc, char *argv[]) {
   /* Open syslog */
   olsr_openlog("olsrd");
 
-  /* Grab initial timestamp */
-  now_times = olsr_times();
-  if ((clock_t) - 1 == now_times) {
-    const char * const err_msg = strerror(errno);
-    olsr_syslog(OLSR_LOG_ERR, "Error in times(): %s, sleeping for a second",
-        err_msg);
-    OLSR_PRINTF(1, "Error in times(): %s, sleeping for a second", err_msg);
-    sleep(1);
-    now_times = olsr_times();
-    if ((clock_t) - 1 == now_times) {
-      olsr_syslog(OLSR_LOG_ERR, "Shutting down because times() does not work");
-      fprintf(stderr, "Shutting down because times() does not work\n");
-      exit(EXIT_FAILURE);
-    }
-  }
-
   printf("\n *** %s ***\n Build date: %s on %s\n http://www.olsr.org\n\n",
       olsrd_version, build_date, build_host);
 
@@ -267,13 +251,6 @@ int main(int argc, char *argv[]) {
     exit(EXIT_FAILURE);
   }
 
-  /* Initialize tick resolution */
-#ifndef WIN32
-  olsr_cnf->system_tick_divider = 1000 / sysconf(_SC_CLK_TCK);
-#else
-  olsr_cnf->system_tick_divider = 1;
-#endif
-
   /* Initialize timers */
   olsr_init_timers();
 
@@ -921,45 +898,6 @@ static int olsr_process_arguments(int argc, char *argv[],
   return 0;
 }
 
-/*
- * A wrapper around times(2). Note, that this function has
- * some portability problems, e.g. different operating systems
- * and linux kernel versions may return values counted from
- * an arbitrary point in time (mostly uptime, some count from
- * the epoch. The linux man page therefore recommends not to
- * use this function. On the other hand, this function has
- * proved it's functions but some olsrd implementations does
- * error handling in a clumsy way - thus inducing bugs...
- *
- * Analysis of times() in different OSes:
- * Linux:
- *   times() returns the number of clock ticks that have
- *   elapsed since an arbitrary point in the past.  The return
- *   value may overflow the possible range of type clock_t.   On
- *     error, (clock_t) -1 is returned, and errno is set appropriately.
- *
- * BSDs:
- *  The times() function returns the value of time in CLK_TCK's
- *  of a second since 0 hours, 0 minutes, 0 seconds, January 1,
- *  1970, Coordinated Universal Time.
- *
- * Values for clock_t in different OSes:
- *  OSX ............ unsigned long
- *  linux .......... long int (signed !)
- *  win32 cygwin.... unsigned long
- *  openBSD ........ int
- *
- * We therefore need to be very very careful how to (portably)
- * handle overflows!!
- * This current commit does not solve the problem yet.
- * it merely documents the problems with times()
- *
- */
-clock_t olsr_times(void) {
-  struct tms tms_buf;
-  return times(&tms_buf);
-}
-
 /*
  * Local Variables:
  * c-basic-offset: 2
index e734c9a..29ff74b 100644 (file)
@@ -224,7 +224,6 @@ struct olsrd_config {
 
   float min_tc_vtime;
   /* Stuff set by olsrd */
-  uint16_t system_tick_divider;        /* Tick resolution */
   uint8_t maxplen;                     /* maximum prefix len */
   size_t ipsize;                       /* Size of address */
   bool del_gws;                        /* Delete InternetGWs at startup */
index a60e640..8159ee3 100644 (file)
 #include "olsr_cookie.h"
 
 /* Timer data, global. Externed in defs.h */
-clock_t now_times;                     /* current idea of times(2) reported uptime */
+uint32_t now_times1;                    /* relative time compared to startup (in milliseconds */
+struct timeval first_tv;               /* timevalue during startup */
+struct timeval last_tv;                /* timevalue used for last olsr_times() calculation */
 
 /* Hashed root of all timers */
-struct list_node timer_wheel[TIMER_WHEEL_SLOTS];
-clock_t timer_last_run;                /* remember the last timeslot walk */
+static struct list_node timer_wheel[TIMER_WHEEL_SLOTS];
+static uint32_t timer_last_run1;                /* remember the last timeslot walk */
 
 /* Pool of timers to avoid malloc() churn */
-struct list_node free_timer_list;
+static struct list_node free_timer_list;
 
 /* Statistics */
 unsigned int timers_running;
 
+uint32_t
+olsr_times(void)
+{
+  struct timeval tv;
+  uint32_t t;
+
+  if (gettimeofday(&tv, NULL) != 0) {
+    OLSR_PRINTF(0, "OS clock is not working, have to shut down OLSR (%s)\n", strerror(errno));
+    exit(0);
+  }
+
+  /* test if time jumped backward or more than 60 seconds forward */
+  if (tv.tv_sec < last_tv.tv_sec || (tv.tv_sec == last_tv.tv_sec && tv.tv_usec < last_tv.tv_usec)
+      || tv.tv_sec - last_tv.tv_sec > 60) {
+    OLSR_PRINTF(3, "Time jump (%d.%06d to %d.%06d)\n",
+              (int32_t) (last_tv.tv_sec), (int32_t) (last_tv.tv_usec), (int32_t) (tv.tv_sec), (int32_t) (tv.tv_usec));
+
+    t = (last_tv.tv_sec - first_tv.tv_sec) * 1000 + (last_tv.tv_usec - first_tv.tv_usec) / 1000;
+    t++;                        /* advance time by one millisecond */
+
+    first_tv = tv;
+    first_tv.tv_sec -= (t / 1000);
+    first_tv.tv_usec -= ((t % 1000) * 1000);
+
+    if (first_tv.tv_usec < 0) {
+      first_tv.tv_sec--;
+      first_tv.tv_usec += 1000000;
+    }
+    last_tv = tv;
+    return t;
+  }
+  last_tv = tv;
+  return (tv.tv_sec - first_tv.tv_sec) * 1000 + (tv.tv_usec - first_tv.tv_usec) / 1000;
+}
+
+/**
+ * Returns a timestamp s seconds in the future
+ */
+uint32_t
+olsr_getTimestamp(uint32_t s)
+{
+  return now_times1 + s;
+}
+
+/**
+ * Returns the number of milliseconds until the timestamp will happen
+ */
+
+int32_t
+olsr_getTimeDue(uint32_t s)
+{
+  uint32_t diff;
+  if (s > now_times1) {
+    diff = s - now_times1;
+
+    /* overflow ? */
+    if (diff > (1u << 31)) {
+      return -(int32_t) (0xffffffff - diff);
+    }
+    return (int32_t) (diff);
+  }
+
+  diff = now_times1 - s;
+  /* overflow ? */
+  if (diff > (1u << 31)) {
+    return (int32_t) (0xffffffff - diff);
+  }
+  return -(int32_t) (diff);
+}
+
+bool
+olsr_isTimedOut(uint32_t s)
+{
+  if (s > now_times1) {
+    return s - now_times1 > (1u << 31);
+  }
+
+  return now_times1 - s <= (1u << 31);
+}
+
 /**
  * Sleep until the next scheduling interval.
  *
@@ -77,7 +159,7 @@ unsigned int timers_running;
  * @return nada
  */
 static void
-olsr_scheduler_sleep(unsigned long scheduler_runtime)
+olsr_scheduler_sleep(uint32_t scheduler_runtime)
 {
   struct timespec remainder_spec, sleeptime_spec;
   struct timeval sleeptime_val, time_used, next_interval;
@@ -90,7 +172,7 @@ olsr_scheduler_sleep(unsigned long scheduler_runtime)
   next_interval.tv_usec = next_interval_usec % USEC_PER_SEC;
 
   /* Determine used runtime */
-  milliseconds_used = scheduler_runtime * olsr_cnf->system_tick_divider;
+  milliseconds_used = scheduler_runtime;
   time_used.tv_sec = milliseconds_used / MSEC_PER_SEC;
   time_used.tv_usec = (milliseconds_used % MSEC_PER_SEC) * USEC_PER_MSEC;
 
@@ -129,13 +211,13 @@ olsr_scheduler(void)
      * Update the global timestamp. We are using a non-wallclock timer here
      * to avoid any undesired side effects if the system clock changes.
      */
-    now_times = olsr_times();
+    now_times1 = olsr_times();
 
     /* Read incoming data */
     olsr_poll_sockets();
 
     /* Process timers (before packet generation) */
-    olsr_walk_timers(&timer_last_run);
+    olsr_walk_timers(&timer_last_run1);
 
     /* Update */
     olsr_process_changes();
@@ -155,7 +237,7 @@ olsr_scheduler(void)
     }
 
     /* We are done, sleep until the next scheduling interval. */
-    olsr_scheduler_sleep(olsr_times() - now_times);
+    olsr_scheduler_sleep(olsr_times() - now_times1);
 
 #if defined WIN32
     /* The Ctrl-C signal handler thread asks us to exit */
@@ -187,7 +269,7 @@ olsr_scheduler(void)
  * @param cached result of random() at system init.
  * @return the absolute timer in system clock tick units
  */
-static clock_t
+static uint32_t
 olsr_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val)
 {
   unsigned int jitter_time;
@@ -298,7 +380,14 @@ olsr_init_timers(void)
   /*
    * Reset the last timer run.
    */
-  timer_last_run = now_times;
+  timer_last_run1 = now_times1;
+
+  if (gettimeofday(&first_tv, NULL)) {
+    OLSR_PRINTF(0, "OS clock is not working, have to shut down OLSR (%d)\n", errno);
+    exit(1);
+  }
+  last_tv = first_tv;
+  now_times1 = olsr_times();
 
   /* Timer memory pooling */
   list_head_init(&free_timer_list);
@@ -310,7 +399,7 @@ olsr_init_timers(void)
  * Callback the provided function with the context pointer.
  */
 void
-olsr_walk_timers(clock_t * last_run)
+olsr_walk_timers(uint32_t * last_run)
 {
   static struct timer_entry *timer;
   struct list_node *timer_head_node;
@@ -325,7 +414,7 @@ olsr_walk_timers(clock_t * last_run)
    * The latter is meant as a safety belt if the scheduler falls behind.
    */
   total_timers_walked = total_timers_fired = timers_walked = timers_fired = 0;
-  while ((*last_run <= now_times) && (wheel_slot_walks < TIMER_WHEEL_SLOTS)) {
+  while ((*last_run <= now_times1) && (wheel_slot_walks < TIMER_WHEEL_SLOTS)) {
 
     /* keep some statistics */
     total_timers_walked += timers_walked;
@@ -408,7 +497,7 @@ olsr_walk_timers(clock_t * last_run)
    * If the scheduler has slipped and we have walked all wheel slots,
    * reset the last timer run.
    */
-  *last_run = now_times;
+  *last_run = now_times1;
 }
 
 /**
@@ -492,20 +581,17 @@ olsr_wallclock_string(void)
  * @return buffer to a formatted system time string.
  */
 const char *
-olsr_clock_string(clock_t the_clock)
+olsr_clock_string(uint32_t clk)
 {
   static char buf[4][sizeof("00:00:00.000")];
   static int idx = 0;
   char *ret;
-  unsigned int sec, msec;
+  unsigned int msec = clk % 1000;
+  unsigned int sec = clk / 1000;
 
   ret = buf[idx];
   idx = (idx + 1) & 3;
 
-  /* On most systems a clocktick is a 10ms quantity. */
-  msec = olsr_cnf->system_tick_divider * (unsigned int)(the_clock - now_times);
-  sec = msec / MSEC_PER_SEC;
-
   snprintf(ret, sizeof(buf) / 4, "%02u:%02u:%02u.%03u", sec / 3600, (sec % 3600) / 60, (sec % 60), (msec % MSEC_PER_SEC));
 
   return ret;
index 29c3edd..b1c248c 100644 (file)
@@ -66,7 +66,7 @@
  */
 struct timer_entry {
   struct list_node timer_list;         /* memory pooling, or wheel membership */
-  clock_t timer_clock;                 /* when timer shall fire (absolute time) */
+  uint32_t timer_clock;                 /* when timer shall fire (absolute time) */
   unsigned int timer_period;           /* set for periodical timers (relative time) */
   olsr_cookie_t timer_cookie;          /* used for diag stuff */
   uint8_t timer_jitter_pct;            /* the jitter expressed in percent */
@@ -90,19 +90,23 @@ LISTNODE2STRUCT(list2timer, struct timer_entry, timer_list);
 
 /* Timers */
 void olsr_init_timers(void);
-void olsr_walk_timers(clock_t *);
+void olsr_walk_timers(uint32_t *);
 void olsr_set_timer(struct timer_entry **, unsigned int, uint8_t, bool, void (*)(void *), void *, olsr_cookie_t);
 struct timer_entry *olsr_start_timer(unsigned int, uint8_t, bool, void (*)(void *), void *, olsr_cookie_t);
 void olsr_change_timer(struct timer_entry *, unsigned int, uint8_t, bool);
 void olsr_stop_timer(struct timer_entry *);
 
 /* Printing timestamps */
-const char *olsr_clock_string(clock_t);
+const char *olsr_clock_string(uint32_t);
 const char *olsr_wallclock_string(void);
 
 /* Main scheduler loop */
 void olsr_scheduler(void) __attribute__ ((noreturn));
 
+uint32_t olsr_getTimestamp (uint32_t s);
+int32_t olsr_getTimeDue (uint32_t s);
+bool olsr_isTimedOut (uint32_t s);
+
 #endif
 
 /*
index f3aa8de..e0c850c 100644 (file)
@@ -180,7 +180,7 @@ olsr_poll_sockets(void)
   }
 
   /* Update time since this is much used by the parsing functions */
-  now_times = olsr_times();
+  now_times1 = olsr_times();
 
   for (olsr_sockets = olsr_socket_entries; olsr_sockets; olsr_sockets = olsr_sockets->next) {
     if (FD_ISSET(olsr_sockets->fd, &ibits))