| /* |
| * Copyright (C) 2003 Yasuhiro Ohara |
| * |
| * This file is part of GNU Zebra. |
| * |
| * GNU Zebra is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2, or (at your option) any |
| * later version. |
| * |
| * GNU Zebra is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with GNU Zebra; see the file COPYING. If not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| * Boston, MA 02111-1307, USA. |
| */ |
| |
| #include <zebra.h> |
| |
| #include "log.h" |
| #include "memory.h" |
| #include "prefix.h" |
| #include "table.h" |
| #include "vty.h" |
| #include "command.h" |
| #include "linklist.h" |
| |
| #include "ospf6_proto.h" |
| #include "ospf6_lsa.h" |
| #include "ospf6_lsdb.h" |
| #include "ospf6_route.h" |
| #include "ospf6_top.h" |
| #include "ospf6_area.h" |
| #include "ospf6_interface.h" |
| #include "ospf6d.h" |
| |
| unsigned char conf_debug_ospf6_route = 0; |
| |
| static char * |
| ospf6_route_table_name (struct ospf6_route_table *table) |
| { |
| static char name[32]; |
| switch (table->scope_type) |
| { |
| case OSPF6_SCOPE_TYPE_GLOBAL: |
| { |
| switch (table->table_type) |
| { |
| case OSPF6_TABLE_TYPE_ROUTES: |
| snprintf (name, sizeof (name), "global route table"); |
| break; |
| case OSPF6_TABLE_TYPE_BORDER_ROUTERS: |
| snprintf (name, sizeof (name), "global brouter table"); |
| break; |
| case OSPF6_TABLE_TYPE_EXTERNAL_ROUTES: |
| snprintf (name, sizeof (name), "global external table"); |
| break; |
| default: |
| snprintf (name, sizeof (name), "global unknown table"); |
| break; |
| } |
| } |
| break; |
| |
| case OSPF6_SCOPE_TYPE_AREA: |
| { |
| struct ospf6_area *oa = (struct ospf6_area *) table->scope; |
| switch (table->table_type) |
| { |
| case OSPF6_TABLE_TYPE_SPF_RESULTS: |
| snprintf (name, sizeof (name), |
| "area %s spf table", oa->name); |
| break; |
| case OSPF6_TABLE_TYPE_ROUTES: |
| snprintf (name, sizeof (name), |
| "area %s route table", oa->name); |
| break; |
| case OSPF6_TABLE_TYPE_PREFIX_RANGES: |
| snprintf (name, sizeof (name), |
| "area %s range table", oa->name); |
| break; |
| case OSPF6_TABLE_TYPE_SUMMARY_PREFIXES: |
| snprintf (name, sizeof (name), |
| "area %s summary prefix table", oa->name); |
| break; |
| case OSPF6_TABLE_TYPE_SUMMARY_ROUTERS: |
| snprintf (name, sizeof (name), |
| "area %s summary router table", oa->name); |
| break; |
| default: |
| snprintf (name, sizeof (name), |
| "area %s unknown table", oa->name); |
| break; |
| } |
| } |
| break; |
| |
| case OSPF6_SCOPE_TYPE_INTERFACE: |
| { |
| struct ospf6_interface *oi = (struct ospf6_interface *) table->scope; |
| switch (table->table_type) |
| { |
| case OSPF6_TABLE_TYPE_CONNECTED_ROUTES: |
| snprintf (name, sizeof (name), "interface %s connected table", |
| oi->interface->name); |
| break; |
| default: |
| snprintf (name, sizeof (name), "interface %s unknown table", |
| oi->interface->name); |
| break; |
| } |
| } |
| break; |
| |
| default: |
| { |
| switch (table->table_type) |
| { |
| case OSPF6_TABLE_TYPE_SPF_RESULTS: |
| snprintf (name, sizeof (name), "temporary spf table"); |
| break; |
| default: |
| snprintf (name, sizeof (name), "temporary unknown table"); |
| break; |
| } |
| } |
| break; |
| } |
| return name; |
| } |
| |
| void |
| ospf6_linkstate_prefix (u_int32_t adv_router, u_int32_t id, |
| struct prefix *prefix) |
| { |
| memset (prefix, 0, sizeof (struct prefix)); |
| prefix->family = AF_INET6; |
| prefix->prefixlen = 64; |
| memcpy (&prefix->u.prefix6.s6_addr[0], &adv_router, 4); |
| memcpy (&prefix->u.prefix6.s6_addr[4], &id, 4); |
| } |
| |
| void |
| ospf6_linkstate_prefix2str (struct prefix *prefix, char *buf, int size) |
| { |
| u_int32_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); |
| inet_ntop (AF_INET, &adv_router, adv_router_str, sizeof (adv_router_str)); |
| inet_ntop (AF_INET, &id, id_str, sizeof (id_str)); |
| if (ntohl (id)) |
| snprintf (buf, size, "%s Net-ID: %s", adv_router_str, id_str); |
| else |
| snprintf (buf, size, "%s", adv_router_str); |
| } |
| |
| /* Global strings for logging */ |
| const char *ospf6_dest_type_str[OSPF6_DEST_TYPE_MAX] = |
| { "Unknown", "Router", "Network", "Discard", "Linkstate", "AddressRange", }; |
| |
| const char *ospf6_dest_type_substr[OSPF6_DEST_TYPE_MAX] = |
| { "?", "R", "N", "D", "L", "A", }; |
| |
| const char *ospf6_path_type_str[OSPF6_PATH_TYPE_MAX] = |
| { "Unknown", "Intra-Area", "Inter-Area", "External-1", "External-2", }; |
| |
| const char *ospf6_path_type_substr[OSPF6_PATH_TYPE_MAX] = |
| { "??", "IA", "IE", "E1", "E2", }; |
| |
| |
| struct ospf6_route * |
| ospf6_route_create (void) |
| { |
| struct ospf6_route *route; |
| route = XCALLOC (MTYPE_OSPF6_ROUTE, sizeof (struct ospf6_route)); |
| return route; |
| } |
| |
| void |
| ospf6_route_delete (struct ospf6_route *route) |
| { |
| XFREE (MTYPE_OSPF6_ROUTE, route); |
| } |
| |
| struct ospf6_route * |
| ospf6_route_copy (struct ospf6_route *route) |
| { |
| struct ospf6_route *new; |
| |
| new = ospf6_route_create (); |
| memcpy (new, route, sizeof (struct ospf6_route)); |
| new->rnode = NULL; |
| new->prev = NULL; |
| new->next = NULL; |
| new->table = NULL; |
| new->lock = 0; |
| return new; |
| } |
| |
| void |
| ospf6_route_lock (struct ospf6_route *route) |
| { |
| route->lock++; |
| } |
| |
| void |
| ospf6_route_unlock (struct ospf6_route *route) |
| { |
| assert (route->lock > 0); |
| route->lock--; |
| if (route->lock == 0) |
| { |
| /* Can't detach from the table until here |
| because ospf6_route_next () will use |
| the 'route->table' pointer for logging */ |
| route->table = NULL; |
| ospf6_route_delete (route); |
| } |
| } |
| |
| /* Route compare function. If ra is more preferred, it returns |
| less than 0. If rb is more preferred returns greater than 0. |
| Otherwise (neither one is preferred), returns 0 */ |
| static int |
| ospf6_route_cmp (struct ospf6_route *ra, struct ospf6_route *rb) |
| { |
| assert (ospf6_route_is_same (ra, rb)); |
| assert (OSPF6_PATH_TYPE_NONE < ra->path.type && |
| ra->path.type < OSPF6_PATH_TYPE_MAX); |
| assert (OSPF6_PATH_TYPE_NONE < rb->path.type && |
| rb->path.type < OSPF6_PATH_TYPE_MAX); |
| |
| 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.cost_e2 != rb->path.cost_e2) |
| return (ra->path.cost_e2 - rb->path.cost_e2); |
| } |
| else |
| { |
| if (ra->path.cost != rb->path.cost) |
| return (ra->path.cost - rb->path.cost); |
| } |
| |
| return 0; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_lookup (struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct route_node *node; |
| struct ospf6_route *route; |
| |
| node = route_node_lookup (table->table, prefix); |
| if (node == NULL) |
| return NULL; |
| |
| route = (struct ospf6_route *) node->info; |
| return route; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_lookup_identical (struct ospf6_route *route, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *target; |
| |
| for (target = ospf6_route_lookup (&route->prefix, table); |
| target; target = target->next) |
| { |
| if (ospf6_route_is_identical (target, route)) |
| return target; |
| } |
| return NULL; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_lookup_bestmatch (struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct route_node *node; |
| struct ospf6_route *route; |
| |
| node = route_node_match (table->table, prefix); |
| if (node == NULL) |
| return NULL; |
| route_unlock_node (node); |
| |
| route = (struct ospf6_route *) node->info; |
| return route; |
| } |
| |
| #ifdef DEBUG |
| static void |
| route_table_assert (struct ospf6_route_table *table) |
| { |
| struct ospf6_route *prev, *r, *next; |
| char buf[64]; |
| unsigned int link_error = 0, num = 0; |
| |
| r = ospf6_route_head (table); |
| prev = NULL; |
| while (r) |
| { |
| if (r->prev != prev) |
| link_error++; |
| |
| next = ospf6_route_next (r); |
| |
| if (r->next != next) |
| link_error++; |
| |
| prev = r; |
| r = next; |
| } |
| |
| for (r = ospf6_route_head (table); r; r = ospf6_route_next (r)) |
| num++; |
| |
| if (link_error == 0 && num == table->count) |
| return; |
| |
| zlog_err ("PANIC !!"); |
| zlog_err ("Something has gone wrong with ospf6_route_table[%p]", table); |
| zlog_debug ("table count = %d, real number = %d", table->count, num); |
| zlog_debug ("DUMP START"); |
| for (r = ospf6_route_head (table); r; r = ospf6_route_next (r)) |
| { |
| prefix2str (&r->prefix, buf, sizeof (buf)); |
| zlog_info ("%p<-[%p]->%p : %s", r->prev, r, r->next, buf); |
| } |
| zlog_debug ("DUMP END"); |
| |
| assert (link_error == 0 && num == table->count); |
| } |
| #define ospf6_route_table_assert(t) (route_table_assert (t)) |
| #else |
| #define ospf6_route_table_assert(t) ((void) 0) |
| #endif /*DEBUG*/ |
| |
| struct ospf6_route * |
| ospf6_route_add (struct ospf6_route *route, |
| struct ospf6_route_table *table) |
| { |
| struct route_node *node, *nextnode, *prevnode; |
| struct ospf6_route *current = NULL; |
| struct ospf6_route *prev = NULL, *old = NULL, *next = NULL; |
| char buf[64]; |
| struct timeval now; |
| |
| assert (route->rnode == NULL); |
| assert (route->lock == 0); |
| assert (route->next == NULL); |
| assert (route->prev == NULL); |
| |
| if (route->type == OSPF6_DEST_TYPE_LINKSTATE) |
| ospf6_linkstate_prefix2str (&route->prefix, buf, sizeof (buf)); |
| else |
| prefix2str (&route->prefix, buf, sizeof (buf)); |
| |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_debug ("%s %p: route add %p: %s", ospf6_route_table_name (table), |
| (void *)table, (void *)route, buf); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route add: %s", ospf6_route_table_name (table), buf); |
| |
| quagga_gettime (QUAGGA_CLK_MONOTONIC, &now); |
| |
| node = route_node_get (table->table, &route->prefix); |
| route->rnode = node; |
| |
| /* find place to insert */ |
| for (current = node->info; current; current = current->next) |
| { |
| if (! ospf6_route_is_same (current, route)) |
| next = current; |
| else if (current->type != route->type) |
| prev = current; |
| else if (ospf6_route_is_same_origin (current, route)) |
| old = current; |
| else if (ospf6_route_cmp (current, route) > 0) |
| next = current; |
| else |
| prev = current; |
| |
| if (old || next) |
| break; |
| } |
| |
| if (old) |
| { |
| /* if route does not actually change, return unchanged */ |
| if (ospf6_route_is_identical (old, route)) |
| { |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_debug ("%s %p: route add %p: needless update of %p", |
| ospf6_route_table_name (table), |
| (void *)table, (void *)route, (void *)old); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route add: needless update", |
| ospf6_route_table_name (table)); |
| |
| ospf6_route_delete (route); |
| SET_FLAG (old->flag, OSPF6_ROUTE_ADD); |
| ospf6_route_table_assert (table); |
| |
| 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); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route add: update", |
| ospf6_route_table_name (table)); |
| |
| /* replace old one if exists */ |
| if (node->info == old) |
| { |
| node->info = route; |
| SET_FLAG (route->flag, OSPF6_ROUTE_BEST); |
| } |
| |
| if (old->prev) |
| old->prev->next = route; |
| route->prev = old->prev; |
| if (old->next) |
| old->next->prev = route; |
| route->next = old->next; |
| |
| route->installed = old->installed; |
| route->changed = now; |
| assert (route->table == NULL); |
| route->table = table; |
| |
| ospf6_route_unlock (old); /* will be deleted later */ |
| ospf6_route_lock (route); |
| |
| SET_FLAG (route->flag, OSPF6_ROUTE_CHANGE); |
| ospf6_route_table_assert (table); |
| |
| if (table->hook_add) |
| (*table->hook_add) (route); |
| |
| return route; |
| } |
| |
| /* insert if previous or next node found */ |
| if (prev || next) |
| { |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_debug ("%s %p: route add %p: another path: prev %p, next %p", |
| ospf6_route_table_name (table), |
| (void *)table, (void *)route, (void *)prev, (void *)next); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route add: another path found", |
| ospf6_route_table_name (table)); |
| |
| if (prev == NULL) |
| prev = next->prev; |
| if (next == NULL) |
| next = prev->next; |
| |
| if (prev) |
| prev->next = route; |
| route->prev = prev; |
| if (next) |
| next->prev = route; |
| route->next = next; |
| |
| if (node->info == next) |
| { |
| assert (next->rnode == node); |
| node->info = route; |
| UNSET_FLAG (next->flag, OSPF6_ROUTE_BEST); |
| SET_FLAG (route->flag, OSPF6_ROUTE_BEST); |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_info ("%s %p: route add %p: replacing previous best: %p", |
| ospf6_route_table_name (table), |
| (void *)table, (void *)route, (void *)next); |
| } |
| |
| route->installed = now; |
| route->changed = now; |
| assert (route->table == NULL); |
| route->table = table; |
| |
| ospf6_route_lock (route); |
| table->count++; |
| ospf6_route_table_assert (table); |
| |
| SET_FLAG (route->flag, OSPF6_ROUTE_ADD); |
| if (table->hook_add) |
| (*table->hook_add) (route); |
| |
| return route; |
| } |
| |
| /* 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", |
| ospf6_route_table_name (table), (void *)table, (void *)route); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route add: brand new route", |
| ospf6_route_table_name (table)); |
| |
| assert (node->info == NULL); |
| node->info = route; |
| SET_FLAG (route->flag, OSPF6_ROUTE_BEST); |
| ospf6_route_lock (route); |
| route->installed = now; |
| route->changed = now; |
| assert (route->table == NULL); |
| route->table = table; |
| |
| /* lookup real existing next route */ |
| nextnode = node; |
| route_lock_node (nextnode); |
| do { |
| nextnode = route_next (nextnode); |
| } while (nextnode && nextnode->info == NULL); |
| |
| /* set next link */ |
| if (nextnode == NULL) |
| route->next = NULL; |
| else |
| { |
| route_unlock_node (nextnode); |
| |
| next = nextnode->info; |
| route->next = next; |
| next->prev = route; |
| } |
| |
| /* lookup real existing prev route */ |
| prevnode = node; |
| route_lock_node (prevnode); |
| do { |
| prevnode = route_prev (prevnode); |
| } while (prevnode && prevnode->info == NULL); |
| |
| /* set prev link */ |
| if (prevnode == NULL) |
| route->prev = NULL; |
| else |
| { |
| route_unlock_node (prevnode); |
| |
| prev = prevnode->info; |
| while (prev->next && ospf6_route_is_same (prev, prev->next)) |
| prev = prev->next; |
| route->prev = prev; |
| prev->next = route; |
| } |
| |
| table->count++; |
| ospf6_route_table_assert (table); |
| |
| SET_FLAG (route->flag, OSPF6_ROUTE_ADD); |
| if (table->hook_add) |
| (*table->hook_add) (route); |
| |
| return route; |
| } |
| |
| void |
| ospf6_route_remove (struct ospf6_route *route, |
| struct ospf6_route_table *table) |
| { |
| struct route_node *node; |
| struct ospf6_route *current; |
| char buf[64]; |
| |
| if (route->type == OSPF6_DEST_TYPE_LINKSTATE) |
| ospf6_linkstate_prefix2str (&route->prefix, buf, sizeof (buf)); |
| else |
| prefix2str (&route->prefix, buf, sizeof (buf)); |
| |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_debug ("%s %p: route remove %p: %s", |
| ospf6_route_table_name (table), |
| (void *)table, (void *)route, buf); |
| else if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| zlog_debug ("%s: route remove: %s", ospf6_route_table_name (table), buf); |
| |
| node = route_node_lookup (table->table, &route->prefix); |
| assert (node); |
| |
| /* 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; |
| current = current->next; |
| } |
| assert (current == route); |
| |
| /* adjust doubly linked list */ |
| if (route->prev) |
| route->prev->next = route->next; |
| if (route->next) |
| route->next->prev = route->prev; |
| |
| if (node->info == route) |
| { |
| if (route->next && ospf6_route_is_same (route->next, route)) |
| { |
| node->info = route->next; |
| SET_FLAG (route->next->flag, OSPF6_ROUTE_BEST); |
| } |
| else |
| node->info = NULL; /* should unlock route_node here ? */ |
| } |
| |
| table->count--; |
| ospf6_route_table_assert (table); |
| |
| SET_FLAG (route->flag, OSPF6_ROUTE_WAS_REMOVED); |
| |
| if (table->hook_remove) |
| (*table->hook_remove) (route); |
| |
| ospf6_route_unlock (route); |
| } |
| |
| struct ospf6_route * |
| ospf6_route_head (struct ospf6_route_table *table) |
| { |
| struct route_node *node; |
| struct ospf6_route *route; |
| |
| node = route_top (table->table); |
| if (node == NULL) |
| return NULL; |
| |
| /* skip to the real existing entry */ |
| while (node && node->info == NULL) |
| node = route_next (node); |
| if (node == NULL) |
| return NULL; |
| |
| route_unlock_node (node); |
| assert (node->info); |
| |
| route = (struct ospf6_route *) node->info; |
| assert (route->prev == NULL); |
| assert (route->table == table); |
| ospf6_route_lock (route); |
| |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_info ("%s %p: route head: %p<-[%p]->%p", |
| ospf6_route_table_name (table), (void *)table, |
| (void *)route->prev, (void *)route, (void *)route->next); |
| |
| return route; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_next (struct ospf6_route *route) |
| { |
| struct ospf6_route *next = route->next; |
| |
| if (IS_OSPF6_DEBUG_ROUTE (MEMORY)) |
| zlog_info ("%s %p: route next: %p<-[%p]->%p", |
| ospf6_route_table_name (route->table), (void *)route->table, |
| (void *)route->prev, (void *)route, (void *)route->next); |
| |
| ospf6_route_unlock (route); |
| if (next) |
| ospf6_route_lock (next); |
| |
| return next; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_best_next (struct ospf6_route *route) |
| { |
| struct route_node *rnode; |
| struct ospf6_route *next; |
| |
| ospf6_route_unlock (route); |
| |
| rnode = route->rnode; |
| route_lock_node (rnode); |
| rnode = route_next (rnode); |
| while (rnode && rnode->info == NULL) |
| rnode = route_next (rnode); |
| if (rnode == NULL) |
| return NULL; |
| route_unlock_node (rnode); |
| |
| assert (rnode->info); |
| next = (struct ospf6_route *) rnode->info; |
| ospf6_route_lock (next); |
| return next; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_match_head (struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct route_node *node; |
| struct ospf6_route *route; |
| |
| /* Walk down tree. */ |
| node = table->table->top; |
| while (node && node->p.prefixlen < prefix->prefixlen && |
| prefix_match (&node->p, prefix)) |
| node = node->link[prefix_bit(&prefix->u.prefix, node->p.prefixlen)]; |
| |
| if (node) |
| route_lock_node (node); |
| while (node && node->info == NULL) |
| node = route_next (node); |
| if (node == NULL) |
| return NULL; |
| route_unlock_node (node); |
| |
| if (! prefix_match (prefix, &node->p)) |
| return NULL; |
| |
| route = node->info; |
| ospf6_route_lock (route); |
| return route; |
| } |
| |
| struct ospf6_route * |
| ospf6_route_match_next (struct prefix *prefix, |
| struct ospf6_route *route) |
| { |
| struct ospf6_route *next; |
| |
| next = ospf6_route_next (route); |
| if (next && ! prefix_match (prefix, &next->prefix)) |
| { |
| ospf6_route_unlock (next); |
| next = NULL; |
| } |
| |
| return next; |
| } |
| |
| void |
| ospf6_route_remove_all (struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| for (route = ospf6_route_head (table); route; |
| route = ospf6_route_next (route)) |
| ospf6_route_remove (route, table); |
| } |
| |
| struct ospf6_route_table * |
| ospf6_route_table_create (int s, int t) |
| { |
| struct ospf6_route_table *new; |
| new = XCALLOC (MTYPE_OSPF6_ROUTE, sizeof (struct ospf6_route_table)); |
| new->table = route_table_init (); |
| new->scope_type = s; |
| new->table_type = t; |
| return new; |
| } |
| |
| void |
| ospf6_route_table_delete (struct ospf6_route_table *table) |
| { |
| ospf6_route_remove_all (table); |
| route_table_finish (table->table); |
| XFREE (MTYPE_OSPF6_ROUTE, table); |
| } |
| |
| |
| /* VTY commands */ |
| void |
| ospf6_route_show (struct vty *vty, struct ospf6_route *route) |
| { |
| int i; |
| char destination[64], nexthop[64]; |
| char duration[16], ifname[IFNAMSIZ]; |
| struct timeval now, res; |
| |
| quagga_gettime (QUAGGA_CLK_MONOTONIC, &now); |
| timersub (&now, &route->changed, &res); |
| timerstring (&res, duration, sizeof (duration)); |
| |
| /* destination */ |
| if (route->type == OSPF6_DEST_TYPE_LINKSTATE) |
| ospf6_linkstate_prefix2str (&route->prefix, destination, |
| sizeof (destination)); |
| else if (route->type == OSPF6_DEST_TYPE_ROUTER) |
| inet_ntop (route->prefix.family, &route->prefix.u.prefix, |
| destination, sizeof (destination)); |
| else |
| prefix2str (&route->prefix, destination, sizeof (destination)); |
| |
| /* nexthop */ |
| inet_ntop (AF_INET6, &route->nexthop[0].address, nexthop, |
| sizeof (nexthop)); |
| if (! if_indextoname (route->nexthop[0].ifindex, ifname)) |
| snprintf (ifname, sizeof (ifname), "%d", route->nexthop[0].ifindex); |
| |
| vty_out (vty, "%c%1s %2s %-30s %-25s %6.*s %s%s", |
| (ospf6_route_is_best (route) ? '*' : ' '), |
| OSPF6_DEST_TYPE_SUBSTR (route->type), |
| OSPF6_PATH_TYPE_SUBSTR (route->path.type), |
| destination, nexthop, IFNAMSIZ, ifname, duration, VNL); |
| |
| for (i = 1; ospf6_nexthop_is_set (&route->nexthop[i]) && |
| i < OSPF6_MULTI_PATH_LIMIT; i++) |
| { |
| /* nexthop */ |
| inet_ntop (AF_INET6, &route->nexthop[i].address, nexthop, |
| sizeof (nexthop)); |
| if (! if_indextoname (route->nexthop[i].ifindex, ifname)) |
| snprintf (ifname, sizeof (ifname), "%d", route->nexthop[i].ifindex); |
| |
| vty_out (vty, "%c%1s %2s %-30s %-25s %6.*s %s%s", |
| ' ', "", "", "", nexthop, IFNAMSIZ, ifname, "", VNL); |
| } |
| } |
| |
| void |
| ospf6_route_show_detail (struct vty *vty, struct ospf6_route *route) |
| { |
| char destination[64], nexthop[64], ifname[IFNAMSIZ]; |
| char area_id[16], id[16], adv_router[16], capa[16], options[16]; |
| struct timeval now, res; |
| char duration[16]; |
| int i; |
| |
| quagga_gettime (QUAGGA_CLK_MONOTONIC, &now); |
| |
| /* destination */ |
| if (route->type == OSPF6_DEST_TYPE_LINKSTATE) |
| ospf6_linkstate_prefix2str (&route->prefix, destination, |
| sizeof (destination)); |
| else if (route->type == OSPF6_DEST_TYPE_ROUTER) |
| inet_ntop (route->prefix.family, &route->prefix.u.prefix, |
| destination, sizeof (destination)); |
| else |
| prefix2str (&route->prefix, destination, sizeof (destination)); |
| vty_out (vty, "Destination: %s%s", destination, VNL); |
| |
| /* destination type */ |
| vty_out (vty, "Destination type: %s%s", |
| OSPF6_DEST_TYPE_NAME (route->type), |
| VNL); |
| |
| /* Time */ |
| timersub (&now, &route->installed, &res); |
| timerstring (&res, duration, sizeof (duration)); |
| vty_out (vty, "Installed Time: %s ago%s", duration, VNL); |
| |
| timersub (&now, &route->changed, &res); |
| timerstring (&res, duration, sizeof (duration)); |
| vty_out (vty, " Changed Time: %s ago%s", duration, VNL); |
| |
| /* Debugging info */ |
| vty_out (vty, "Lock: %d Flags: %s%s%s%s%s", route->lock, |
| (CHECK_FLAG (route->flag, OSPF6_ROUTE_BEST) ? "B" : "-"), |
| (CHECK_FLAG (route->flag, OSPF6_ROUTE_ADD) ? "A" : "-"), |
| (CHECK_FLAG (route->flag, OSPF6_ROUTE_REMOVE) ? "R" : "-"), |
| (CHECK_FLAG (route->flag, OSPF6_ROUTE_CHANGE) ? "C" : "-"), |
| VNL); |
| vty_out (vty, "Memory: prev: %p this: %p next: %p%s", |
| (void *)route->prev, (void *)route, (void *)route->next, VNL); |
| |
| /* Path section */ |
| |
| /* Area-ID */ |
| inet_ntop (AF_INET, &route->path.area_id, area_id, sizeof (area_id)); |
| vty_out (vty, "Associated Area: %s%s", area_id, VNL); |
| |
| /* Path type */ |
| vty_out (vty, "Path Type: %s%s", |
| OSPF6_PATH_TYPE_NAME (route->path.type), VNL); |
| |
| /* LS Origin */ |
| inet_ntop (AF_INET, &route->path.origin.id, id, sizeof (id)); |
| inet_ntop (AF_INET, &route->path.origin.adv_router, adv_router, |
| sizeof (adv_router)); |
| vty_out (vty, "LS Origin: %s Id: %s Adv: %s%s", |
| ospf6_lstype_name (route->path.origin.type), |
| id, adv_router, VNL); |
| |
| /* Options */ |
| ospf6_options_printbuf (route->path.options, options, sizeof (options)); |
| vty_out (vty, "Options: %s%s", options, VNL); |
| |
| /* Router Bits */ |
| ospf6_capability_printbuf (route->path.router_bits, capa, sizeof (capa)); |
| vty_out (vty, "Router Bits: %s%s", capa, VNL); |
| |
| /* Prefix Options */ |
| vty_out (vty, "Prefix Options: xxx%s", VNL); |
| |
| /* Metrics */ |
| vty_out (vty, "Metric Type: %d%s", route->path.metric_type, |
| VNL); |
| vty_out (vty, "Metric: %d (%d)%s", |
| route->path.cost, route->path.cost_e2, VNL); |
| |
| /* Nexthops */ |
| vty_out (vty, "Nexthop:%s", VNL); |
| for (i = 0; ospf6_nexthop_is_set (&route->nexthop[i]) && |
| i < OSPF6_MULTI_PATH_LIMIT; i++) |
| { |
| /* nexthop */ |
| inet_ntop (AF_INET6, &route->nexthop[i].address, nexthop, |
| sizeof (nexthop)); |
| if (! if_indextoname (route->nexthop[i].ifindex, ifname)) |
| snprintf (ifname, sizeof (ifname), "%d", route->nexthop[i].ifindex); |
| vty_out (vty, " %s %.*s%s", nexthop, IFNAMSIZ, ifname, VNL); |
| } |
| vty_out (vty, "%s", VNL); |
| } |
| |
| static void |
| ospf6_route_show_table_summary (struct vty *vty, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route, *prev = NULL; |
| int i, pathtype[OSPF6_PATH_TYPE_MAX]; |
| unsigned int number = 0; |
| int nhinval = 0, ecmp = 0; |
| int alternative = 0, destination = 0; |
| |
| for (i = 0; i < OSPF6_PATH_TYPE_MAX; i++) |
| pathtype[i] = 0; |
| |
| for (route = ospf6_route_head (table); route; |
| route = ospf6_route_next (route)) |
| { |
| if (prev == NULL || ! ospf6_route_is_same (prev, route)) |
| destination++; |
| else |
| alternative++; |
| if (! ospf6_nexthop_is_set (&route->nexthop[0])) |
| nhinval++; |
| else if (ospf6_nexthop_is_set (&route->nexthop[1])) |
| ecmp++; |
| pathtype[route->path.type]++; |
| number++; |
| |
| prev = route; |
| } |
| |
| assert (number == table->count); |
| |
| vty_out (vty, "Number of OSPFv3 routes: %d%s", number, VNL); |
| vty_out (vty, "Number of Destination: %d%s", destination, VNL); |
| vty_out (vty, "Number of Alternative routes: %d%s", alternative, VNL); |
| vty_out (vty, "Number of Equal Cost Multi Path: %d%s", ecmp, VNL); |
| for (i = OSPF6_PATH_TYPE_INTRA; i <= OSPF6_PATH_TYPE_EXTERNAL2; i++) |
| { |
| vty_out (vty, "Number of %s routes: %d%s", |
| OSPF6_PATH_TYPE_NAME (i), pathtype[i], VNL); |
| } |
| } |
| |
| static void |
| ospf6_route_show_table_prefix (struct vty *vty, |
| struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| route = ospf6_route_lookup (prefix, table); |
| if (route == NULL) |
| return; |
| |
| ospf6_route_lock (route); |
| while (route && ospf6_route_is_prefix (prefix, route)) |
| { |
| /* Specifying a prefix will always display details */ |
| ospf6_route_show_detail (vty, route); |
| route = ospf6_route_next (route); |
| } |
| if (route) |
| ospf6_route_unlock (route); |
| } |
| |
| static void |
| ospf6_route_show_table_address (struct vty *vty, |
| struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| route = ospf6_route_lookup_bestmatch (prefix, table); |
| if (route == NULL) |
| return; |
| |
| prefix = &route->prefix; |
| ospf6_route_lock (route); |
| while (route && ospf6_route_is_prefix (prefix, route)) |
| { |
| /* Specifying a prefix will always display details */ |
| ospf6_route_show_detail (vty, route); |
| route = ospf6_route_next (route); |
| } |
| if (route) |
| ospf6_route_unlock (route); |
| } |
| |
| static void |
| ospf6_route_show_table_match (struct vty *vty, int detail, |
| struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| assert (prefix->family); |
| |
| route = ospf6_route_match_head (prefix, table); |
| while (route) |
| { |
| if (detail) |
| ospf6_route_show_detail (vty, route); |
| else |
| ospf6_route_show (vty, route); |
| route = ospf6_route_match_next (prefix, route); |
| } |
| } |
| |
| static void |
| ospf6_route_show_table_type (struct vty *vty, int detail, u_char type, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| route = ospf6_route_head (table); |
| while (route) |
| { |
| if (route->path.type == type) |
| { |
| if (detail) |
| ospf6_route_show_detail (vty, route); |
| else |
| ospf6_route_show (vty, route); |
| } |
| route = ospf6_route_next (route); |
| } |
| } |
| |
| static void |
| ospf6_route_show_table (struct vty *vty, int detail, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| route = ospf6_route_head (table); |
| while (route) |
| { |
| if (detail) |
| ospf6_route_show_detail (vty, route); |
| else |
| ospf6_route_show (vty, route); |
| route = ospf6_route_next (route); |
| } |
| } |
| |
| int |
| ospf6_route_table_show (struct vty *vty, int argc, const char *argv[], |
| struct ospf6_route_table *table) |
| { |
| int summary = 0; |
| int match = 0; |
| int detail = 0; |
| int slash = 0; |
| int isprefix = 0; |
| int i, ret; |
| struct prefix prefix; |
| u_char type = 0; |
| |
| memset (&prefix, 0, sizeof (struct prefix)); |
| |
| for (i = 0; i < argc; i++) |
| { |
| if (! strcmp (argv[i], "summary")) |
| { |
| summary++; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "intra-area")) |
| { |
| type = OSPF6_PATH_TYPE_INTRA; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "inter-area")) |
| { |
| type = OSPF6_PATH_TYPE_INTER; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "external-1")) |
| { |
| type = OSPF6_PATH_TYPE_EXTERNAL1; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "external-2")) |
| { |
| type = OSPF6_PATH_TYPE_EXTERNAL2; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "detail")) |
| { |
| detail++; |
| continue; |
| } |
| |
| if (! strcmp (argv[i], "match")) |
| { |
| match++; |
| continue; |
| } |
| |
| ret = str2prefix (argv[i], &prefix); |
| if (ret == 1 && prefix.family == AF_INET6) |
| { |
| isprefix++; |
| if (strchr (argv[i], '/')) |
| slash++; |
| continue; |
| } |
| |
| vty_out (vty, "Malformed argument: %s%s", argv[i], VNL); |
| return CMD_SUCCESS; |
| } |
| |
| /* Give summary of this route table */ |
| if (summary) |
| { |
| ospf6_route_show_table_summary (vty, table); |
| return CMD_SUCCESS; |
| } |
| |
| /* Give exact prefix-match route */ |
| if (isprefix && ! match) |
| { |
| /* If exact address, give best matching route */ |
| if (! slash) |
| ospf6_route_show_table_address (vty, &prefix, table); |
| else |
| ospf6_route_show_table_prefix (vty, &prefix, table); |
| |
| return CMD_SUCCESS; |
| } |
| |
| if (match) |
| ospf6_route_show_table_match (vty, detail, &prefix, table); |
| else if (type) |
| ospf6_route_show_table_type (vty, detail, type, table); |
| else |
| ospf6_route_show_table (vty, detail, table); |
| |
| return CMD_SUCCESS; |
| } |
| |
| static void |
| ospf6_linkstate_show_header (struct vty *vty) |
| { |
| vty_out (vty, "%-7s %-15s %-15s %-8s %-14s %s%s", |
| "Type", "Router-ID", "Net-ID", "Rtr-Bits", "Options", "Cost", VNL); |
| } |
| |
| static void |
| ospf6_linkstate_show (struct vty *vty, struct ospf6_route *route) |
| { |
| u_int32_t router, id; |
| char routername[16], idname[16], rbits[16], options[16]; |
| |
| router = ospf6_linkstate_prefix_adv_router (&route->prefix); |
| inet_ntop (AF_INET, &router, routername, sizeof (routername)); |
| id = ospf6_linkstate_prefix_id (&route->prefix); |
| inet_ntop (AF_INET, &id, idname, sizeof (idname)); |
| |
| ospf6_capability_printbuf (route->path.router_bits, rbits, sizeof (rbits)); |
| ospf6_options_printbuf (route->path.options, options, sizeof (options)); |
| |
| if (ntohl (id)) |
| vty_out (vty, "%-7s %-15s %-15s %-8s %-14s %lu%s", |
| "Network", routername, idname, rbits, options, |
| (unsigned long) route->path.cost, VNL); |
| else |
| vty_out (vty, "%-7s %-15s %-15s %-8s %-14s %lu%s", |
| "Router", routername, idname, rbits, options, |
| (unsigned long) route->path.cost, VNL); |
| } |
| |
| |
| static void |
| ospf6_linkstate_show_table_exact (struct vty *vty, |
| struct prefix *prefix, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| route = ospf6_route_lookup (prefix, table); |
| if (route == NULL) |
| return; |
| |
| ospf6_route_lock (route); |
| while (route && ospf6_route_is_prefix (prefix, route)) |
| { |
| /* Specifying a prefix will always display details */ |
| ospf6_route_show_detail (vty, route); |
| route = ospf6_route_next (route); |
| } |
| if (route) |
| ospf6_route_unlock (route); |
| } |
| |
| static void |
| ospf6_linkstate_show_table (struct vty *vty, int detail, |
| struct ospf6_route_table *table) |
| { |
| struct ospf6_route *route; |
| |
| if (! detail) |
| ospf6_linkstate_show_header (vty); |
| |
| route = ospf6_route_head (table); |
| while (route) |
| { |
| if (detail) |
| ospf6_route_show_detail (vty, route); |
| else |
| ospf6_linkstate_show (vty, route); |
| route = ospf6_route_next (route); |
| } |
| } |
| |
| int |
| ospf6_linkstate_table_show (struct vty *vty, int argc, const char *argv[], |
| struct ospf6_route_table *table) |
| { |
| int detail = 0; |
| int is_id = 0; |
| int is_router = 0; |
| int i, ret; |
| struct prefix router, id, prefix; |
| |
| memset (&router, 0, sizeof (struct prefix)); |
| memset (&id, 0, sizeof (struct prefix)); |
| memset (&prefix, 0, sizeof (struct prefix)); |
| |
| for (i = 0; i < argc; i++) |
| { |
| if (! strcmp (argv[i], "detail")) |
| { |
| detail++; |
| continue; |
| } |
| |
| if (! is_router) |
| { |
| ret = str2prefix (argv[i], &router); |
| if (ret == 1 && router.family == AF_INET) |
| { |
| is_router++; |
| continue; |
| } |
| vty_out (vty, "Malformed argument: %s%s", argv[i], VNL); |
| return CMD_SUCCESS; |
| } |
| |
| if (! is_id) |
| { |
| ret = str2prefix (argv[i], &id); |
| if (ret == 1 && id.family == AF_INET) |
| { |
| is_id++; |
| continue; |
| } |
| vty_out (vty, "Malformed argument: %s%s", argv[i], VNL); |
| return CMD_SUCCESS; |
| } |
| |
| vty_out (vty, "Malformed argument: %s%s", argv[i], VNL); |
| return CMD_SUCCESS; |
| } |
| |
| if (is_router) |
| ospf6_linkstate_prefix (router.u.prefix4.s_addr, |
| id.u.prefix4.s_addr, &prefix); |
| |
| if (prefix.family) |
| ospf6_linkstate_show_table_exact (vty, &prefix, table); |
| else |
| ospf6_linkstate_show_table (vty, detail, table); |
| |
| return CMD_SUCCESS; |
| } |
| |
| |
| void |
| ospf6_brouter_show_header (struct vty *vty) |
| { |
| vty_out (vty, "%-15s %-8s %-14s %-10s %-15s%s", |
| "Router-ID", "Rtr-Bits", "Options", "Path-Type", "Area", VNL); |
| } |
| |
| void |
| ospf6_brouter_show (struct vty *vty, struct ospf6_route *route) |
| { |
| u_int32_t adv_router; |
| char adv[16], rbits[16], options[16], area[16]; |
| |
| adv_router = ospf6_linkstate_prefix_adv_router (&route->prefix); |
| inet_ntop (AF_INET, &adv_router, adv, sizeof (adv)); |
| ospf6_capability_printbuf (route->path.router_bits, rbits, sizeof (rbits)); |
| ospf6_options_printbuf (route->path.options, options, sizeof (options)); |
| inet_ntop (AF_INET, &route->path.area_id, area, sizeof (area)); |
| |
| /* vty_out (vty, "%-15s %-8s %-14s %-10s %-15s%s", |
| "Router-ID", "Rtr-Bits", "Options", "Path-Type", "Area", VNL); */ |
| vty_out (vty, "%-15s %-8s %-14s %-10s %-15s%s", |
| adv, rbits, options, OSPF6_PATH_TYPE_NAME (route->path.type), |
| area, VNL); |
| } |
| |
| DEFUN (debug_ospf6_route, |
| debug_ospf6_route_cmd, |
| "debug ospf6 route (table|intra-area|inter-area|memory)", |
| DEBUG_STR |
| OSPF6_STR |
| "Debug route table calculation\n" |
| "Debug detail\n" |
| "Debug intra-area route calculation\n" |
| "Debug inter-area route calculation\n" |
| "Debug route memory use\n" |
| ) |
| { |
| unsigned char level = 0; |
| |
| if (! strncmp (argv[0], "table", 5)) |
| level = OSPF6_DEBUG_ROUTE_TABLE; |
| else if (! strncmp (argv[0], "intra", 5)) |
| level = OSPF6_DEBUG_ROUTE_INTRA; |
| else if (! strncmp (argv[0], "inter", 5)) |
| level = OSPF6_DEBUG_ROUTE_INTER; |
| else if (! strncmp (argv[0], "memor", 5)) |
| level = OSPF6_DEBUG_ROUTE_MEMORY; |
| OSPF6_DEBUG_ROUTE_ON (level); |
| return CMD_SUCCESS; |
| } |
| |
| DEFUN (no_debug_ospf6_route, |
| no_debug_ospf6_route_cmd, |
| "no debug ospf6 route (table|intra-area|inter-area|memory)", |
| NO_STR |
| DEBUG_STR |
| OSPF6_STR |
| "Debug route table calculation\n" |
| "Debug intra-area route calculation\n" |
| "Debug route memory use\n") |
| { |
| unsigned char level = 0; |
| |
| if (! strncmp (argv[0], "table", 5)) |
| level = OSPF6_DEBUG_ROUTE_TABLE; |
| else if (! strncmp (argv[0], "intra", 5)) |
| level = OSPF6_DEBUG_ROUTE_INTRA; |
| else if (! strncmp (argv[0], "inter", 5)) |
| level = OSPF6_DEBUG_ROUTE_INTER; |
| else if (! strncmp (argv[0], "memor", 5)) |
| level = OSPF6_DEBUG_ROUTE_MEMORY; |
| OSPF6_DEBUG_ROUTE_OFF (level); |
| return CMD_SUCCESS; |
| } |
| |
| int |
| config_write_ospf6_debug_route (struct vty *vty) |
| { |
| if (IS_OSPF6_DEBUG_ROUTE (TABLE)) |
| vty_out (vty, "debug ospf6 route table%s", VNL); |
| if (IS_OSPF6_DEBUG_ROUTE (INTRA)) |
| vty_out (vty, "debug ospf6 route intra-area%s", VNL); |
| if (IS_OSPF6_DEBUG_ROUTE (INTER)) |
| vty_out (vty, "debug ospf6 route inter-area%s", VNL); |
| return 0; |
| } |
| |
| void |
| install_element_ospf6_debug_route (void) |
| { |
| install_element (ENABLE_NODE, &debug_ospf6_route_cmd); |
| install_element (ENABLE_NODE, &no_debug_ospf6_route_cmd); |
| install_element (CONFIG_NODE, &debug_ospf6_route_cmd); |
| install_element (CONFIG_NODE, &no_debug_ospf6_route_cmd); |
| } |
| |
| |
| |