Normalize olsr_clock namespace
authorHenning Rogge <hrogge@googlemail.com>
Fri, 25 Feb 2011 17:00:57 +0000 (18:00 +0100)
committerHenning Rogge <hrogge@googlemail.com>
Fri, 25 Feb 2011 17:00:57 +0000 (18:00 +0100)
15 files changed:
lib/bmf/src/PacketHistory.c
lib/httpinfo/src/olsrd_httpinfo.c
lib/secure/src/olsrd_secure.c
lib/txtinfo/src/olsrd_txtinfo.c
src/interfaces.c
src/link_set.c
src/lq_packet.h
src/olsr.c
src/olsr_cfg.c
src/olsr_cfg_gen.c
src/olsr_clock.c
src/olsr_clock.h
src/olsr_socket.c
src/olsr_timer.c
src/tc_set.c

index e49fe24..f432302 100644 (file)
@@ -248,7 +248,7 @@ CheckAndMarkRecentPacket(u_int32_t crc32)
       /* Found duplicate entry */
 
       /* Always mark as "seen recently": refresh time-out */
-      walker->timeOut = olsr_timer_getAbsolute(HISTORY_HOLD_TIME);
+      walker->timeOut = olsr_clock_getAbsolute(HISTORY_HOLD_TIME);
 
       return 1;
     }                           /* if */
@@ -258,7 +258,7 @@ CheckAndMarkRecentPacket(u_int32_t crc32)
   newEntry = malloc(sizeof(struct TDupEntry));
   if (newEntry != NULL) {
     newEntry->crc32 = crc32;
-    newEntry->timeOut = olsr_timer_getAbsolute(HISTORY_HOLD_TIME);
+    newEntry->timeOut = olsr_clock_getAbsolute(HISTORY_HOLD_TIME);
 
     /* Add new entry at the front of the list */
     newEntry->next = PacketHistory[idx];
@@ -288,7 +288,7 @@ PrunePacketHistory(void *useless __attribute__ ((unused)))
         struct TDupEntry *entry = nextEntry;
         nextEntry = entry->next;
 
-        if (olsr_timer_isTimedOut(entry->timeOut)) {
+        if (olsr_clock_isPast(entry->timeOut)) {
           /* De-queue */
           if (prevEntry != NULL) {
             prevEntry->next = entry->next;
index 07fb5cb..0eec676 100644 (file)
@@ -845,10 +845,10 @@ build_config_body(struct autobuf *abuf)
 
   abuf_puts(abuf, "</tr>\n<tr>\n");
 
-  abuf_appendf(abuf, "<td>Pollrate: %s</td>\n", olsr_milli_to_txt(&tbuf, olsr_cnf->pollrate));
+  abuf_appendf(abuf, "<td>Pollrate: %s</td>\n", olsr_clock_to_string(&tbuf, olsr_cnf->pollrate));
   abuf_appendf(abuf, "<td>TC redundancy: %d</td>\n", olsr_cnf->tc_redundancy);
   abuf_appendf(abuf, "<td>MPR coverage: %d</td>\n", olsr_cnf->mpr_coverage);
-  abuf_appendf(abuf, "<td>NAT threshold: %s</td>\n", olsr_milli_to_txt(&tbuf, olsr_cnf->lq_nat_thresh));
+  abuf_appendf(abuf, "<td>NAT threshold: %s</td>\n", olsr_clock_to_string(&tbuf, olsr_cnf->lq_nat_thresh));
 
   abuf_puts(abuf, "</tr>\n<tr>\n");
 
index 968ce3a..786f48a 100644 (file)
@@ -557,7 +557,7 @@ check_timestamp(struct interface *olsr_if_config, const union olsr_ip_addr *orig
 
   /* update validtime */
 
-  entry->valtime = olsr_timer_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
+  entry->valtime = olsr_clock_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
 
   return 1;
 }
@@ -633,7 +633,7 @@ send_challenge(struct interface *olsr_if_config, const union olsr_ip_addr *new_h
   memcpy(&entry->addr, new_host, olsr_cnf->ipsize);
 
   /* update validtime - not validated */
-  entry->conftime = olsr_timer_getAbsolute(EXCHANGE_HOLD_TIME * 1000);
+  entry->conftime = olsr_clock_getAbsolute(EXCHANGE_HOLD_TIME * 1000);
 
   hash = olsr_ip_hashing(new_host);
 
@@ -730,7 +730,7 @@ parse_cres(struct interface *olsr_if_config, uint8_t *in_msg)
   entry->diff = now.tv_sec - msg->timestamp;
 
   /* update validtime - validated entry */
-  entry->valtime = olsr_timer_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
+  entry->valtime = olsr_clock_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
 
   OLSR_DEBUG(LOG_PLUGINS, "[ENC]%s registered with diff %d!\n",
              olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->originator), entry->diff);
@@ -822,7 +822,7 @@ parse_rres(uint8_t *in_msg)
   entry->diff = now.tv_sec - msg->timestamp;
 
   /* update validtime - validated entry */
-  entry->valtime = olsr_timer_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
+  entry->valtime = olsr_clock_getAbsolute(TIMESTAMP_HOLD_TIME * 1000);
 
   OLSR_DEBUG(LOG_PLUGINS, "[ENC]%s registered with diff %d!\n",
              olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->originator), entry->diff);
@@ -866,7 +866,7 @@ parse_challenge(struct interface *olsr_if_config, uint8_t *in_msg)
     entry->prev = &timestamps[hash];
   } else {
     /* Check configuration timeout */
-    if (!olsr_timer_isTimedOut(entry->conftime)) {
+    if (!olsr_clock_isPast(entry->conftime)) {
       /* If registered - do not accept! */
       OLSR_DEBUG(LOG_PLUGINS, "[ENC]Challenge from registered node...dropping!\n");
       return 0;
@@ -902,7 +902,7 @@ parse_challenge(struct interface *olsr_if_config, uint8_t *in_msg)
   entry->validated = 0;
 
   /* update validtime - not validated */
-  entry->conftime = olsr_timer_getAbsolute(EXCHANGE_HOLD_TIME * 1000);
+  entry->conftime = olsr_clock_getAbsolute(EXCHANGE_HOLD_TIME * 1000);
 
   /* Build and send response */
 
@@ -1117,7 +1117,7 @@ timeout_timestamps(void *foo __attribute__ ((unused)))
     /*Traverse MID list */
     while (tmp_list != &timestamps[idx]) {
       /*Check if the entry is timed out */
-      if ((olsr_timer_isTimedOut(tmp_list->valtime)) && (olsr_timer_isTimedOut(tmp_list->conftime))) {
+      if ((olsr_clock_isPast(tmp_list->valtime)) && (olsr_clock_isPast(tmp_list->conftime))) {
 #if !defined REMOVE_LOG_DEBUG
         struct ipaddr_str buf;
 #endif
index c1743ee..3be2ad3 100644 (file)
@@ -432,7 +432,7 @@ txtinfo_link(struct comport_connection *con,
     olsr_ip_to_string(&buf_neighip, &lnk->neighbor_iface_addr);
     strscpy(buf_sym, lnk->status == SYM_LINK ? OLSR_YES : OLSR_NO, sizeof(buf_sym));
     strscpy(buf_mrp, lnk->is_mpr ? OLSR_YES : OLSR_NO, sizeof(buf_mrp));
-    olsr_milli_to_txt(&buf_vtime, lnk->link_sym_timer == NULL ? 0 : lnk->link_sym_timer->timer_clock - olsr_timer_getNow());
+    olsr_clock_to_string(&buf_vtime, lnk->link_sym_timer == NULL ? 0 : lnk->link_sym_timer->timer_clock - olsr_clock_getNow());
     snprintf(buf_rawlinkcost, sizeof(buf_rawlinkcost), "%ud", lnk->linkcost);
 
     olsr_get_linkcost_text(lnk->linkcost, false, buf_linkcost, sizeof(buf_linkcost));
@@ -528,7 +528,7 @@ txtinfo_topology(struct comport_connection *con,
     struct tc_edge_entry *tc_edge, *edge_iterator;
     olsr_ip_to_string(&buf_localip, &tc->addr);
     if (tc->validity_timer) {
-      olsr_milli_to_txt(&buf_vtime, tc->validity_timer->timer_clock - olsr_timer_getNow());
+      olsr_clock_to_string(&buf_vtime, tc->validity_timer->timer_clock - olsr_clock_getNow());
     }
     else {
       strscpy(buf_vtime.buf, "0.0", sizeof(buf_vtime));
@@ -654,7 +654,7 @@ txtinfo_hna(struct comport_connection *con,
 
     olsr_ip_to_string(&buf_localip, &tc->addr);
     if (tc->validity_timer) {
-      olsr_milli_to_txt(&buf_vtime, tc->validity_timer->timer_clock - olsr_timer_getNow());
+      olsr_clock_to_string(&buf_vtime, tc->validity_timer->timer_clock - olsr_clock_getNow());
     }
     else {
       strscpy(buf_vtime.buf, "0.0", sizeof(buf_vtime));
@@ -717,7 +717,7 @@ txtinfo_mid(struct comport_connection *con,
     olsr_ip_to_string(&buf_localip, &tc->addr);
     if (tc->validity_timer) {
       if (tc->validity_timer) {
-        olsr_milli_to_txt(&buf_vtime, tc->validity_timer->timer_clock - olsr_timer_getNow());
+        olsr_clock_to_string(&buf_vtime, tc->validity_timer->timer_clock - olsr_clock_getNow());
       }
       else {
         strscpy(buf_vtime.buf, "0.0", sizeof(buf_vtime));
index f0c17da..099ca67 100644 (file)
@@ -141,7 +141,7 @@ static void add_lost_interface_ip(union olsr_ip_addr *ip, uint32_t hello_timeout
   lost = olsr_memcookie_malloc(interface_lost_mem_cookie);
   lost->node.key = &lost->ip;
   lost->ip = *ip;
-  lost->valid_until = olsr_timer_getAbsolute(hello_timeout * 2);
+  lost->valid_until = olsr_clock_getAbsolute(hello_timeout * 2);
   avl_insert(&interface_lost_tree, &lost->node);
 
   OLSR_DEBUG(LOG_INTERFACE, "Added %s to lost interface list for %d ms\n",
@@ -291,7 +291,7 @@ check_interface_updates(void *foo __attribute__ ((unused)))
 
   /* clean up lost interface tree */
   OLSR_FOR_ALL_LOSTIF_ENTRIES(lost, iterator) {
-    if (olsr_timer_isTimedOut(lost->valid_until)) {
+    if (olsr_clock_isPast(lost->valid_until)) {
       remove_lost_interface_ip(lost);
     }
   }
index 7504fcc..e4dc7d5 100644 (file)
@@ -117,7 +117,7 @@ lookup_link_status(const struct link_entry *entry)
     return SYM_LINK;
   }
 
-  if (!olsr_timer_isTimedOut(entry->ASYM_time)) {
+  if (!olsr_clock_isPast(entry->ASYM_time)) {
     return ASYM_LINK;
   }
 
@@ -528,7 +528,7 @@ update_link_entry(const union olsr_ip_addr *local,
 
   /* Update ASYM_time */
   entry->vtime = message->comm->vtime;
-  entry->ASYM_time = olsr_timer_getAbsolute(message->comm->vtime);
+  entry->ASYM_time = olsr_clock_getAbsolute(message->comm->vtime);
 
   entry->status = check_link_status(message, in_if);
 
@@ -552,7 +552,7 @@ update_link_entry(const union olsr_ip_addr *local,
 
   /* L_time = max(L_time, L_ASYM_time) */
   if (entry->link_timer && (entry->link_timer->timer_clock < entry->ASYM_time)) {
-    olsr_set_link_timer(entry, olsr_timer_getRelative(entry->ASYM_time));
+    olsr_set_link_timer(entry, olsr_clock_getRelative(entry->ASYM_time));
   }
 
   /* Update neighbor */
index b078425..ad9e472 100644 (file)
@@ -107,7 +107,7 @@ pkt_get_s32(const uint8_t ** p, int32_t * var)
 static INLINE void
 pkt_get_reltime(const uint8_t ** p, uint32_t * var)
 {
-  *var = me_to_reltime(**p);
+  *var = olsr_clock_decode_olsrv1(**p);
   *p += sizeof(uint8_t);
 }
 static INLINE void
@@ -203,7 +203,7 @@ pkt_put_s32(uint8_t ** p, int32_t var)
 static INLINE void
 pkt_put_reltime(uint8_t ** p, uint32_t var)
 {
-  **p = reltime_to_me(var);
+  **p = olsr_clock_encode_olsrv1(var);
   *p += sizeof(uint8_t);
 }
 static INLINE void
index 5f719f4..d2b9a56 100644 (file)
@@ -239,7 +239,7 @@ olsr_calculate_willingness(void)
     olsr_cnf->willingness = (ainfo.battery_percentage / 26);
   }
   OLSR_INFO(LOG_MAIN, "Willingness set to %d - next update in %s secs\n",
-      olsr_cnf->willingness, olsr_milli_to_txt(&tbuf, olsr_cnf->will_int));
+      olsr_cnf->willingness, olsr_clock_to_string(&tbuf, olsr_cnf->will_int));
 }
 
 /**
index bcdcc47..7c51a93 100644 (file)
@@ -502,10 +502,10 @@ parse_cfg_interface(char *argstr, struct olsr_config *rcfg, char *rmsg)
             new_if->cnf->ipv6_multi_glbl = ipaddr;
             PARSER_DEBUG_PRINTF("\tIPv6 global multicast: %s\n", ip6_to_string(&buf, &new_if->cnf->ipv6_multi_glbl.v6));
           } else if (0 == strcasecmp("HelloInterval", p_next[0])) {
-            new_if->cnf->hello_params.emission_interval = olsr_txt_to_milli(p_next[1]);
+            new_if->cnf->hello_params.emission_interval = olsr_clock_parse_string(p_next[1]);
             PARSER_DEBUG_PRINTF("\tHELLO interval1: %u ms\n", new_if->cnf->hello_params.emission_interval);
           } else if (0 == strcasecmp("HelloValidityTime", p_next[0])) {
-            new_if->cnf->hello_params.validity_time = olsr_txt_to_milli(p_next[1]);
+            new_if->cnf->hello_params.validity_time = olsr_clock_parse_string(p_next[1]);
             PARSER_DEBUG_PRINTF("\tHELLO validity: %u ms\n", new_if->cnf->hello_params.validity_time);
           } else if ((0 == strcasecmp("Tcinterval", p_next[0])) || (0 == strcasecmp("TcValidityTime", p_next[0])) ||
                      (0 == strcasecmp("Midinterval", p_next[0])) || (0 == strcasecmp("MidValidityTime", p_next[0])) ||
@@ -840,17 +840,17 @@ parse_cfg_option(const int optint, char *argstr, const int line, struct olsr_con
       struct millitxt_buf tbuf;
 #endif
 
-      rcfg->lq_nat_thresh = olsr_txt_to_milli(argstr);
-      PARSER_DEBUG_PRINTF("NAT threshold %s\n", olsr_milli_to_txt(&tbuf, rcfg->lq_nat_thresh));
+      rcfg->lq_nat_thresh = olsr_clock_parse_string(argstr);
+      PARSER_DEBUG_PRINTF("NAT threshold %s\n", olsr_clock_to_string(&tbuf, rcfg->lq_nat_thresh));
     }
     break;
   case 'Y':                    /* NicChgsPollInt (f) */
-    rcfg->nic_chgs_pollrate = olsr_txt_to_milli(argstr);
+    rcfg->nic_chgs_pollrate = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("NIC Changes Pollrate %u ms\n", rcfg->nic_chgs_pollrate);
     break;
   case 'T':                    /* Pollrate (f) */
     {
-      rcfg->pollrate = olsr_txt_to_milli(argstr);
+      rcfg->pollrate = olsr_clock_parse_string(argstr);
       PARSER_DEBUG_PRINTF("Pollrate %u ms\n", rcfg->pollrate);
     }
     break;
@@ -991,27 +991,27 @@ parse_cfg_option(const int optint, char *argstr, const int line, struct olsr_con
     }
     break;
   case CFG_HNA_HTIME:
-    rcfg->hna_params.emission_interval = olsr_txt_to_milli(argstr);
+    rcfg->hna_params.emission_interval = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("HNA interval1: %u ms\n", rcfg->hna_params.emission_interval);
     break;
   case CFG_HNA_VTIME:
-    rcfg->hna_params.validity_time = olsr_txt_to_milli(argstr);
+    rcfg->hna_params.validity_time = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("HNA validity: %u ms\n", rcfg->hna_params.validity_time);
     break;
   case CFG_MID_HTIME:
-    rcfg->mid_params.emission_interval = olsr_txt_to_milli(argstr);
+    rcfg->mid_params.emission_interval = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("MID interval1: %u ms\n", rcfg->mid_params.emission_interval);
     break;
   case CFG_MID_VTIME:
-    rcfg->mid_params.validity_time = olsr_txt_to_milli(argstr);
+    rcfg->mid_params.validity_time = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("MID validity: %u ms\n", rcfg->mid_params.validity_time);
     break;
   case CFG_TC_HTIME:
-    rcfg->tc_params.emission_interval = olsr_txt_to_milli(argstr);
+    rcfg->tc_params.emission_interval = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("TC interval1: %u ms\n", rcfg->tc_params.emission_interval);
     break;
   case CFG_TC_VTIME:
-    rcfg->tc_params.validity_time = olsr_txt_to_milli(argstr);
+    rcfg->tc_params.validity_time = olsr_clock_parse_string(argstr);
     PARSER_DEBUG_PRINTF("TC validity: %u ms\n", rcfg->tc_params.validity_time);
     break;
 
@@ -1368,7 +1368,7 @@ olsr_sanity_check_cfg(struct olsr_config *cfg)
 
   /* NAT threshold value */
   if (cfg->lq_nat_thresh < 100 || cfg->lq_nat_thresh > 1000) {
-    fprintf(stderr, "NAT threshold %s is not allowed\n", olsr_milli_to_txt(&tbuf, cfg->lq_nat_thresh));
+    fprintf(stderr, "NAT threshold %s is not allowed\n", olsr_clock_to_string(&tbuf, cfg->lq_nat_thresh));
     return -1;
   }
 
index 23b2d72..600993b 100644 (file)
@@ -53,9 +53,9 @@ append_reltime(struct autobuf *abuf, const char *name, uint32_t val, uint32_t de
   struct millitxt_buf buf;
 
   if (val != deflt) {
-    abuf_appendf(abuf, "    %s\t%s\n", name, olsr_milli_to_txt(&buf, val));
+    abuf_appendf(abuf, "    %s\t%s\n", name, olsr_clock_to_string(&buf, val));
   } else if (first) {
-    abuf_appendf(abuf, "    #%s\t%s\n", name, olsr_milli_to_txt(&buf, val));
+    abuf_appendf(abuf, "    #%s\t%s\n", name, olsr_clock_to_string(&buf, val));
   }
 }
 
@@ -119,12 +119,12 @@ olsr_write_cnf_buf(struct autobuf *abuf, struct olsr_config *cnf, bool write_mor
   /* Pollrate */
   abuf_appendf(abuf, "# Polling rate in seconds(float).\n"
                "# Auto uses default value 0.05 sec\n" "Pollrate\t%s\n",
-               olsr_milli_to_txt(&tbuf, cnf->pollrate));
+               olsr_clock_to_string(&tbuf, cnf->pollrate));
 
   /* NIC Changes Pollrate */
   abuf_appendf(abuf, "# Interval to poll network interfaces for configuration\n"
                "# changes. Defaults to 2.5 seconds\n" "NicChgsPollInt\t%s\n",
-               olsr_milli_to_txt(&tbuf, cnf->nic_chgs_pollrate));
+               olsr_clock_to_string(&tbuf, cnf->nic_chgs_pollrate));
 
   /* TC redundancy */
   abuf_appendf(abuf, "# TC redundancy\n"
@@ -144,7 +144,7 @@ olsr_write_cnf_buf(struct autobuf *abuf, struct olsr_config *cnf, bool write_mor
   abuf_appendf(abuf, "# Fish Eye algorithm\n"
                "# 0 = do not use fish eye\n" "# 1 = use fish eye\n" "LinkQualityFishEye\t%d\n\n", cnf->lq_fish);
 
-  abuf_appendf(abuf, "# NAT threshold\n" "NatThreshold\t%s\n\n", olsr_milli_to_txt(&tbuf, cnf->lq_nat_thresh));
+  abuf_appendf(abuf, "# NAT threshold\n" "NatThreshold\t%s\n\n", olsr_clock_to_string(&tbuf, cnf->lq_nat_thresh));
 
   abuf_appendf(abuf, "# Clear screen when printing debug output?\n" "ClearScreen\t%s\n\n", cnf->clear_screen ? "yes" : "no");
 
index 172a84b..8353673 100644 (file)
@@ -52,6 +52,9 @@ static uint32_t now_times;             /* relative time compared to startup (in
 static struct timeval first_tv;        /* timevalue during startup */
 static struct timeval last_tv;         /* timevalue used for last olsr_times() calculation */
 
+/**
+ * Initialize olsr clock system
+ */
 void
 olsr_clock_init(void) {
   /* Grab initial timestamp */
@@ -60,14 +63,14 @@ olsr_clock_init(void) {
     olsr_exit(1);
   }
   last_tv = first_tv;
-  olsr_timer_updateClock();
+  olsr_clock_update();
 }
 
 /**
  * Update the internal clock to current system time
  */
 void
-olsr_timer_updateClock(void)
+olsr_clock_update(void)
 {
   struct timeval tv;
   uint32_t t;
@@ -106,7 +109,7 @@ olsr_timer_updateClock(void)
  * @return current time
  */
 uint32_t
-olsr_timer_getNow(void) {
+olsr_clock_getNow(void) {
   return now_times;
 }
 
@@ -117,7 +120,7 @@ olsr_timer_getNow(void) {
  *   happened.
  */
 int32_t
-olsr_timer_getRelative(uint32_t absolute)
+olsr_clock_getRelative(uint32_t absolute)
 {
   uint32_t diff;
   if (absolute > now_times) {
@@ -144,7 +147,7 @@ olsr_timer_getRelative(uint32_t absolute)
  * @return true if the event already happened, false otherwise
  */
 bool
-olsr_timer_isTimedOut(uint32_t absolute)
+olsr_clock_isPast(uint32_t absolute)
 {
   if (absolute > now_times) {
     return absolute - now_times > (1u << 31);
@@ -168,7 +171,7 @@ olsr_timer_isTimedOut(uint32_t absolute)
  *@return a 8-bit mantissa/exponent product
  */
 uint8_t
-reltime_to_me(const uint32_t interval)
+olsr_clock_encode_olsrv1(const uint32_t interval)
 {
   uint8_t a = 0, b = 0;                /* Underflow defaults */
 
@@ -238,7 +241,7 @@ reltime_to_me(const uint32_t interval)
  *           = ((16 + a) * 1000) >> (8-b)
  */
 uint32_t
-me_to_reltime(const uint8_t me)
+olsr_clock_decode_olsrv1(const uint8_t me)
 {
   const uint8_t a = me >> 4;
   const uint8_t b = me & 0x0F;
@@ -246,7 +249,7 @@ me_to_reltime(const uint8_t me)
   if (b >= 8) {
     return ((16 + a) << (b - 8)) * 1000;
   }
-  assert(me == reltime_to_me(((16 + a) * 1000) >> (8 - b)));
+  assert(me == olsr_clock_encode_olsrv1(((16 + a) * 1000) >> (8 - b)));
   return ((16 + a) * 1000) >> (8 - b);
 }
 
@@ -255,7 +258,7 @@ me_to_reltime(const uint8_t me)
  * (divided by 1000)
  */
 char *
-olsr_milli_to_txt(struct millitxt_buf *buffer, uint32_t t) {
+olsr_clock_to_string(struct millitxt_buf *buffer, uint32_t t) {
   sprintf(buffer->buf, "%u.%03u", t/1000, t%1000);
   return buffer->buf;
 }
@@ -264,7 +267,7 @@ olsr_milli_to_txt(struct millitxt_buf *buffer, uint32_t t) {
  * converts a floating point text into a unsigned integer representation
  * (multiplied by 1000)
  */
-uint32_t olsr_txt_to_milli(char *txt) {
+uint32_t olsr_clock_parse_string(char *txt) {
   uint32_t t = 0;
   int fractionDigits = 0;
   bool frac = false;
index 49345ea..4c14a39 100644 (file)
@@ -40,8 +40,8 @@
  */
 
 
-#ifndef _OLSR_MANTISSA
-#define _OLSR_MANTISSA
+#ifndef _OLSR_CLOCK
+#define _OLSR_CLOCK
 
 #include "defs.h"
 #include "olsr_types.h"
@@ -57,11 +57,11 @@ struct millitxt_buf {
 };
 
 void olsr_clock_init(void);
-void olsr_timer_updateClock(void);
+void olsr_clock_update(void);
 
-int32_t EXPORT(olsr_timer_getRelative) (uint32_t absolute);
-bool EXPORT(olsr_timer_isTimedOut) (uint32_t s);
-uint32_t EXPORT(olsr_timer_getNow)(void);
+int32_t EXPORT(olsr_clock_getRelative) (uint32_t absolute);
+bool EXPORT(olsr_clock_isPast) (uint32_t s);
+uint32_t EXPORT(olsr_clock_getNow)(void);
 
 /**
  * Returns a timestamp s seconds in the future
@@ -69,17 +69,16 @@ uint32_t EXPORT(olsr_timer_getNow)(void);
  * @return absolute time when event will happen
  */
 static inline uint32_t
-olsr_timer_getAbsolute(uint32_t relative)
+olsr_clock_getAbsolute(uint32_t relative)
 {
-  return olsr_timer_getNow() + relative;
+  return olsr_clock_getNow() + relative;
 }
 
-uint32_t EXPORT(me_to_reltime) (const uint8_t);
-uint8_t EXPORT(reltime_to_me) (const uint32_t);
-
-char *EXPORT(olsr_milli_to_txt)(struct millitxt_buf *buffer, uint32_t t);
-uint32_t EXPORT(olsr_txt_to_milli)(char *txt);
+uint32_t EXPORT(olsr_clock_decode_olsrv1) (const uint8_t);
+uint8_t EXPORT(olsr_clock_encode_olsrv1) (const uint32_t);
 
+char *EXPORT(olsr_clock_to_string)(struct millitxt_buf *buffer, uint32_t t);
+uint32_t EXPORT(olsr_clock_parse_string)(char *txt);
 
 #endif
 
index 8d056e1..30d3c7e 100644 (file)
@@ -148,9 +148,9 @@ handle_sockets(uint32_t next_interval)
   int32_t remaining;
 
   /* Update time since this is much used by the parsing functions */
-  olsr_timer_updateClock();
+  olsr_clock_update();
 
-  remaining = olsr_timer_getRelative(next_interval);
+  remaining = olsr_clock_getRelative(next_interval);
   if (remaining <= 0) {
     /* we are already over the interval */
     if (list_is_empty(&socket_head)) {
@@ -211,7 +211,7 @@ handle_sockets(uint32_t next_interval)
     }
 
     /* Update time since this is much used by the parsing functions */
-    olsr_timer_updateClock();
+    olsr_clock_update();
     OLSR_FOR_ALL_SOCKETS(entry, iterator) {
       int flags;
       if (entry->process == NULL) {
@@ -230,7 +230,7 @@ handle_sockets(uint32_t next_interval)
     }
 
     /* calculate the next timeout */
-    remaining = olsr_timer_getRelative(next_interval);
+    remaining = olsr_clock_getRelative(next_interval);
     if (remaining <= 0) {
       /* we are already over the interval */
       break;
index a785370..e54779b 100644 (file)
@@ -50,7 +50,7 @@ olsr_timer_init(void)
   /*
    * Reset the last timer run.
    */
-  timer_last_run = olsr_timer_getNow();
+  timer_last_run = olsr_clock_getNow();
 
   /* Allocate a cookie for the block based memory manager. */
   timer_mem_cookie = olsr_memcookie_add("timer_entry", sizeof(struct olsr_timer_entry));
@@ -130,8 +130,8 @@ olsr_timer_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.
      */
-    olsr_timer_updateClock();
-    next_interval = olsr_timer_getAbsolute(olsr_cnf->pollrate);
+    olsr_clock_update();
+    next_interval = olsr_clock_getAbsolute(olsr_cnf->pollrate);
 
     /* Process timers */
     walk_timers(&timer_last_run);
@@ -361,7 +361,7 @@ calc_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val)
    * Also protect against overflows resulting from > 25 bit timers.
    */
   if (jitter_pct == 0 || jitter_pct > 99 || rel_time > (1 << 24)) {
-    return olsr_timer_getAbsolute(rel_time);
+    return olsr_clock_getAbsolute(rel_time);
   }
 
   /*
@@ -372,7 +372,7 @@ calc_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val)
 
   OLSR_DEBUG(LOG_TIMER, "TIMER: jitter %u%% rel_time %ums to %ums\n", jitter_pct, rel_time, rel_time - jitter_time);
 
-  return olsr_timer_getAbsolute(rel_time - jitter_time);
+  return olsr_clock_getAbsolute(rel_time - jitter_time);
 }
 
 /**
@@ -390,7 +390,7 @@ walk_timers(uint32_t * last_run)
    * or check *all* the wheel slots, whatever is less work.
    * The latter is meant as a safety belt if the scheduler falls behind.
    */
-  while ((*last_run <= olsr_timer_getNow()) && (wheel_slot_walks < TIMER_WHEEL_SLOTS)) {
+  while ((*last_run <= olsr_clock_getNow()) && (wheel_slot_walks < TIMER_WHEEL_SLOTS)) {
     struct list_entity tmp_head_node;
     /* keep some statistics */
     unsigned int timers_walked = 0, timers_fired = 0;
@@ -420,7 +420,7 @@ walk_timers(uint32_t * last_run)
       timers_walked++;
 
       /* Ready to fire ? */
-      if (olsr_timer_isTimedOut(timer->timer_clock)) {
+      if (olsr_clock_isPast(timer->timer_clock)) {
 #if !defined(REMOVE_LOG_DEBUG)
   struct timeval_buf timebuf;
 #endif
@@ -482,7 +482,7 @@ walk_timers(uint32_t * last_run)
    * If the scheduler has slipped and we have walked all wheel slots,
    * reset the last timer run.
    */
-  *last_run = olsr_timer_getNow();
+  *last_run = olsr_clock_getNow();
 }
 
 /**
index 8090599..dfb12f4 100644 (file)
@@ -657,7 +657,7 @@ olsr_print_tc_table(void)
     char *vtime = NONE;
 
     if (tc->validity_timer) {
-      olsr_milli_to_txt(&tbuf, olsr_timer_getRelative(tc->validity_timer->timer_clock));
+      olsr_clock_to_string(&tbuf, olsr_clock_getRelative(tc->validity_timer->timer_clock));
       vtime = tbuf.buf;
     }