return name;
}
-void ospf6_linkstate_prefix(u_int32_t adv_router, u_int32_t id,
+void ospf6_linkstate_prefix(uint32_t adv_router, uint32_t id,
struct prefix *prefix)
{
memset(prefix, 0, sizeof(struct prefix));
void ospf6_linkstate_prefix2str(struct prefix *prefix, char *buf, int size)
{
- u_int32_t adv_router, id;
+ uint32_t adv_router, id;
char adv_router_str[16], id_str[16];
memcpy(&adv_router, &prefix->u.prefix6.s6_addr[0], 4);
memcpy(&id, &prefix->u.prefix6.s6_addr[4], 4);
XFREE(MTYPE_OSPF6_NEXTHOP, nh);
}
-void ospf6_free_nexthops(struct list *nh_list)
-{
- struct ospf6_nexthop *nh;
- struct listnode *node, *nnode;
-
- if (nh_list) {
- for (ALL_LIST_ELEMENTS(nh_list, node, nnode, nh))
- ospf6_nexthop_delete(nh);
- }
-}
-
void ospf6_clear_nexthops(struct list *nh_list)
{
struct listnode *node;
if (ospf6_nexthop_is_set(nh)) {
nh_new = ospf6_nexthop_create();
ospf6_nexthop_copy(nh_new, nh);
- listnode_add(dst, nh_new);
+ listnode_add_sort(dst, nh_new);
}
}
}
if (!ospf6_route_find_nexthop(dst, nh)) {
nh_new = ospf6_nexthop_create();
ospf6_nexthop_copy(nh_new, nh);
- listnode_add(dst, nh_new);
+ listnode_add_sort(dst, nh_new);
}
}
}
{
struct listnode *anode, *bnode;
struct ospf6_nexthop *anh, *bnh;
+ bool identical = false;
if (a && b) {
if (listcount(a->nh_list) == listcount(b->nh_list)) {
for (ALL_LIST_ELEMENTS_RO(a->nh_list, anode, anh)) {
+ identical = false;
for (ALL_LIST_ELEMENTS_RO(b->nh_list, bnode,
- bnh))
- if (!ospf6_nexthop_is_same(anh, bnh))
- return (1);
+ bnh)) {
+ if (ospf6_nexthop_is_same(anh, bnh))
+ identical = true;
+ }
+ /* Currnet List A element not found List B
+ * Non-Identical lists return */
+ if (identical == false)
+ return 1;
}
- return (0);
+ return 0;
} else
- return (1);
+ return 1;
}
/* One of the routes doesn't exist ? */
return (1);
}
void ospf6_route_zebra_copy_nexthops(struct ospf6_route *route,
- ifindex_t *ifindexes,
- struct in6_addr **nexthop_addr,
+ struct zapi_nexthop nexthops[],
int entries)
{
struct ospf6_nexthop *nh;
zlog_debug(" nexthop: %s%%%.*s(%d)", buf,
IFNAMSIZ, ifname, nh->ifindex);
}
- if (i < entries) {
- nexthop_addr[i] = &nh->address;
- ifindexes[i] = nh->ifindex;
- i++;
- } else {
+ if (i >= entries)
return;
- }
+
+ nexthops[i].vrf_id = VRF_DEFAULT;
+ nexthops[i].ifindex = nh->ifindex;
+ if (!IN6_IS_ADDR_UNSPECIFIED(&nh->address)) {
+ nexthops[i].gate.ipv6 = nh->address;
+ nexthops[i].type = NEXTHOP_TYPE_IPV6_IFINDEX;
+ } else
+ nexthops[i].type = NEXTHOP_TYPE_IFINDEX;
+ i++;
}
}
}
return (-1);
}
+int ospf6_nexthop_cmp(struct ospf6_nexthop *a, struct ospf6_nexthop *b)
+{
+ if (a->ifindex < b->ifindex)
+ return -1;
+ else if (a->ifindex > b->ifindex)
+ return 1;
+ else
+ return memcmp(&a->address, &b->address,
+ sizeof(struct in6_addr));
+
+ return 0;
+}
+
+static int ospf6_path_cmp(struct ospf6_path *a, struct ospf6_path *b)
+{
+ if (a->origin.adv_router < b->origin.adv_router)
+ return -1;
+ else if (a->origin.adv_router > b->origin.adv_router)
+ return 1;
+ else
+ return 0;
+}
+
+void ospf6_path_free(struct ospf6_path *op)
+{
+ if (op->nh_list)
+ list_delete_and_null(&op->nh_list);
+ XFREE(MTYPE_OSPF6_PATH, op);
+}
+
+struct ospf6_path *ospf6_path_dup(struct ospf6_path *path)
+{
+ struct ospf6_path *new;
+
+ new = XCALLOC(MTYPE_OSPF6_PATH, sizeof(struct ospf6_path));
+ memcpy(new, path, sizeof(struct ospf6_path));
+ new->nh_list = list_new();
+ new->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
+ new->nh_list->del = (void (*)(void *))ospf6_nexthop_delete;
+
+ return new;
+}
+
+void ospf6_copy_paths(struct list *dst, struct list *src)
+{
+ struct ospf6_path *path_new, *path;
+ struct listnode *node;
+
+ if (dst && src) {
+ for (ALL_LIST_ELEMENTS_RO(src, node, path)) {
+ path_new = ospf6_path_dup(path);
+ ospf6_copy_nexthops(path_new->nh_list, path->nh_list);
+ listnode_add_sort(dst, path_new);
+ }
+ }
+}
+
struct ospf6_route *ospf6_route_create(void)
{
struct ospf6_route *route;
route = XCALLOC(MTYPE_OSPF6_ROUTE, sizeof(struct ospf6_route));
route->nh_list = list_new();
+ route->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
+ route->nh_list->del = (void (*)(void *))ospf6_nexthop_delete;
+ route->paths = list_new();
+ route->paths->cmp = (int (*)(void *, void *))ospf6_path_cmp;
+ route->paths->del = (void (*)(void *))ospf6_path_free;
return route;
}
void ospf6_route_delete(struct ospf6_route *route)
{
if (route) {
- ospf6_free_nexthops(route->nh_list);
- list_free(route->nh_list);
+ if (route->nh_list)
+ list_delete_and_null(&route->nh_list);
+ if (route->paths)
+ list_delete_and_null(&route->paths);
XFREE(MTYPE_OSPF6_ROUTE, route);
}
}
new->linkstate_id = route->linkstate_id;
new->path = route->path;
ospf6_copy_nexthops(new->nh_list, route->nh_list);
+ ospf6_copy_paths(new->paths, route->paths);
new->rnode = NULL;
new->prev = NULL;
new->next = NULL;
if (ra->type != rb->type)
return (ra->type - rb->type);
- if (ra->path.area_id != rb->path.area_id)
- return (ntohl(ra->path.area_id) - ntohl(rb->path.area_id));
-
if (ra->path.type != rb->path.type)
return (ra->path.type - rb->path.type);
if (ra->path.type == OSPF6_PATH_TYPE_EXTERNAL2) {
if (ra->path.u.cost_e2 != rb->path.u.cost_e2)
return (ra->path.u.cost_e2 - rb->path.u.cost_e2);
+ else
+ return (ra->path.cost - rb->path.cost);
} else {
if (ra->path.cost != rb->path.cost)
return (ra->path.cost - rb->path.cost);
}
+ if (ra->path.area_id != rb->path.area_id)
+ return (ntohl(ra->path.area_id) - ntohl(rb->path.area_id));
+
return 0;
}
return NULL;
route = (struct ospf6_route *)node->info;
+ route_unlock_node(node); /* to free the lookup lock */
return route;
}
for (target = ospf6_route_lookup(&route->prefix, table); target;
target = target->next) {
- if (ospf6_route_is_identical(target, route))
+ if (target->type == route->type
+ && (memcmp(&target->prefix, &route->prefix,
+ sizeof(struct prefix))
+ == 0)
+ && target->path.type == route->path.type
+ && target->path.cost == route->path.cost
+ && target->path.u.cost_e2 == route->path.u.cost_e2
+ && ospf6_route_cmp_nexthops(target, route) == 0)
return target;
}
return NULL;
if (ospf6_route_is_identical(old, route)) {
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
zlog_debug(
- "%s %p: route add %p: needless update of %p",
+ "%s %p: route add %p: needless update of %p old cost %u",
ospf6_route_table_name(table),
(void *)table, (void *)route,
- (void *)old);
+ (void *)old, old->path.cost);
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
zlog_debug("%s: route add: needless update",
ospf6_route_table_name(table));
SET_FLAG(old->flag, OSPF6_ROUTE_ADD);
ospf6_route_table_assert(table);
+ /* to free the lookup lock */
+ route_unlock_node(node);
return old;
}
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
- zlog_debug("%s %p: route add %p: update of %p",
- ospf6_route_table_name(table), (void *)table,
- (void *)route, (void *)old);
+ zlog_debug(
+ "%s %p: route add %p cost %u nh %u: update of %p old cost %u nh %u",
+ ospf6_route_table_name(table), (void *)table,
+ (void *)route, route->path.cost,
+ listcount(route->nh_list), (void *)old,
+ old->path.cost, listcount(old->nh_list));
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
zlog_debug("%s: route add: update",
ospf6_route_table_name(table));
if (prev || next) {
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
zlog_debug(
- "%s %p: route add %p: another path: prev %p, next %p",
+ "%s %p: route add %p cost %u: another path: prev %p, next %p node ref %u",
ospf6_route_table_name(table), (void *)table,
- (void *)route, (void *)prev, (void *)next);
+ (void *)route, route->path.cost, (void *)prev,
+ (void *)next, node->lock);
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
- zlog_debug("%s: route add: another path found",
- ospf6_route_table_name(table));
+ zlog_debug("%s: route add cost %u: another path found",
+ ospf6_route_table_name(table),
+ route->path.cost);
if (prev == NULL)
prev = next->prev;
SET_FLAG(route->flag, OSPF6_ROUTE_BEST);
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
zlog_info(
- "%s %p: route add %p: replacing previous best: %p",
+ "%s %p: route add %p cost %u: replacing previous best: %p cost %u",
ospf6_route_table_name(table),
(void *)table, (void *)route,
- (void *)next);
+ route->path.cost,
+ (void *)next, next->path.cost);
}
route->installed = now;
/* Else, this is the brand new route regarding to the prefix */
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
- zlog_debug("%s %p: route add %p: brand new route",
+ zlog_debug("%s %p: route add %p %s cost %u: brand new route",
ospf6_route_table_name(table), (void *)table,
- (void *)route);
+ (void *)route, buf, route->path.cost);
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
zlog_debug("%s: route add: brand new route",
ospf6_route_table_name(table));
prefix2str(&route->prefix, buf, sizeof(buf));
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
- zlog_debug("%s %p: route remove %p: %s",
+ zlog_debug("%s %p: route remove %p: %s cost %u refcount %u",
ospf6_route_table_name(table), (void *)table,
- (void *)route, buf);
+ (void *)route, buf, route->path.cost, route->lock);
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
zlog_debug("%s: route remove: %s",
ospf6_route_table_name(table), buf);
/* find the route to remove, making sure that the route pointer
is from the route table. */
current = node->info;
- while (current && ospf6_route_is_same(current, route)) {
- if (current == route)
- break;
+ while (current && current != route)
current = current->next;
- }
+
assert(current == route);
/* adjust doubly linked list */
if (route->next && route->next->rnode == node) {
node->info = route->next;
SET_FLAG(route->next->flag, OSPF6_ROUTE_BEST);
- } else
- node->info = NULL; /* should unlock route_node here ? */
+ } else {
+ node->info = NULL;
+ route->rnode = NULL;
+ route_unlock_node(node); /* to free the original lock */
+ }
}
+ route_unlock_node(node); /* to free the lookup lock */
table->count--;
ospf6_route_table_assert(table);
SET_FLAG(route->flag, OSPF6_ROUTE_WAS_REMOVED);
+ /* Note hook_remove may call ospf6_route_remove */
if (table->hook_remove)
(*table->hook_remove)(route);
void ospf6_route_table_delete(struct ospf6_route_table *table)
{
ospf6_route_remove_all(table);
+ bf_free(table->idspace);
route_table_finish(table->table);
XFREE(MTYPE_OSPF6_ROUTE, table);
}
vty_out(vty, "Metric: %d (%d)\n", route->path.cost,
route->path.u.cost_e2);
+ vty_out(vty, "Paths count: %u\n", route->paths->count);
+ vty_out(vty, "Nexthop count: %u\n", route->nh_list->count);
/* Nexthops */
vty_out(vty, "Nexthop:\n");
for (ALL_LIST_ELEMENTS_RO(route->nh_list, node, nh)) {
}
static void ospf6_route_show_table_type(struct vty *vty, int detail,
- u_char type,
+ uint8_t type,
struct ospf6_route_table *table)
{
struct ospf6_route *route;
int isprefix = 0;
int i, ret;
struct prefix prefix;
- u_char type = 0;
+ uint8_t type = 0;
memset(&prefix, 0, sizeof(struct prefix));
static void ospf6_linkstate_show(struct vty *vty, struct ospf6_route *route)
{
- u_int32_t router, id;
+ uint32_t router, id;
char routername[16], idname[16], rbits[16], options[16];
router = ospf6_linkstate_prefix_adv_router(&route->prefix);
void ospf6_brouter_show(struct vty *vty, struct ospf6_route *route)
{
- u_int32_t adv_router;
+ uint32_t adv_router;
char adv[16], rbits[16], options[16], area[16];
adv_router = ospf6_linkstate_prefix_adv_router(&route->prefix);
int idx_type = 3;
unsigned char level = 0;
- if (!strncmp(argv[idx_type]->arg, "table", 5))
+ if (!strcmp(argv[idx_type]->text, "table"))
level = OSPF6_DEBUG_ROUTE_TABLE;
- else if (!strncmp(argv[idx_type]->arg, "intra", 5))
+ else if (!strcmp(argv[idx_type]->text, "intra-area"))
level = OSPF6_DEBUG_ROUTE_INTRA;
- else if (!strncmp(argv[idx_type]->arg, "inter", 5))
+ else if (!strcmp(argv[idx_type]->text, "inter-area"))
level = OSPF6_DEBUG_ROUTE_INTER;
- else if (!strncmp(argv[idx_type]->arg, "memor", 5))
+ else if (!strcmp(argv[idx_type]->text, "memory"))
level = OSPF6_DEBUG_ROUTE_MEMORY;
OSPF6_DEBUG_ROUTE_ON(level);
return CMD_SUCCESS;
int idx_type = 4;
unsigned char level = 0;
- if (!strncmp(argv[idx_type]->arg, "table", 5))
+ if (!strcmp(argv[idx_type]->text, "table"))
level = OSPF6_DEBUG_ROUTE_TABLE;
- else if (!strncmp(argv[idx_type]->arg, "intra", 5))
+ else if (!strcmp(argv[idx_type]->text, "intra-area"))
level = OSPF6_DEBUG_ROUTE_INTRA;
- else if (!strncmp(argv[idx_type]->arg, "inter", 5))
+ else if (!strcmp(argv[idx_type]->text, "inter-area"))
level = OSPF6_DEBUG_ROUTE_INTER;
- else if (!strncmp(argv[idx_type]->arg, "memor", 5))
+ else if (!strcmp(argv[idx_type]->text, "memory"))
level = OSPF6_DEBUG_ROUTE_MEMORY;
OSPF6_DEBUG_ROUTE_OFF(level);
return CMD_SUCCESS;
vty_out(vty, "debug ospf6 route intra-area\n");
if (IS_OSPF6_DEBUG_ROUTE(INTER))
vty_out(vty, "debug ospf6 route inter-area\n");
+ if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
+ vty_out(vty, "debug ospf6 route memory\n");
+
return 0;
}