Print for duplicate table implemented
authorHenning Rogge <rogge@fgan.de>
Tue, 20 May 2008 12:49:22 +0000 (14:49 +0200)
committerHenning Rogge <rogge@fgan.de>
Tue, 20 May 2008 12:49:22 +0000 (14:49 +0200)
Cleanup timer for duplicate table

src/common/avl.h
src/duplicate_set.c
src/duplicate_set.h

index 1d1b294..f71058d 100644 (file)
@@ -43,6 +43,8 @@
 #ifndef _AVL_H
 #define _AVL_H
 
+#include <stddef.h>
+
 /* must be declared here because of circular dependency through "defs.h" */
 
 #define INLINE inline __attribute__((always_inline))
index d0cf130..388cb80 100644 (file)
 #include "common/avl.h"
 #include "olsr.h"
 #include "mid_set.h"
+#include "scheduler.h"
+#include "mantissa.h"
+
+static void olsr_cleanup_duplicate_entry(void *unused);
 
 struct avl_tree duplicate_set;
+struct timer_entry *duplicate_cleanup_timer;
+
 
 void olsr_init_duplicate_set(void) {
   avl_init(&duplicate_set, olsr_cnf->ip_version == AF_INET ? &avl_comp_ipv4 : &avl_comp_ipv6);
+  
+  olsr_set_timer(&duplicate_cleanup_timer, DUPLICATE_CLEANUP_INTERVAL,
+     DUPLICATE_CLEANUP_JITTER, OLSR_TIMER_PERIODIC,
+     &olsr_cleanup_duplicate_entry, NULL, 0);
 }
 
-struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr) {
-  struct duplicate_entry *entry;
-  entry = olsr_malloc(sizeof(struct duplicate_entry), "New duplicate entry");
+struct dup_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr) {
+  struct dup_entry *entry;
+  entry = olsr_malloc(sizeof(struct dup_entry), "New duplicate entry");
   if (entry != NULL) {
     memcpy (&entry->ip, ip, olsr_cnf->ip_version == AF_INET ? sizeof(entry->ip.v4) : sizeof(entry->ip.v6)); 
     entry->seqnr = seqnr;
@@ -67,10 +77,23 @@ struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr)
   return entry;
 }
 
+static void olsr_cleanup_duplicate_entry(void __attribute__ ((unused)) *unused) {
+  struct dup_entry *entry;
+  
+  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+    if (TIMED_OUT(entry->valid_until)) {
+      avl_delete(&duplicate_set, &entry->avl);
+      free (entry);
+    }
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+}
+
 int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
-  struct duplicate_entry *entry;
+  struct dup_entry *entry;
   int diff;
   void *mainIp;
+  clock_t valid_until;
+  
 #ifndef NODEBUG
   struct ipaddr_str buf;
 #endif  
@@ -80,17 +103,25 @@ int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
     mainIp = ip;
   }
   
-  entry = (struct duplicate_entry *)avl_find(&duplicate_set, ip);
+  valid_until = GET_TIMESTAMP(DUPLICATE_VTIME);
+  
+  entry = (struct dup_entry *)avl_find(&duplicate_set, ip);
   if (entry == NULL) {
     entry = olsr_create_duplicate_entry(ip, seqnr);
     if (entry != NULL) {
       avl_insert(&duplicate_set, &entry->avl, 0);
+      entry->valid_until = valid_until;
     }
     return 1; // okay, we process this package
   }
 
   diff = (int)seqnr - (int)(entry->seqnr);
   
+  // update timestamp
+  if (valid_until > entry->valid_until) {
+    entry->valid_until = valid_until;
+  }
+  
   // overflow ?
   if (diff > (1<<15)) {
     diff -= (1<<16);
@@ -135,5 +166,22 @@ int olsr_shall_process_message(void *ip, olsr_u16_t seqnr) {
 }
 
 void olsr_print_duplicate_table(void) {
-  /* XXX FIXME */
+#ifndef NODEBUG
+  /* The whole function makes no sense without it. */
+  struct dup_entry *entry;
+  const int ipwidth = olsr_cnf->ip_version == AF_INET ? 15 : 30;
+  struct ipaddr_str addrbuf;
+  
+  OLSR_PRINTF(1,
+        "\n--- %s ------------------------------------------------- DUPLICATE SET\n\n"
+        "%-*s %8s %s\n", olsr_wallclock_string(), ipwidth,
+        "Node IP", "DupArray", "VTime");
+
+  OLSR_FOR_ALL_DUP_ENTRIES(entry) {
+    OLSR_PRINTF(1, "%-*s %08x %s\n",
+        ipwidth, olsr_ip_to_string(&addrbuf, (union olsr_ip_addr *)(entry->avl.key)),
+        entry->array,
+        olsr_clock_string(entry->valid_until));
+  } OLSR_FOR_ALL_DUP_ENTRIES_END(entry);
+#endif
 }
index f1745b7..8833e5b 100644 (file)
 #ifndef DUPLICATE_SET_2_H_
 #define DUPLICATE_SET_2_H_
 
-#include "common/avl.h"
+#include "defs.h"
 #include "olsr.h"
+#include "mantissa.h"
+#include "common/avl.h"
+
+#define DUPLICATE_CLEANUP_INTERVAL 15000
+#define DUPLICATE_CLEANUP_JITTER 25
+#define DUPLICATE_VTIME 120000
 
-struct duplicate_entry {
+struct dup_entry {
   struct avl_node avl;
   union olsr_ip_addr ip;
   olsr_u16_t seqnr;
   olsr_u16_t too_low_counter;
   olsr_u32_t array;
+  clock_t    valid_until;
 };
 
+AVLNODE2STRUCT(duptree2dupentry, struct dup_entry , avl);
+
 void olsr_init_duplicate_set(void);
-struct duplicate_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr);
+struct dup_entry *olsr_create_duplicate_entry(void *ip, olsr_u16_t seqnr);
 int olsr_shall_process_message(void *ip, olsr_u16_t seqnr);
 void olsr_print_duplicate_table(void);
 
+#define OLSR_FOR_ALL_DUP_ENTRIES(dup) \
+{ \
+  struct avl_node *dup_tree_node, *next_dup_tree_node; \
+  for (dup_tree_node = avl_walk_first(&duplicate_set); \
+    dup_tree_node; dup_tree_node = next_dup_tree_node) { \
+    next_dup_tree_node = avl_walk_next(dup_tree_node); \
+    dup = duptree2dupentry(dup_tree_node);
+#define OLSR_FOR_ALL_DUP_ENTRIES_END(dup) }}
+
 #endif /*DUPLICATE_SET_2_H_*/
 
 /*