Automated merge with http://gredler.at/hg/olsrd-linkset-refactoring
authorHannes Gredler <hannes@gredler.at>
Tue, 29 Apr 2008 06:46:24 +0000 (08:46 +0200)
committerHannes Gredler <hannes@gredler.at>
Tue, 29 Apr 2008 06:46:24 +0000 (08:46 +0200)
1  2 
src/lq_plugin.c
src/lq_plugin.h
src/olsr.c
src/tc_set.c
src/tc_set.h

diff --cc src/lq_plugin.c
Simple merge
diff --cc src/lq_plugin.h
Simple merge
diff --cc src/olsr.c
Simple merge
diff --cc src/tc_set.c
@@@ -512,33 -452,90 +511,31 @@@ olsr_delete_tc_edge_entry(struct tc_edg
      tc_edge_inv->edge_inv = NULL;
    }
  
 -  /*
 -   * Delete the tc_entry if the last edge and last prefix is gone.
 -   */
 -  if (!tc_edge->tc->edge_tree.count &&
 -      !tc_edge->tc->prefix_tree.count) {
 -
 -    /*
 -     * Only remove remote tc entries.
 -     */
 -    if (tc_edge->tc != tc_myself) {
 -      olsr_delete_tc_entry(tc_edge->tc);
 -    }
 -  }
 -
 -  free(tc_edge);
 +  olsr_cookie_free(tc_edge_mem_cookie, tc_edge);
  }
  
  /**
   * Delete all destinations that have a lower ANSN.
   *
   * @param tc the entry to delete edges from
-- * @param ansn the advertised neighbor set sequence number
-- * @return 1 if any destinations were deleted 0 if not
++ * @return TRUE if any destinations were deleted, FALSE if not
   */
- olsr_bool
+ static int
 -olsr_delete_outdated_tc_edges(struct tc_entry *tc, olsr_u16_t ansn,
 -                              union olsr_ip_addr *lower_border,
 -                              union olsr_ip_addr *upper_border)
 +olsr_delete_outdated_tc_edges(struct tc_entry *tc)
  {
    struct tc_edge_entry *tc_edge;
 -  int retval = 0;
 +  olsr_bool retval = OLSR_FALSE;
  
  #if 0
 -  OLSR_PRINTF(5, "TC: deleting MPRS\n");
 +  OLSR_PRINTF(5, "TC: deleting outdated TC-edge entries\n");
  #endif
  
 -  int mode = 0; // too low ?
 -
 -  if (lower_border == NULL && upper_border == NULL) {
 -    mode = 3;
 -  }
    OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
 -    switch (mode) {
 -      case 0: // too low
 -        if (avl_comp_default(lower_border, &tc_edge->T_dest_addr) <= 0) {
 -          mode = 1;
 -        }
 -        break;
 -      case 1: // lower <= ip < upper
 -        if (avl_comp_default(upper_border, &tc_edge->T_dest_addr) <= 0) {
 -          mode = 2;
 -        }
 -        break;
 -      case 2:
 -        // too high
 -        break;
 -      case 3:
 -        // fallback
 -        break;
 -    }
 -
 -    if (SEQNO_GREATER_THAN(ansn, tc_edge->T_seq)) {
 -      if (mode == 1) {
 -        olsr_delete_tc_edge_entry(tc_edge);
 -        retval = 1;
 -      }
 -
 -      /*
 -       * Do not delete the edge now, just mark the edge as down.
 -       * Downed edges will be ignored by the SPF computation.
 -       * It could be that a TC message spans across multiple packets,
 -       * which causes an edge delete followed by an edge add.
 -       * If the edge gets refreshed in subsequent packets then we have
 -       * avoided a two edge transistion.
 -       * If the edge really went away then after the garbage collection
 -       * timer has expired olsr_time_out_tc_set() will do the needful.
 -       */
 -      if (mode == 3) {
 -        tc_edge->flags |= OLSR_TC_EDGE_DOWN;
 -        olsr_set_tc_edge_timer(tc_edge, OLSR_TC_EDGE_GC_TIME);
 -        retval = 1;
 -      }
 +    if (SEQNO_GREATER_THAN(tc->ansn, tc_edge->ansn)) {
 +      olsr_delete_tc_edge_entry(tc_edge);
 +      retval = OLSR_TRUE;
      }
 -  }OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
 +  } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
  
    return retval;
  }
   * @return 1 if entries are added 0 if not
   */
  static int
 -olsr_tc_update_edge(struct tc_entry *tc, unsigned int vtime_s, olsr_u16_t ansn,
 +olsr_tc_update_edge(struct tc_entry *tc, olsr_u16_t ansn,
-                     const unsigned char **curr)
+                     const unsigned char **curr, union olsr_ip_addr *neighbor)
  {
    struct tc_edge_entry *tc_edge;
-   union olsr_ip_addr neighbor;
    int edge_change;
  
    edge_change = 0;
        return 0;
      }
  
-     tc_edge = olsr_add_tc_edge_entry(tc, &neighbor, ansn);
 -    tc_edge = olsr_add_tc_edge_entry(tc, neighbor, ansn, vtime_s);
 -
++    tc_edge = olsr_add_tc_edge_entry(tc, neighbor, ansn);
 +    
      olsr_deserialize_tc_lq_pair(curr, tc_edge);
      edge_change = 1;
  
@@@ -662,15 -663,16 +658,15 @@@ olsr_print_tc_table(void
      OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
        struct ipaddr_str addrbuf, dstaddrbuf;
        struct lqtextbuffer lqbuffer1, lqbuffer2;
 -
 -      if ((tc_edge->flags & OLSR_TC_EDGE_DOWN) == 0) {
 -        OLSR_PRINTF(1, "%-*s %-*s %-14s  %s\n",
 -            ipwidth, olsr_ip_to_string(&addrbuf, &tc->addr),
 -            ipwidth, olsr_ip_to_string(&dstaddrbuf, &tc_edge->T_dest_addr),
 -            get_tc_edge_entry_text(tc_edge, &lqbuffer1),
 -            get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
 -      }
 -    }OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
 -  }OLSR_FOR_ALL_TC_ENTRIES_END(tc);
 +      
-       OLSR_PRINTF(1, "%-*s %-*s  (%-10s) %s\n",
++      OLSR_PRINTF(1, "%-*s %-*s %-14s %s\n",
 +                  ipwidth, olsr_ip_to_string(&addrbuf, &tc->addr),
 +                  ipwidth, olsr_ip_to_string(&dstaddrbuf, &tc_edge->T_dest_addr),
 +                  get_tc_edge_entry_text(tc_edge, &lqbuffer1),
 +                  get_linkcost_text(tc_edge->cost, OLSR_FALSE, &lqbuffer2));
 +      
 +    } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
 +  } OLSR_FOR_ALL_TC_ENTRIES_END(tc);
  #endif
  }
  
@@@ -722,18 -725,16 +721,21 @@@ olsr_input_tc(union olsr_message *msg
    pkt_get_u8(&curr, &msg_hops);
    pkt_get_u16(&curr, &msg_seq);
    pkt_get_u16(&curr, &ansn);
-   pkt_ignore_u16(&curr);
+   /* get borders */
+   pkt_get_u8(&curr, &lower_border);
+   pkt_get_u8(&curr, &upper_border);
  
    tc = olsr_lookup_tc_entry(&originator);
-   
    if (tc && 0 != tc->edge_tree.count) {
 -    if (olsr_seq_inrange_high( (int)tc->msg_seq - TC_SEQNO_WINDOW, tc->msg_seq, msg_seq) && olsr_seq_inrange_high(
 -        (int)tc->ansn - TC_ANSN_WINDOW, tc->ansn, ansn)) {
 +    if (olsr_seq_inrange_high(
 +          (int)tc->msg_seq - TC_SEQNO_WINDOW,
 +          tc->msg_seq,
 +          msg_seq) &&
 +        olsr_seq_inrange_high(
 +          (int)tc->ansn - TC_ANSN_WINDOW,
 +          tc->ansn, ansn)) {
  
        /*
         * Ignore already seen seq/ansn values (small window for mesh memory)
  
    /*
     * Now walk the edge advertisements contained in the packet.
 -   * Play some efficiency games here, like checking first
 -   * if the edge exists in order to avoid address validation.
     */
    limit = (unsigned char *)msg + size;
+   borderSet = 0;
    while (curr < limit) {
-     if (olsr_tc_update_edge(tc, ansn, &curr)) {
 -    if (olsr_tc_update_edge(tc, vtime_s, ansn, &curr, &upper_border_ip)) {
++    if (olsr_tc_update_edge(tc, ansn, &curr, &upper_border_ip)) {
        changes_topology = OLSR_TRUE;
      }
+     if (!borderSet) {
+       borderSet = 1;
+       memcpy(&lower_border_ip, &upper_border_ip, sizeof(lower_border_ip));
+     }
+   }
+   // calculate real border ips
+   if (lower_border == 0 && upper_border == 0) {
+     borderSet = 0;
+   } else if (borderSet) {
+     if (lower_border == 0xff) {
+       memset(&lower_border_ip, 0, sizeof(lower_border_ip));
+     } else {
+       int i;
+       lower_border--;
+       for (i=0; i<lower_border/8; i++) {
+         lower_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - i - 1] = 0;
+       }
+       lower_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border/8 - 1] &= (0xff << (lower_border & 7));
+       lower_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - lower_border/8 - 1] |= (1 << (lower_border & 7));
+     }
+     if (upper_border == 0xff) {
+       memset(&upper_border_ip, 0xff, sizeof(upper_border_ip));
+     } else {
+       int i;
+       upper_border--;
+       for (i=0; i<upper_border/8; i++) {
+         upper_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - i - 1] = 0;
+       }
+       upper_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border/8 - 1] &= (0xff << (upper_border & 7));
+       upper_border_ip.v6.in6_u.u6_addr8[olsr_cnf->ipsize - upper_border/8 - 1] |= (1 << (upper_border & 7));
+     }
    }
  
    /*
diff --cc src/tc_set.h
Simple merge