if (community_list_dup_check (list, entry))
community_entry_free (entry);
else
- community_list_entry_add (list, entry);
+ {
+ community_list_entry_add (list, entry);
+ route_map_notify_dependencies(name, RMAP_EVENT_CLIST_ADDED);
+ }
return 0;
}
if (!str)
{
community_list_delete (list);
+ route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
return 0;
}
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
community_list_entry_delete (list, entry, style);
+ route_map_notify_dependencies(name, RMAP_EVENT_CLIST_DELETED);
return 0;
}
if (community_list_dup_check (list, entry))
community_entry_free (entry);
else
- community_list_entry_add (list, entry);
+ {
+ community_list_entry_add (list, entry);
+ route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_ADDED);
+ }
return 0;
}
if (!str)
{
community_list_delete (list);
+ route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
return 0;
}
return COMMUNITY_LIST_ERR_CANT_FIND_LIST;
community_list_entry_delete (list, entry, style);
+ route_map_notify_dependencies(name, RMAP_EVENT_ECLIST_DELETED);
return 0;
}
struct as_list_list str;
/* Hook function which is executed when new access_list is added. */
- void (*add_hook) (void);
+ void (*add_hook) (char *);
/* Hook function which is executed when access_list is deleted. */
- void (*delete_hook) (void);
+ void (*delete_hook) (char *);
};
/* Element of AS path filter. */
else
aslist->head = asfilter;
aslist->tail = asfilter;
+
+ /* Run hook function. */
+ if (as_list_master.add_hook)
+ (*as_list_master.add_hook) (aslist->name);
+
}
/* Lookup as_list from list of as_list by name. */
aslist = as_list_lookup (name);
if (aslist == NULL)
- {
- aslist = as_list_insert (name);
-
- /* Run hook function. */
- if (as_list_master.add_hook)
- (*as_list_master.add_hook) ();
- }
+ aslist = as_list_insert (name);
return aslist;
}
static void
as_list_filter_delete (struct as_list *aslist, struct as_filter *asfilter)
{
+ char *name = strdup (aslist->name);
+
if (asfilter->next)
asfilter->next->prev = asfilter->prev;
else
/* Run hook function. */
if (as_list_master.delete_hook)
- (*as_list_master.delete_hook) ();
+ (*as_list_master.delete_hook) (name);
+ if (name)
+ free(name);
}
static int
/* Add hook function. */
void
-as_list_add_hook (void (*func) (void))
+as_list_add_hook (void (*func) (char *))
{
as_list_master.add_hook = func;
}
/* Delete hook function. */
void
-as_list_delete_hook (void (*func) (void))
+as_list_delete_hook (void (*func) (char *))
{
as_list_master.delete_hook = func;
}
/* Run hook function. */
if (as_list_master.delete_hook)
- (*as_list_master.delete_hook) ();
+ (*as_list_master.delete_hook) (argv[0]);
return CMD_SUCCESS;
}
extern enum as_filter_type as_list_apply (struct as_list *, void *);
extern struct as_list *as_list_lookup (const char *);
-extern void as_list_add_hook (void (*func) (void));
-extern void as_list_delete_hook (void (*func) (void));
+extern void as_list_add_hook (void (*func) (char *));
+extern void as_list_delete_hook (void (*func) (char *));
#endif /* _QUAGGA_BGP_FILTER_H */
/* reverse bgp_route_init */
bgp_route_finish ();
- /* reverse bgp_route_map_init/route_map_init */
- route_map_finish ();
+ /* cleanup route maps */
+ bgp_route_map_terminate();
/* reverse bgp_scan_init */
bgp_scan_finish ();
#endif /* HAVE_LIBPCREPOSIX */
#include "buffer.h"
#include "sockunion.h"
+#include "hash.h"
#include "bgpd/bgpd.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_aspath.h"
+#include "bgpd/bgp_packet.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_zebra.h"
#include "bgpd/bgp_regex.h"
#include "bgpd/bgp_vty.h"
#include "bgpd/bgp_debug.h"
+
/* Memo of route-map commands.
o Cisco route-map
as_list = as_list_lookup ((char *) rule);
if (as_list == NULL)
return RMAP_NOMATCH;
-
+
bgp_info = object;
-
+
/* Perform match. */
return ((as_list_apply (as_list, bgp_info->attr->aspath) == AS_FILTER_DENY) ? RMAP_NOMATCH : RMAP_MATCH);
}
static void *
route_set_ipv6_nexthop_peer_compile (const char *arg)
{
- int ret;
int *rins = NULL;
rins = XCALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (int));
/* Add bgp route map rule. */
static int
bgp_route_match_add (struct vty *vty, struct route_map_index *index,
- const char *command, const char *arg)
+ const char *command, const char *arg,
+ route_map_event_t type)
{
int ret;
return CMD_WARNING;
}
}
+
+ if (type != RMAP_EVENT_MATCH_ADDED)
+ {
+ route_map_upd8_dependency (type, arg, index->map->name);
+ }
+
return CMD_SUCCESS;
}
/* Delete bgp route map rule. */
static int
bgp_route_match_delete (struct vty *vty, struct route_map_index *index,
- const char *command, const char *arg)
+ const char *command, const char *arg,
+ route_map_event_t type)
{
int ret;
+ char *dep_name = (char *)arg;
+ const char *tmpstr;
+ char *rmap_name = NULL;
- ret = route_map_delete_match (index, command, arg);
+ if (type != RMAP_EVENT_MATCH_DELETED)
+ {
+ /* ignore the mundane, the types without any dependency */
+ if (arg == NULL)
+ {
+ if ((tmpstr = route_map_get_match_arg(index, command)) != NULL)
+ dep_name = XSTRDUP(MTYPE_ROUTE_MAP_RULE, tmpstr);
+ }
+ rmap_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, index->map->name);
+ }
+
+ ret = route_map_delete_match (index, command, dep_name);
if (ret)
{
switch (ret)
{
case RMAP_RULE_MISSING:
vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
- return CMD_WARNING;
+ break;
case RMAP_COMPILE_ERROR:
vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
- return CMD_WARNING;
+ break;
}
+ if (arg == NULL && dep_name)
+ XFREE(MTYPE_ROUTE_MAP_RULE, dep_name);
+ if (rmap_name)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
+ return CMD_WARNING;
}
+
+ if (type != RMAP_EVENT_MATCH_DELETED && dep_name)
+ route_map_upd8_dependency(type, dep_name, rmap_name);
+
+ if (arg == NULL && dep_name)
+ XFREE(MTYPE_ROUTE_MAP_RULE, dep_name);
+ if (rmap_name)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
+
return CMD_SUCCESS;
}
return CMD_SUCCESS;
}
-/* Hook function for updating route_map assignment. */
+/*
+ * This is the workhorse routine for processing in/out/import/export routemap
+ * modifications.
+ */
static void
-bgp_route_map_update (const char *unused)
+bgp_route_map_process_peer (char *rmap_name, struct peer *peer,
+ int afi, int safi, int route_update)
{
- int i;
- afi_t afi;
- safi_t safi;
- int direct;
- struct listnode *node, *nnode;
- struct listnode *mnode, *mnnode;
- struct bgp *bgp;
- struct peer *peer;
- struct peer_group *group;
+
+ int update;
struct bgp_filter *filter;
- struct bgp_node *bn;
- struct bgp_static *bgp_static;
- /* For neighbor route-map updates. */
- for (ALL_LIST_ELEMENTS (bm->bgp, mnode, mnnode, bgp))
+ if (!peer || !rmap_name)
+ return;
+
+ filter = &peer->filter[afi][safi];
+ /*
+ * in is for non-route-server clients,
+ * import/export is for route-server clients,
+ * out is for all peers
+ */
+ if (!CHECK_FLAG(peer->flags, PEER_FLAG_RSERVER_CLIENT))
{
- for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
- {
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- filter = &peer->filter[afi][safi];
-
- for (direct = RMAP_IN; direct < RMAP_MAX; direct++)
- {
- if (filter->map[direct].name)
- filter->map[direct].map =
- route_map_lookup_by_name (filter->map[direct].name);
- else
- filter->map[direct].map = NULL;
- }
-
- if (filter->usmap.name)
- filter->usmap.map = route_map_lookup_by_name (filter->usmap.name);
- else
- filter->usmap.map = NULL;
- }
- }
- for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
+ if (filter->map[RMAP_IN].name &&
+ (strcmp(rmap_name, filter->map[RMAP_IN].name) == 0))
{
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- filter = &group->conf->filter[afi][safi];
-
- for (direct = RMAP_IN; direct < RMAP_MAX; direct++)
- {
- if (filter->map[direct].name)
- filter->map[direct].map =
- route_map_lookup_by_name (filter->map[direct].name);
- else
- filter->map[direct].map = NULL;
- }
-
- if (filter->usmap.name)
- filter->usmap.map = route_map_lookup_by_name (filter->usmap.name);
- else
- filter->usmap.map = NULL;
- }
+ filter->map[RMAP_IN].map =
+ route_map_lookup_by_name (filter->map[RMAP_IN].name);
+
+ if (route_update)
+ {
+ if (CHECK_FLAG (peer->af_flags[afi][safi],
+ PEER_FLAG_SOFT_RECONFIG))
+ {
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "peer %s (inbound, soft-reconfig)",
+ rmap_name, peer->host);
+
+ bgp_soft_reconfig_in (peer, afi, safi);
+ }
+ else if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
+ || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
+ {
+
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "peer %s (inbound, route-refresh)",
+ rmap_name, peer->host);
+ bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
+ }
+ }
}
}
- /* For default-originate route-map updates. */
- for (ALL_LIST_ELEMENTS (bm->bgp, mnode, mnnode, bgp))
+ if (CHECK_FLAG(peer->flags, PEER_FLAG_RSERVER_CLIENT))
{
- for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
+ update = 0;
+
+ if (filter->map[RMAP_IMPORT].name &&
+ (strcmp(rmap_name, filter->map[RMAP_IMPORT].name) == 0))
{
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- if (peer->default_rmap[afi][safi].name)
- peer->default_rmap[afi][safi].map =
- route_map_lookup_by_name (peer->default_rmap[afi][safi].name);
- else
- peer->default_rmap[afi][safi].map = NULL;
- }
+ filter->map[RMAP_IMPORT].map =
+ route_map_lookup_by_name (filter->map[RMAP_IMPORT].name);
+ update = 1;
+ }
+
+ if (filter->map[RMAP_EXPORT].name &&
+ (strcmp(rmap_name, filter->map[RMAP_EXPORT].name) == 0))
+ {
+ filter->map[RMAP_EXPORT].map =
+ route_map_lookup_by_name (filter->map[RMAP_EXPORT].name);
+
+ update = 1;
+ }
+
+ if (update && route_update)
+ {
+ if (CHECK_FLAG (peer->af_flags[afi][safi],
+ PEER_FLAG_SOFT_RECONFIG))
+ {
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "peer %s (import, soft-reconfig)",
+ rmap_name, peer->host);
+
+ bgp_soft_reconfig_in (peer, afi, safi);
+ }
+ else if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
+ || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
+ {
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "peer %s (import, route-refresh)",
+ rmap_name, peer->host);
+ bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
+ }
+ /* DD: Else, what else do we do ? Reset peer ? */
}
}
- /* For table route-map updates. */
- for (ALL_LIST_ELEMENTS (bm->bgp, mnode, mnnode, bgp))
+ if (filter->map[RMAP_OUT].name &&
+ (strcmp(rmap_name, filter->map[RMAP_OUT].name) == 0))
+ {
+ filter->map[RMAP_OUT].map =
+ route_map_lookup_by_name (filter->map[RMAP_OUT].name);
+
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on peer %s (outbound)",
+ rmap_name, peer->host);
+
+ if (route_update)
+ bgp_announce_route_all(peer);
+ }
+
+ if (filter->usmap.name &&
+ (strcmp(rmap_name, filter->usmap.name) == 0))
{
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- if (bgp->table_map[afi][safi].name)
- {
- bgp->table_map[afi][safi].map =
- route_map_lookup_by_name (bgp->table_map[afi][safi].name);
- bgp_zebra_announce_table(bgp, afi, safi);
- }
- else
- bgp->table_map[afi][safi].map = NULL;
- }
+ filter->usmap.map = route_map_lookup_by_name (filter->usmap.name);
+ if (route_update)
+ bgp_announce_route_all(peer);
}
+}
- /* For network route-map updates. */
- for (ALL_LIST_ELEMENTS (bm->bgp, mnode, mnnode, bgp))
+static void
+bgp_route_map_update_peer_group(char *rmap_name, struct bgp *bgp)
+{
+ struct peer_group *group;
+ struct listnode *node, *nnode;
+ struct bgp_filter *filter;
+ int afi, safi;
+ int direct;
+
+ if (!bgp)
+ return;
+
+ /* All the peers have been updated correctly already. This is
+ * just updating the placeholder data. No real update required.
+ */
+ for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
+ {
+ filter = &group->conf->filter[afi][safi];
+
+ for (direct = RMAP_IN; direct < RMAP_MAX; direct++)
+ {
+ if ((filter->map[direct].name) &&
+ (strcmp(rmap_name, filter->map[direct].name) == 0))
+ filter->map[direct].map =
+ route_map_lookup_by_name (filter->map[direct].name);
+ }
+
+ if (filter->usmap.name &&
+ (strcmp(rmap_name, filter->usmap.name) == 0))
+ filter->usmap.map = route_map_lookup_by_name (filter->usmap.name);
+ }
+}
+
+static int
+bgp_route_map_process_update (void *arg, char *rmap_name, int route_update)
+{
+ int i;
+ afi_t afi;
+ safi_t safi;
+ struct peer *peer;
+ struct bgp_node *bn;
+ struct bgp_static *bgp_static;
+ struct bgp *bgp = (struct bgp *)arg;
+ struct listnode *node, *nnode;
+ char buf[INET6_ADDRSTRLEN];
+
+ if (!bgp)
+ return;
+
+ for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
{
+
+ /* Ignore dummy peer-group structure */
+ if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
+ continue;
+
for (afi = AFI_IP; afi < AFI_MAX; afi++)
for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- for (bn = bgp_table_top (bgp->route[afi][safi]); bn;
- bn = bgp_route_next (bn))
- if ((bgp_static = bn->info) != NULL)
+ {
+ /* Ignore inactive AFI/SAFI */
+ if (! peer->afc[afi][safi])
+ continue;
+
+ /* process in/out/import/export route-maps */
+ bgp_route_map_process_peer(rmap_name, peer, afi, safi, route_update);
+
+ /* process default-originate route-map */
+ if (peer->default_rmap[afi][safi].name &&
+ (strcmp (rmap_name, peer->default_rmap[afi][safi].name) == 0))
{
- if (bgp_static->rmap.name)
- bgp_static->rmap.map =
- route_map_lookup_by_name (bgp_static->rmap.name);
- else
- bgp_static->rmap.map = NULL;
+ peer->default_rmap[afi][safi].map =
+ route_map_lookup_by_name (peer->default_rmap[afi][safi].name);
+
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "default-originate", rmap_name);
+
+ if (route_update)
+ bgp_default_originate (peer, afi, safi, 0);
}
+ }
}
+ bgp_route_map_update_peer_group(rmap_name, bgp);
+
+ /* For table route-map updates. */
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
+ {
+ if (bgp->table_map[afi][safi].name &&
+ (strcmp(rmap_name, bgp->table_map[afi][safi].name) == 0))
+ {
+ bgp->table_map[afi][safi].map =
+ route_map_lookup_by_name (bgp->table_map[afi][safi].name);
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "table map", rmap_name);
+ if (route_update)
+ bgp_zebra_announce_table(bgp, afi, safi);
+ }
+ }
+
+ /* For network route-map updates. */
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
+ for (bn = bgp_table_top (bgp->route[afi][safi]); bn;
+ bn = bgp_route_next (bn))
+ if ((bgp_static = bn->info) != NULL)
+ {
+ if (bgp_static->rmap.name &&
+ (strcmp(rmap_name, bgp_static->rmap.name) == 0))
+ {
+ bgp_static->rmap.map =
+ route_map_lookup_by_name (bgp_static->rmap.name);
+ if (route_update)
+ if (!bgp_static->backdoor)
+ {
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "static route %s", rmap_name,
+ inet_ntop (bn->p.family, &bn->p.u.prefix,
+ buf, INET6_ADDRSTRLEN));
+ bgp_static_update (bgp, &bn->p, bgp_static, afi, safi);
+ }
+ }
+ }
+
/* For redistribute route-map updates. */
- for (ALL_LIST_ELEMENTS (bm->bgp, mnode, mnnode, bgp))
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
+ {
+ if (bgp->rmap[afi][i].name &&
+ (strcmp(rmap_name, bgp->rmap[afi][i].name) == 0))
+ {
+ bgp->rmap[afi][i].map =
+ route_map_lookup_by_name (bgp->rmap[afi][i].name);
+
+ if (bgp->redist[afi][i] && route_update)
+ {
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Processing route_map %s update on "
+ "redistributed routes", rmap_name);
+
+ bgp_redistribute_resend (bgp, afi, i);
+ }
+ }
+ }
+
+ return (0);
+}
+
+static int
+bgp_route_map_process_update_cb (void *arg, char *rmap_name)
+{
+ return bgp_route_map_process_update (arg, rmap_name, 1);
+}
+
+int
+bgp_route_map_update_timer(struct thread *thread)
+{
+ struct bgp *bgp = THREAD_ARG(thread);
+
+ bgp->t_rmap_update = NULL;
+
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Started processing route map update");
+
+ route_map_walk_update_list((void *)bgp, bgp_route_map_process_update_cb);
+
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Finished processing route map update");
+
+ return (0);
+}
+
+static void
+bgp_route_map_mark_update (char *rmap_name)
+{
+ struct listnode *node, *nnode;
+ struct bgp *bgp;
+
+ for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
{
- for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
+ if (bgp->t_rmap_update == NULL)
{
- if (bgp->rmap[ZEBRA_FAMILY_IPV4][i].name)
- bgp->rmap[ZEBRA_FAMILY_IPV4][i].map =
- route_map_lookup_by_name (bgp->rmap[ZEBRA_FAMILY_IPV4][i].name);
-#ifdef HAVE_IPV6
- if (bgp->rmap[ZEBRA_FAMILY_IPV6][i].name)
- bgp->rmap[ZEBRA_FAMILY_IPV6][i].map =
- route_map_lookup_by_name (bgp->rmap[ZEBRA_FAMILY_IPV6][i].name);
-#endif /* HAVE_IPV6 */
+ if (BGP_DEBUG(events, EVENTS))
+ zlog_debug("Starting route map update timer (in %d secs)",
+ bgp->rmap_update_timer);
+ /* rmap_update_timer of 0 means don't do route updates */
+ if (bgp->rmap_update_timer)
+ bgp->t_rmap_update =
+ thread_add_timer(master, bgp_route_map_update_timer, bgp,
+ bgp->rmap_update_timer);
+ else
+ bgp_route_map_process_update((void *)bgp, rmap_name, 0);
}
}
}
static void
-bgp_route_map_add (const char *unused)
+bgp_route_map_add (const char *rmap_name)
{
if (BGP_DEBUG (events, EVENTS))
- zlog_debug ("received route-map add");
+ zlog_debug ("received route-map add of %s", rmap_name);
+
+ if (route_map_mark_updated(rmap_name, 0) == 0)
+ bgp_route_map_mark_update(rmap_name);
- bgp_route_map_update(unused);
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
}
+
static void
-bgp_route_map_delete (const char *unused)
+bgp_route_map_delete (const char *rmap_name)
{
if (BGP_DEBUG (events, EVENTS))
- zlog_debug ("received route-map delete");
+ zlog_debug ("received route-map delete of %s", rmap_name);
+
+ if (route_map_mark_updated(rmap_name, 1) == 0)
+ bgp_route_map_mark_update(rmap_name);
- bgp_route_map_update(unused);
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_DELETED);
}
+
static void
-bgp_route_map_event (route_map_event_t event, const char *unused)
+bgp_route_map_event (route_map_event_t event, const char *rmap_name)
{
if (BGP_DEBUG (events, EVENTS))
- zlog_debug ("received route-map event");
+ zlog_debug ("received route-map event for %s", rmap_name);
- bgp_route_map_update(unused);
+ if (route_map_mark_updated(rmap_name, 0) == 0)
+ bgp_route_map_mark_update(rmap_name);
+
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
}
"IPv6 address of peer\n"
"IP address of peer\n")
{
- return bgp_route_match_add (vty, vty->index, "peer", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "peer", argv[0],
+ RMAP_EVENT_MATCH_ADDED);
}
DEFUN (match_peer_local,
"Match peer address\n"
"Static or Redistributed routes\n")
{
- return bgp_route_match_add (vty, vty->index, "peer", "local");
+ return bgp_route_match_add (vty, vty->index, "peer", "local",
+ RMAP_EVENT_MATCH_DELETED);
}
DEFUN (no_match_peer,
"Match peer address\n")
{
if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "peer", NULL);
+ return bgp_route_match_delete (vty, vty->index, "peer", NULL,
+ RMAP_EVENT_MATCH_DELETED);
- return bgp_route_match_delete (vty, vty->index, "peer", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "peer", argv[0],
+ RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_peer,
"IP access-list number (expanded range)\n"
"IP Access-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip address", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip address", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ip_address,
"Match address of route\n")
{
if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip address", NULL);
+ return bgp_route_match_delete (vty, vty->index, "ip address", NULL,
+ RMAP_EVENT_FILTER_DELETED);
- return bgp_route_match_delete (vty, vty->index, "ip address", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip address", argv[0],
+ RMAP_EVENT_FILTER_DELETED);
}
ALIAS (no_match_ip_address,
"IP access-list number (expanded range)\n"
"IP Access-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip next-hop", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ip_next_hop,
"Match next-hop address of route\n")
{
if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip next-hop", NULL);
+ return bgp_route_match_delete (vty, vty->index, "ip next-hop", NULL,
+ RMAP_EVENT_FILTER_DELETED);
- return bgp_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip next-hop", argv[0],
+ RMAP_EVENT_FILTER_DELETED);
}
ALIAS (no_match_ip_next_hop,
"Match portion of routes defined by percentage value\n"
"Percentage of routes\n")
{
- return bgp_route_match_add (vty, vty->index, "probability", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "probability", argv[0],
+ RMAP_EVENT_MATCH_ADDED);
}
DEFUN (no_match_probability,
MATCH_STR
"Match portion of routes defined by percentage value\n")
{
- return bgp_route_match_delete (vty, vty->index, "probability", argc ? argv[0] : NULL);
+ return bgp_route_match_delete (vty, vty->index, "probability", argc ? argv[0] : NULL,
+ RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_probability,
"IP access-list number (expanded range)\n"
"IP standard access-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip route-source", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip route-source", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ip_route_source,
"Match advertising source address of route\n")
{
if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip route-source", NULL);
+ return bgp_route_match_delete (vty, vty->index, "ip route-source", NULL,
+ RMAP_EVENT_FILTER_DELETED);
- return bgp_route_match_delete (vty, vty->index, "ip route-source", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip route-source",
+ argv[0], RMAP_EVENT_FILTER_DELETED);
}
ALIAS (no_match_ip_route_source,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip address prefix-list", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip address prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ip_address_prefix_list,
"Match address of route\n"
"Match entries of prefix-lists\n")
{
- if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip address prefix-list", NULL);
-
- return bgp_route_match_delete (vty, vty->index, "ip address prefix-list", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip address prefix-list",
+ argc == 0 ? NULL : argv[0],
+ RMAP_EVENT_PLIST_DELETED);
}
ALIAS (no_match_ip_address_prefix_list,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip next-hop prefix-list", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip next-hop prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ip_next_hop_prefix_list,
"Match next-hop address of route\n"
"Match entries of prefix-lists\n")
{
- if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip next-hop prefix-list", NULL);
-
- return bgp_route_match_delete (vty, vty->index, "ip next-hop prefix-list", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip next-hop prefix-list",
+ argc == 0 ? NULL : argv[0],
+ RMAP_EVENT_PLIST_DELETED);
}
ALIAS (no_match_ip_next_hop_prefix_list,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ip route-source prefix-list", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ip route-source prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ip_route_source_prefix_list,
"Match advertising source address of route\n"
"Match entries of prefix-lists\n")
{
- if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "ip route-source prefix-list", NULL);
-
- return bgp_route_match_delete (vty, vty->index, "ip route-source prefix-list", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ip route-source prefix-list",
+ argc == 0 ? NULL : argv[0],
+ RMAP_EVENT_PLIST_DELETED);
}
ALIAS (no_match_ip_route_source_prefix_list,
"Match metric of route\n"
"Metric value\n")
{
- return bgp_route_match_add (vty, vty->index, "metric", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "metric", argv[0],
+ RMAP_EVENT_MATCH_ADDED);
}
DEFUN (no_match_metric,
MATCH_STR
"Match metric of route\n")
{
- if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "metric", NULL);
-
- return bgp_route_match_delete (vty, vty->index, "metric", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "metric",
+ argc == 0 ? NULL : argv[0],
+ RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_metric,
"Match local-preference of route\n"
"Metric value\n")
{
- return bgp_route_match_add (vty, vty->index, "local-preference", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "local-preference", argv[0],
+ RMAP_EVENT_MATCH_ADDED);
}
DEFUN (no_match_local_pref,
MATCH_STR
"Match local preference of route\n")
{
- if (argc == 0)
- return bgp_route_match_delete (vty, vty->index, "local-preference", NULL);
+ return bgp_route_match_delete (vty, vty->index, "local-preference",
+ argc == 0 ? NULL : argv[0],
+ RMAP_EVENT_MATCH_DELETED);
- return bgp_route_match_delete (vty, vty->index, "local-preference", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "local-preference", argv[0],
+ RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_local_pref,
"Community-list number (expanded)\n"
"Community-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "community", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "community", argv[0],
+ RMAP_EVENT_CLIST_ADDED);
}
DEFUN (match_community_exact,
sprintf (argstr, "%s exact-match", argv[0]);
- ret = bgp_route_match_add (vty, vty->index, "community", argstr);
+ ret = bgp_route_match_add (vty, vty->index, "community", argstr,
+ RMAP_EVENT_CLIST_ADDED);
XFREE (MTYPE_ROUTE_MAP_COMPILED, argstr);
MATCH_STR
"Match BGP community list\n")
{
- return bgp_route_match_delete (vty, vty->index, "community", NULL);
+ return bgp_route_match_delete (vty, vty->index, "community", NULL,
+ RMAP_EVENT_CLIST_DELETED);
}
ALIAS (no_match_community,
"Extended community-list number (expanded)\n"
"Extended community-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "extcommunity", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "extcommunity", argv[0],
+ RMAP_EVENT_ECLIST_ADDED);
}
DEFUN (no_match_ecommunity,
MATCH_STR
"Match BGP/VPN extended community list\n")
{
- return bgp_route_match_delete (vty, vty->index, "extcommunity", NULL);
+ return bgp_route_match_delete (vty, vty->index, "extcommunity", NULL,
+ RMAP_EVENT_ECLIST_DELETED);
}
ALIAS (no_match_ecommunity,
"Match BGP AS path list\n"
"AS path access-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "as-path", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "as-path", argv[0],
+ RMAP_EVENT_ASLIST_ADDED);
}
DEFUN (no_match_aspath,
MATCH_STR
"Match BGP AS path list\n")
{
- return bgp_route_match_delete (vty, vty->index, "as-path", NULL);
+ return bgp_route_match_delete (vty, vty->index, "as-path", NULL,
+ RMAP_EVENT_ASLIST_DELETED);
}
ALIAS (no_match_aspath,
"unknown heritage\n")
{
if (strncmp (argv[0], "igp", 2) == 0)
- return bgp_route_match_add (vty, vty->index, "origin", "igp");
+ return bgp_route_match_add (vty, vty->index, "origin", "igp",
+ RMAP_EVENT_MATCH_ADDED);
if (strncmp (argv[0], "egp", 1) == 0)
- return bgp_route_match_add (vty, vty->index, "origin", "egp");
+ return bgp_route_match_add (vty, vty->index, "origin", "egp",
+ RMAP_EVENT_MATCH_ADDED);
if (strncmp (argv[0], "incomplete", 2) == 0)
- return bgp_route_match_add (vty, vty->index, "origin", "incomplete");
+ return bgp_route_match_add (vty, vty->index, "origin", "incomplete",
+ RMAP_EVENT_MATCH_ADDED);
return CMD_WARNING;
}
MATCH_STR
"BGP origin code\n")
{
- return bgp_route_match_delete (vty, vty->index, "origin", NULL);
+ return bgp_route_match_delete (vty, vty->index, "origin", NULL,
+ RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_origin,
"Match IPv6 address of route\n"
"IPv6 access-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ipv6 address", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ipv6 address", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ipv6_address,
"Match IPv6 address of route\n"
"IPv6 access-list name\n")
{
- return bgp_route_match_delete (vty, vty->index, "ipv6 address", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ipv6 address", argv[0],
+ RMAP_EVENT_FILTER_DELETED);
}
DEFUN (match_ipv6_next_hop,
"Match IPv6 next-hop address of route\n"
"IPv6 address of next hop\n")
{
- return bgp_route_match_add (vty, vty->index, "ipv6 next-hop", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ipv6 next-hop", argv[0],
+ RMAP_EVENT_MATCH_ADDED);
}
DEFUN (no_match_ipv6_next_hop,
"Match IPv6 next-hop address of route\n"
"IPv6 address of next hop\n")
{
- return bgp_route_match_delete (vty, vty->index, "ipv6 next-hop", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ipv6 next-hop", argv[0],
+ RMAP_EVENT_MATCH_DELETED);
}
DEFUN (match_ipv6_address_prefix_list,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return bgp_route_match_add (vty, vty->index, "ipv6 address prefix-list", argv[0]);
+ return bgp_route_match_add (vty, vty->index, "ipv6 address prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ipv6_address_prefix_list,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return bgp_route_match_delete (vty, vty->index, "ipv6 address prefix-list", argv[0]);
+ return bgp_route_match_delete (vty, vty->index, "ipv6 address prefix-list",
+ argv[0], RMAP_EVENT_PLIST_DELETED);
}
DEFUN (set_ipv6_nexthop_peer,
install_element (RMAP_NODE, &no_match_pathlimit_as_cmd);
install_element (RMAP_NODE, &no_match_pathlimit_as_val_cmd);
}
+
+void
+bgp_route_map_terminate (void)
+{
+ /* ToDo: Cleanup all the used memory */
+
+ route_map_add_hook (NULL);
+ route_map_delete_hook (NULL);
+ route_map_event_hook (NULL);
+ route_map_finish();
+
+}
"Minimum interval between sending BGP routing updates\n"
"time in seconds\n")
+/* Time to wait before processing route-map updates */
+DEFUN (bgp_set_route_map_delay_timer,
+ bgp_set_route_map_delay_timer_cmd,
+ "bgp route-map delay-timer <0-600>",
+ SET_STR
+ "BGP route-map delay timer\n"
+ "Time in secs to wait before processing route-map changes\n"
+ "0 disables the timer and no route updates happen when\n"
+ "route-maps change")
+{
+ u_int32_t rmap_delay_timer;
+ struct bgp *bgp;
+
+ bgp = vty->index;
+ if (argv[0])
+ {
+ VTY_GET_INTEGER_RANGE ("delay-timer", rmap_delay_timer, argv[0], 0, 600);
+ bgp->rmap_update_timer = rmap_delay_timer;
+
+ /* if the dynamic update handling is being disabled, and a timer is
+ * running, stop the timer and act as if the timer has already fired.
+ */
+ if (!rmap_delay_timer && bgp->t_rmap_update )
+ {
+ BGP_TIMER_OFF(bgp->t_rmap_update);
+ thread_execute (bm->master, bgp_route_map_update_timer, &bgp, 0);
+ }
+ return CMD_SUCCESS;
+ }
+ else
+ CMD_WARNING;
+}
+
+DEFUN (no_bgp_set_route_map_delay_timer,
+ no_bgp_set_route_map_delay_timer_cmd,
+ "no bgp route-map delay-timer",
+ NO_STR
+ "Default BGP route-map delay timer\n"
+ "Reset to default time to wait for processing route-map changes")
+{
+ u_int32_t rmap_delay_timer;
+ struct bgp *bgp;
+
+ bgp = vty->index;
+ bgp->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
+
+ return CMD_SUCCESS;
+}
+
/* neighbor interface */
static int
peer_interface_vty (struct vty *vty, const char *ip_str, const char *str)
install_element (BGP_NODE, &no_bgp_timers_cmd);
install_element (BGP_NODE, &no_bgp_timers_arg_cmd);
+ /* route-map delay-timer commands */
+ install_element (BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
+ install_element (BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
+
/* "bgp client-to-client reflection" commands */
install_element (BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
install_element (BGP_NODE, &bgp_client_to_client_reflection_cmd);
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("Zebra send: redistribute add %s", zebra_route_string(type));
-
+
/* Send distribute add message to zebra. */
zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
return CMD_SUCCESS;
}
+int
+bgp_redistribute_resend (struct bgp *bgp, afi_t afi, int type)
+{
+ /* Return if zebra connection is not established. */
+ if (zclient->sock < 0)
+ return -1;
+
+ if (BGP_DEBUG(zebra, ZEBRA))
+ zlog_debug("Zebra send: redistribute add %s", zebra_route_string(type));
+
+ /* Send distribute add message to zebra. */
+ zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
+ zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
+
+ return 0;
+}
+
/* Redistribute with route-map specification. */
int
bgp_redistribute_rmap_set (struct bgp *bgp, afi_t afi, int type,
extern void bgp_zebra_withdraw (struct prefix *, struct bgp_info *, safi_t);
extern int bgp_redistribute_set (struct bgp *, afi_t, int);
+extern int bgp_redistribute_resend (struct bgp *, afi_t, int);
extern int bgp_redistribute_rmap_set (struct bgp *, afi_t, int, const char *);
extern int bgp_redistribute_metric_set (struct bgp *, afi_t, int, u_int32_t);
extern int bgp_redistribute_unset (struct bgp *, afi_t, int);
bgp_router_id_set(bgp, &router_id_zebra);
*bgp_val = bgp;
+ bgp->t_rmap_update = NULL;
+ bgp->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
+
/* Create BGP server socket, if first instance. */
if (list_isempty(bm->bgp)
&& !bgp_option_check (BGP_OPT_NO_LISTEN))
afi_t afi;
int i;
+ if (bgp->t_rmap_update)
+ BGP_TIMER_OFF(bgp->t_rmap_update);
+
/* Delete static route. */
bgp_static_delete (bgp);
}
static void
-peer_aslist_update (void)
+peer_aslist_update (char *aslist_name)
{
afi_t afi;
safi_t safi;
}
}
}
+static void
+peer_aslist_add (char *aslist_name)
+{
+ peer_aslist_update (aslist_name);
+ route_map_notify_dependencies((char *)aslist_name, RMAP_EVENT_ASLIST_ADDED);
+}
+
+static void
+peer_aslist_del (char *aslist_name)
+{
+ peer_aslist_update (aslist_name);
+ route_map_notify_dependencies((char *)aslist_name, RMAP_EVENT_ASLIST_DELETED);
+}
+
/* Set route-map to the peer. */
+static void
+peer_reprocess_routes (struct peer *peer, int direct,
+ afi_t afi, safi_t safi)
+{
+ if (peer->status != Established)
+ return;
+
+ if (direct != RMAP_OUT)
+ {
+ if (CHECK_FLAG (peer->af_flags[afi][safi],
+ PEER_FLAG_SOFT_RECONFIG))
+ bgp_soft_reconfig_in (peer, afi, safi);
+ else if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
+ || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
+ bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
+ }
+ else
+ bgp_announce_route(peer, afi, safi);
+}
+
int
peer_route_map_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
const char *name)
if (filter->map[direct].name)
free (filter->map[direct].name);
-
+
filter->map[direct].name = strdup (name);
filter->map[direct].map = route_map_lookup_by_name (name);
if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
- return 0;
+ {
+ peer_reprocess_routes(peer, direct, afi, safi);
+ return 0;
+ }
group = peer->group;
for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
free (filter->map[direct].name);
filter->map[direct].name = strdup (name);
filter->map[direct].map = route_map_lookup_by_name (name);
+ peer_reprocess_routes (peer, direct, afi, safi);
}
return 0;
}
filter->map[direct].map = NULL;
if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
- return 0;
+ {
+ peer_reprocess_routes(peer, direct, afi, safi);
+ return 0;
+ }
group = peer->group;
for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
free (filter->map[direct].name);
filter->map[direct].name = NULL;
filter->map[direct].map = NULL;
+ peer_reprocess_routes(peer, direct, afi, safi);
}
return 0;
}
filter->usmap.map = route_map_lookup_by_name (name);
if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
- return 0;
+ {
+ bgp_announce_route (peer, afi, safi);
+ return 0;
+ }
group = peer->group;
for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
free (filter->usmap.name);
filter->usmap.name = strdup (name);
filter->usmap.map = route_map_lookup_by_name (name);
+ bgp_announce_route (peer, afi, safi);
}
return 0;
}
filter->usmap.map = NULL;
if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
- return 0;
+ {
+ bgp_announce_route(peer, afi, safi);
+ return 0;
+ }
group = peer->group;
for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
free (filter->usmap.name);
filter->usmap.name = NULL;
filter->usmap.map = NULL;
+ bgp_announce_route(peer, afi, safi);
}
return 0;
}
vty_out (vty, " timers bgp %d %d%s", bgp->default_keepalive,
bgp->default_holdtime, VTY_NEWLINE);
+ if (bgp->rmap_update_timer != RMAP_DEFAULT_UPDATE_TIMER)
+ vty_out (vty, " bgp route-map delay-timer %d%s", bgp->rmap_update_timer,
+ VTY_NEWLINE);
+
/* peer-group */
for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
{
/* Filter list initialize. */
bgp_filter_init ();
- as_list_add_hook (peer_aslist_update);
- as_list_delete_hook (peer_aslist_update);
+ as_list_add_hook (peer_aslist_add);
+ as_list_delete_hook (peer_aslist_del);
/* Prefix list initialize.*/
prefix_list_init ();
/* For union sockunion. */
#include "sockunion.h"
+#include "routemap.h"
/* Typedef BGP specific types. */
typedef u_int32_t as_t;
/* BGP redistribute route-map. */
struct bgp_rmap rmap[AFI_MAX][ZEBRA_ROUTE_MAX];
+ /* timer to dampen route map changes */
+ struct thread *t_rmap_update; /* Handle route map updates */
+ u_int32_t rmap_update_timer; /* Route map update timer */
+#define RMAP_DEFAULT_UPDATE_TIMER 5 /* disabled by default */
+
/* BGP distance configuration. */
u_char distance_ebgp;
u_char distance_ibgp;
extern int peer_ttl_security_hops_set (struct peer *, int);
extern int peer_ttl_security_hops_unset (struct peer *);
+extern int bgp_route_map_update_timer (struct thread *thread);
+extern void bgp_route_map_terminate(void);
#endif /* _QUAGGA_BGPD_H */
#include "sockunion.h"
#include "buffer.h"
#include "log.h"
+#include "routemap.h"
struct filter_cisco
{
/* Run hook function. */
if (access->master->add_hook)
(*access->master->add_hook) (access);
+ route_map_notify_dependencies(access->name, RMAP_EVENT_FILTER_ADDED);
}
/* If access_list has no filter then return 1. */
filter_free (filter);
+ route_map_notify_dependencies(access->name, RMAP_EVENT_FILTER_DELETED);
/* If access_list becomes empty delete it from access_master. */
if (access_list_empty (access))
access_list_delete (access);
master = access->master;
+ route_map_notify_dependencies(access->name, RMAP_EVENT_FILTER_DELETED);
/* Run hook function. */
if (master->delete_hook)
(*master->delete_hook) (access);
master = access->master;
+ route_map_notify_dependencies(access->name, RMAP_EVENT_FILTER_DELETED);
/* Run hook function. */
if (master->delete_hook)
(*master->delete_hook) (access);
{ MTYPE_ROUTE_MAP_RULE, "Route map rule" },
{ MTYPE_ROUTE_MAP_RULE_STR, "Route map rule str" },
{ MTYPE_ROUTE_MAP_COMPILED, "Route map compiled" },
+ { MTYPE_ROUTE_MAP_DEP, "Route map dependency" },
{ MTYPE_CMD_TOKENS, "Command desc" },
{ MTYPE_KEY, "Key" },
{ MTYPE_KEYCHAIN, "Key chain" },
#include "buffer.h"
#include "stream.h"
#include "log.h"
+#include "routemap.h"
/* Each prefix-list's entry. */
struct prefix_list_entry
cleared. */
master->recent = NULL;
+ route_map_notify_dependencies(plist->name, RMAP_EVENT_PLIST_DELETED);
+
+ if (master->delete_hook)
+ (*master->delete_hook) (NULL);
+
if (plist->name)
XFREE (MTYPE_PREFIX_LIST_STR, plist->name);
-
+
prefix_list_free (plist);
-
- if (master->delete_hook)
- (*master->delete_hook) (NULL);
+
}
static struct prefix_list_entry *
if (update_list)
{
+ route_map_notify_dependencies(plist->name, RMAP_EVENT_PLIST_DELETED);
if (plist->master->delete_hook)
(*plist->master->delete_hook) (plist);
if (plist->master->add_hook)
(*plist->master->add_hook) (plist);
+ route_map_notify_dependencies(plist->name, RMAP_EVENT_PLIST_ADDED);
plist->master->recent = plist;
}
#include "command.h"
#include "vty.h"
#include "log.h"
+#include "hash.h"
/* Vector for route match rules. */
static vector route_match_vec;
void (*add_hook) (const char *);
void (*delete_hook) (const char *);
- void (*event_hook) (route_map_event_t, const char *);
+ void (*event_hook) (route_map_event_t, const char *);
};
/* Master list of route map. */
-static struct route_map_list route_map_master = { NULL, NULL, NULL, NULL };
+static struct route_map_list route_map_master = { NULL, NULL, NULL, NULL, NULL };
+
+enum route_map_upd8_type
+ {
+ ROUTE_MAP_ADD = 1,
+ ROUTE_MAP_DEL,
+ };
+
+/* all possible route-map dependency types */
+enum route_map_dep_type
+ {
+ ROUTE_MAP_DEP_RMAP = 1,
+ ROUTE_MAP_DEP_CLIST,
+ ROUTE_MAP_DEP_ECLIST,
+ ROUTE_MAP_DEP_PLIST,
+ ROUTE_MAP_DEP_ASPATH,
+ ROUTE_MAP_DEP_FILTER,
+ ROUTE_MAP_DEP_MAX,
+ };
+
+struct route_map_dep
+{
+ char *dep_name;
+ struct hash *dep_rmap_hash;
+ struct hash *this_hash; /* ptr to the hash structure this is part of */
+};
-static void
-route_map_rule_delete (struct route_map_rule_list *,
- struct route_map_rule *);
+/* Hashes maintaining dependency between various sublists used by route maps */
+struct hash *route_map_dep_hash[ROUTE_MAP_DEP_MAX];
+
+static unsigned int route_map_dep_hash_make_key (void *p);
+static int route_map_dep_hash_cmp (const void *p1, const void *p2);
+static void route_map_init_dep_hashes (void);
+static void route_map_clear_all_references (char *rmap_name);
+static void route_map_rule_delete (struct route_map_rule_list *,
+ struct route_map_rule *);
+static int rmap_debug = 0;
static void
route_map_index_delete (struct route_map_index *, int);
/* Execute hook. */
if (route_map_master.add_hook)
- (*route_map_master.add_hook) (name);
-
+ {
+ (*route_map_master.add_hook) (name);
+ route_map_notify_dependencies(name, RMAP_EVENT_CALL_ADDED);
+ }
return map;
}
-/* Route map delete from list. */
-static void
-route_map_delete (struct route_map *map)
+/* this is supposed to be called post processing by
+ * the delete hook function. Don't invoke delete_hook
+ * again in this routine.
+ */
+void
+route_map_free_map (struct route_map *map)
{
struct route_map_list *list;
struct route_map_index *index;
- char *name;
-
+
while ((index = map->head) != NULL)
route_map_index_delete (index, 0);
- name = map->name;
-
list = &route_map_master;
- if (map->next)
- map->next->prev = map->prev;
- else
- list->tail = map->prev;
+ if (map != NULL)
+ {
+ if (map->next)
+ map->next->prev = map->prev;
+ else
+ list->tail = map->prev;
- if (map->prev)
- map->prev->next = map->next;
- else
- list->head = map->next;
+ if (map->prev)
+ map->prev->next = map->next;
+ else
+ list->head = map->next;
- XFREE (MTYPE_ROUTE_MAP, map);
+ XFREE (MTYPE_ROUTE_MAP_NAME, map->name);
+ XFREE (MTYPE_ROUTE_MAP, map);
+ }
+}
+/* Route map delete from list. */
+static void
+route_map_delete (struct route_map *map)
+{
+ struct route_map_index *index;
+ char *name;
+
+ while ((index = map->head) != NULL)
+ route_map_index_delete (index, 0);
+
+ name = map->name;
+ map->head = NULL;
+
+ /* Clear all dependencies */
+ route_map_clear_all_references(name);
+ map->deleted = 1;
/* Execute deletion hook. */
if (route_map_master.delete_hook)
- (*route_map_master.delete_hook) (name);
-
- if (name)
- XFREE (MTYPE_ROUTE_MAP_NAME, name);
+ {
+ (*route_map_master.delete_hook) (name);
+ route_map_notify_dependencies(name, RMAP_EVENT_CALL_DELETED);
+ }
+ if (!map->to_be_processed)
+ {
+ route_map_free_map (map);
+ }
}
/* Lookup route map by route map name string. */
{
struct route_map *map;
+ if (!name)
+ return NULL;
+
for (map = route_map_master.head; map; map = map->next)
- if (strcmp (map->name, name) == 0)
+ if ((strcmp (map->name, name) == 0) && (!map->deleted))
return map;
return NULL;
}
+int
+route_map_mark_updated (const char *name, int del_later)
+{
+ struct route_map *map;
+ int ret = -1;
+
+ /* We need to do this walk manually instead of calling lookup_by_name()
+ * because the lookup function doesn't return route maps marked as
+ * deleted.
+ */
+ for (map = route_map_master.head; map; map = map->next)
+ if (strcmp (map->name, name) == 0)
+ {
+ map->to_be_processed = 1;
+ ret = 0;
+ }
+
+ return(ret);
+}
+
+int
+route_map_clear_updated (struct route_map *map)
+{
+ int ret = -1;
+
+ if (map)
+ {
+ map->to_be_processed = 0;
+ if (map->deleted)
+ route_map_free_map(map);
+ }
+
+ return (ret);
+}
+
/* Lookup route map. If there isn't route map create one and return
it. */
static struct route_map *
map = route_map_lookup_by_name (name);
if (map == NULL)
map = route_map_add (name);
+
return map;
}
+void
+route_map_walk_update_list (void *arg,
+ int (*route_map_update_fn) (void *arg, char *name))
+{
+ struct route_map *node;
+ struct route_map *nnode = NULL;
+
+ for (node = route_map_master.head; node; node = nnode)
+ {
+ if (node->to_be_processed)
+ {
+ /* DD: Should we add any thread yield code here */
+ route_map_update_fn(arg, node->name);
+ nnode = node->next;
+ route_map_clear_updated(node);
+ }
+ else
+ nnode = node->next;
+ }
+}
+
/* Return route map's type string. */
static const char *
route_map_type_str (enum route_map_type type)
else
{
for (map = route_map_master.head; map; map = map->next)
- vty_show_route_map_entry (vty, map);
+ if (!map->deleted)
+ vty_show_route_map_entry (vty, map);
}
return CMD_SUCCESS;
}
/* Execute event hook. */
if (route_map_master.event_hook && notify)
- (*route_map_master.event_hook) (RMAP_EVENT_INDEX_DELETED,
- index->map->name);
-
+ {
+ (*route_map_master.event_hook) (RMAP_EVENT_INDEX_DELETED,
+ index->map->name);
+ route_map_notify_dependencies(index->map->name, RMAP_EVENT_CALL_ADDED);
+ }
XFREE (MTYPE_ROUTE_MAP_INDEX, index);
}
/* Execute event hook. */
if (route_map_master.event_hook)
- (*route_map_master.event_hook) (RMAP_EVENT_INDEX_ADDED,
- map->name);
-
+ {
+ (*route_map_master.event_hook) (RMAP_EVENT_INDEX_ADDED,
+ map->name);
+ route_map_notify_dependencies (map->name, RMAP_EVENT_CALL_ADDED);
+ }
return index;
}
return 1;
}
+/* Use this to return the already specified argument for this match. This is
+ * useful to get the specified argument with a route map match rule when the
+ * rule is being deleted and the argument is not provided.
+ */
+const char *
+route_map_get_match_arg(struct route_map_index *index, const char *match_name)
+{
+ struct route_map_rule *rule;
+ struct route_map_rule_cmd *cmd;
+
+ /* First lookup rule for add match statement. */
+ cmd = route_map_lookup_match (match_name);
+ if (cmd == NULL)
+ return NULL;
+
+ for (rule = index->match_list.head; rule; rule = rule->next)
+ if (rule->cmd == cmd && rule->rule_str != NULL)
+ return (rule->rule_str);
+
+ return (NULL);
+}
+
/* Add match statement to route map. */
int
route_map_add_match (struct route_map_index *index, const char *match_name,
/* Execute event hook. */
if (route_map_master.event_hook)
- (*route_map_master.event_hook) (replaced ?
- RMAP_EVENT_MATCH_REPLACED:
- RMAP_EVENT_MATCH_ADDED,
- index->map->name);
+ {
+ (*route_map_master.event_hook) (replaced ?
+ RMAP_EVENT_MATCH_REPLACED:
+ RMAP_EVENT_MATCH_ADDED,
+ index->map->name);
+ route_map_notify_dependencies(index->map->name, RMAP_EVENT_CALL_ADDED);
+ }
return 0;
}
route_map_rule_delete (&index->match_list, rule);
/* Execute event hook. */
if (route_map_master.event_hook)
- (*route_map_master.event_hook) (RMAP_EVENT_MATCH_DELETED,
- index->map->name);
+ {
+ (*route_map_master.event_hook) (RMAP_EVENT_MATCH_DELETED,
+ index->map->name);
+ route_map_notify_dependencies(index->map->name, RMAP_EVENT_CALL_ADDED);
+ }
return 0;
}
/* Can't find matched rule. */
/* Execute event hook. */
if (route_map_master.event_hook)
- (*route_map_master.event_hook) (replaced ?
- RMAP_EVENT_SET_REPLACED:
- RMAP_EVENT_SET_ADDED,
- index->map->name);
+ {
+ (*route_map_master.event_hook) (replaced ?
+ RMAP_EVENT_SET_REPLACED:
+ RMAP_EVENT_SET_ADDED,
+ index->map->name);
+ route_map_notify_dependencies(index->map->name, RMAP_EVENT_CALL_ADDED);
+ }
return 0;
}
route_map_rule_delete (&index->set_list, rule);
/* Execute event hook. */
if (route_map_master.event_hook)
- (*route_map_master.event_hook) (RMAP_EVENT_SET_DELETED,
- index->map->name);
+ {
+ (*route_map_master.event_hook) (RMAP_EVENT_SET_DELETED,
+ index->map->name);
+ route_map_notify_dependencies(index->map->name, RMAP_EVENT_CALL_ADDED);
+ }
return 0;
}
/* Can't find matched rule. */
route_set_vec = NULL;
}
+/* Routines for route map dependency lists and dependency processing */
+static int
+route_map_rmap_hash_cmp (const void *p1, const void *p2)
+{
+ return (strcmp((char *)p1, (char *)p2) == 0);
+}
+
+static int
+route_map_dep_hash_cmp (const void *p1, const void *p2)
+{
+
+ return (strcmp (((struct route_map_dep *)p1)->dep_name, (char *)p2) == 0);
+}
+
+static void
+route_map_rmap_free(struct hash_backet *backet, void *arg)
+{
+ char *rmap_name = (char *)backet->data;
+
+ if (rmap_name)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
+}
+
+static void
+route_map_dep_hash_free (struct hash_backet *backet, void *arg)
+{
+ struct route_map_dep *dep = (struct route_map_dep *)backet->data;
+
+ if (!dep)
+ return;
+
+ if (dep->dep_rmap_hash)
+ hash_iterate (dep->dep_rmap_hash, route_map_rmap_free, (void *)NULL);
+
+ hash_free(dep->dep_rmap_hash);
+ XFREE(MTYPE_ROUTE_MAP_NAME, dep->dep_name);
+ XFREE(MTYPE_ROUTE_MAP_DEP, dep);
+}
+
+static void
+route_map_clear_reference(struct hash_backet *backet, void *arg)
+{
+ struct route_map_dep *dep = (struct route_map_dep *)backet->data;
+ char *rmap_name;
+
+ if (dep && arg)
+ {
+ rmap_name = (char *)hash_release(dep->dep_rmap_hash, (void *)arg);
+ if (rmap_name)
+ {
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
+ }
+ if (!dep->dep_rmap_hash->count)
+ {
+ dep = hash_release(dep->this_hash, (void *)dep->dep_name);
+ hash_free(dep->dep_rmap_hash);
+ XFREE(MTYPE_ROUTE_MAP_NAME, dep->dep_name);
+ XFREE(MTYPE_ROUTE_MAP_DEP, dep);
+ }
+ }
+}
+
+static void
+route_map_clear_all_references (char *rmap_name)
+{
+ int i;
+
+ for (i = 1; i < ROUTE_MAP_DEP_MAX; i++)
+ {
+ hash_iterate(route_map_dep_hash[i], route_map_clear_reference,
+ (void *)rmap_name);
+ }
+}
+
+static void *
+route_map_dep_hash_alloc(void *p)
+{
+ char *dep_name = (char *)p;
+ struct route_map_dep *dep_entry;
+
+ dep_entry = XCALLOC(MTYPE_ROUTE_MAP_DEP, sizeof(struct route_map_dep));
+ dep_entry->dep_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, dep_name);
+ dep_entry->dep_rmap_hash = hash_create(route_map_dep_hash_make_key,
+ route_map_rmap_hash_cmp);
+ dep_entry->this_hash = NULL;
+
+ return((void *)dep_entry);
+}
+
+static void *
+route_map_name_hash_alloc(void *p)
+{
+ return((void *)XSTRDUP(MTYPE_ROUTE_MAP_NAME, (char *)p));
+}
+
+static unsigned int
+route_map_dep_hash_make_key (void *p)
+{
+ return (string_hash_make((char *)p));
+}
+
+static void
+route_map_print_dependency (struct hash_backet *backet, void *data)
+{
+ char *rmap_name = (char *)backet->data;
+ char *dep_name = (char *)data;
+
+ if (rmap_name)
+ zlog_debug("%s: Dependency for %s: %s", __FUNCTION__, dep_name, rmap_name);
+}
+
+static int
+route_map_dep_update (struct hash *dephash, const char *dep_name,
+ const char *rmap_name,
+ route_map_event_t type)
+{
+ struct route_map_dep *dep;
+ char *ret_map_name;
+
+ switch (type)
+ {
+ case RMAP_EVENT_PLIST_ADDED:
+ case RMAP_EVENT_CLIST_ADDED:
+ case RMAP_EVENT_ECLIST_ADDED:
+ case RMAP_EVENT_ASLIST_ADDED:
+ case RMAP_EVENT_CALL_ADDED:
+ case RMAP_EVENT_FILTER_ADDED:
+ if (rmap_debug)
+ zlog_debug("%s: Adding dependency for %s in %s", __FUNCTION__,
+ dep_name, rmap_name);
+ dep = (struct route_map_dep *) hash_get (dephash, (void *)dep_name,
+ route_map_dep_hash_alloc);
+ if (!dep)
+ return -1;
+
+ if (!dep->this_hash)
+ dep->this_hash = dephash;
+
+ hash_get(dep->dep_rmap_hash, rmap_name, route_map_name_hash_alloc);
+ break;
+ case RMAP_EVENT_PLIST_DELETED:
+ case RMAP_EVENT_CLIST_DELETED:
+ case RMAP_EVENT_ECLIST_DELETED:
+ case RMAP_EVENT_ASLIST_DELETED:
+ case RMAP_EVENT_CALL_DELETED:
+ case RMAP_EVENT_FILTER_DELETED:
+ if (rmap_debug)
+ zlog_debug("%s: Deleting dependency for %s in %s", __FUNCTION__,
+ dep_name, rmap_name);
+ dep = (struct route_map_dep *) hash_get (dephash, (void *)dep_name,
+ NULL);
+ if (!dep)
+ return 0;
+ ret_map_name = (char *)hash_release(dep->dep_rmap_hash, (void *)rmap_name);
+ if (ret_map_name)
+ XFREE(MTYPE_ROUTE_MAP_NAME, ret_map_name);
+
+ if (!dep->dep_rmap_hash->count)
+ {
+ dep = hash_release(dephash, (void *)dep_name);
+ hash_free(dep->dep_rmap_hash);
+ XFREE(MTYPE_ROUTE_MAP_NAME, dep->dep_name);
+ XFREE(MTYPE_ROUTE_MAP_DEP, dep);
+ dep = NULL;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (dep)
+ {
+ if (rmap_debug)
+ hash_iterate (dep->dep_rmap_hash, route_map_print_dependency, (void *)dep_name);
+ }
+ return 0;
+}
+
+static struct hash *
+route_map_get_dep_hash (route_map_event_t event)
+{
+ struct hash *upd8_hash = NULL;
+
+ switch (event)
+ {
+ case RMAP_EVENT_PLIST_ADDED:
+ case RMAP_EVENT_PLIST_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_PLIST];
+ break;
+ case RMAP_EVENT_CLIST_ADDED:
+ case RMAP_EVENT_CLIST_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_CLIST];
+ break;
+ case RMAP_EVENT_ECLIST_ADDED:
+ case RMAP_EVENT_ECLIST_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_ECLIST];
+ break;
+ case RMAP_EVENT_ASLIST_ADDED:
+ case RMAP_EVENT_ASLIST_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_ASPATH];
+ break;
+ case RMAP_EVENT_CALL_ADDED:
+ case RMAP_EVENT_CALL_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_RMAP];
+ break;
+ case RMAP_EVENT_FILTER_ADDED:
+ case RMAP_EVENT_FILTER_DELETED:
+ upd8_hash = route_map_dep_hash[ROUTE_MAP_DEP_FILTER];
+ break;
+ default:
+ upd8_hash = NULL;
+ break;
+ }
+ return (upd8_hash);
+}
+
+static void
+route_map_process_dependency (struct hash_backet *backet, void *data)
+{
+ char *rmap_name;
+ route_map_event_t type = (route_map_event_t )data;
+
+ rmap_name = (char *)backet->data;
+
+ if (rmap_name)
+ {
+ if (rmap_debug)
+ zlog_debug("%s: Notifying %s of dependency", __FUNCTION__,
+ rmap_name);
+ if (route_map_master.event_hook)
+ (*route_map_master.event_hook) (type, rmap_name);
+ }
+}
+
+void
+route_map_upd8_dependency (route_map_event_t type, const char *arg,
+ const char *rmap_name)
+{
+ struct hash *upd8_hash = NULL;
+
+ if ((upd8_hash = route_map_get_dep_hash(type)))
+ route_map_dep_update (upd8_hash, arg, rmap_name, type);
+}
+
+void
+route_map_notify_dependencies (const char *affected_name, route_map_event_t event)
+{
+ struct route_map_dep *dep;
+ struct hash *upd8_hash;
+
+ if (!affected_name)
+ return;
+
+ if ((upd8_hash = route_map_get_dep_hash(event)) == NULL)
+ return;
+
+ dep = (struct route_map_dep *)hash_get (upd8_hash, (void *)affected_name,
+ NULL);
+ if (dep)
+ {
+ if (!dep->this_hash)
+ dep->this_hash = upd8_hash;
+
+ hash_iterate (dep->dep_rmap_hash, route_map_process_dependency, (void *)event);
+ }
+}
+
/* VTY related functions. */
DEFUN (route_map,
route_map_cmd,
if (index)
{
if (index->nextrm)
- XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
+ {
+ route_map_upd8_dependency (RMAP_EVENT_CALL_DELETED,
+ index->nextrm,
+ index->map->name);
+ XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
+ }
index->nextrm = XSTRDUP (MTYPE_ROUTE_MAP_NAME, argv[0]);
}
+
+ /* Execute event hook. */
+ route_map_upd8_dependency (RMAP_EVENT_CALL_ADDED,
+ index->nextrm,
+ index->map->name);
return CMD_SUCCESS;
}
if (index->nextrm)
{
+ route_map_upd8_dependency (RMAP_EVENT_CALL_DELETED,
+ index->nextrm,
+ index->map->name);
XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
index->nextrm = NULL;
}
1
};
+static void
+route_map_init_dep_hashes (void)
+{
+ int i;
+
+ for (i = 1; i < ROUTE_MAP_DEP_MAX; i++)
+ route_map_dep_hash[i] = hash_create(route_map_dep_hash_make_key,
+ route_map_dep_hash_cmp);
+}
+
/* Initialization of route map vector. */
void
route_map_init_vty (void)
{
+ route_map_init_dep_hashes();
+
/* Install route map top node. */
install_node (&rmap_node, route_map_config_write);
RMAP_EVENT_MATCH_DELETED,
RMAP_EVENT_MATCH_REPLACED,
RMAP_EVENT_INDEX_ADDED,
- RMAP_EVENT_INDEX_DELETED
+ RMAP_EVENT_INDEX_DELETED,
+ RMAP_EVENT_CALL_ADDED, /* call to another routemap added */
+ RMAP_EVENT_CALL_DELETED,
+ RMAP_EVENT_PLIST_ADDED,
+ RMAP_EVENT_PLIST_DELETED,
+ RMAP_EVENT_CLIST_ADDED,
+ RMAP_EVENT_CLIST_DELETED,
+ RMAP_EVENT_ECLIST_ADDED,
+ RMAP_EVENT_ECLIST_DELETED,
+ RMAP_EVENT_ASLIST_ADDED,
+ RMAP_EVENT_ASLIST_DELETED,
+ RMAP_EVENT_FILTER_ADDED,
+ RMAP_EVENT_FILTER_DELETED,
} route_map_event_t;
/* Depth limit in RMAP recursion using RMAP_CALL. */
/* Make linked list. */
struct route_map *next;
struct route_map *prev;
+
+ /* Maintain update info */
+ int to_be_processed; /* True if modification isn't acted on yet */
+ int deleted; /* If 1, then this node will be deleted */
};
/* Prototypes. */
const char *match_name,
const char *match_arg);
+extern const char *route_map_get_match_arg (struct route_map_index *index,
+ const char *match_name);
+
/* Add route-map set statement to the route map. */
extern int route_map_add_set (struct route_map_index *index,
const char *set_name,
extern void route_map_add_hook (void (*func) (const char *));
extern void route_map_delete_hook (void (*func) (const char *));
-extern void route_map_event_hook (void (*func) (route_map_event_t, const char *));
+extern void route_map_event_hook (void (*func) (route_map_event_t,
+ const char *));
+extern int route_map_mark_updated (const char *name, int deleted);
+extern int route_map_clear_updated (struct route_map *rmap);
+extern void route_map_walk_update_list (void *arg,
+ int (*update_fn) (void *arg,
+ char *name));
+extern void route_map_upd8_dependency (route_map_event_t type, const char *arg,
+ const char *rmap_name);
+extern void route_map_notify_dependencies (const char *affected_name,
+ route_map_event_t event);
#endif /* _ZEBRA_ROUTEMAP_H */
$(othersrc) zebra_ptm.c zebra_rnh.c
testzebra_SOURCES = test_main.c zebra_rib.c interface.c connected.c debug.c \
- zebra_vty.c zebra_ptm.c \
+ zebra_vty.c zebra_ptm.c zebra_routemap.c \
kernel_null.c redistribute_null.c ioctl_null.c misc_null.c zebra_rnh_null.c
noinst_HEADERS = \
rib_table_info_t *info = rn->table->info;
struct interface *ifp;
route_map_result_t ret = RMAP_MATCH;
- extern char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX+1];
- struct route_map *rmap;
int family;
+ char buf[INET6_ADDRSTRLEN+1];
family = 0;
switch (nexthop->type)
if (!family)
family = info->afi;
- rmap = 0;
- if (rib->type >= 0 && rib->type < ZEBRA_ROUTE_MAX &&
- proto_rm[family][rib->type])
- rmap = route_map_lookup_by_name (proto_rm[family][rib->type]);
- if (!rmap && proto_rm[family][ZEBRA_ROUTE_MAX])
- rmap = route_map_lookup_by_name (proto_rm[family][ZEBRA_ROUTE_MAX]);
- if (rmap) {
- ret = route_map_apply(rmap, &rn->p, RMAP_ZEBRA, nexthop);
- }
-
+ ret = zebra_route_map_check(family, rib->type, &rn->p, nexthop);
if (ret == RMAP_DENYMATCH)
- UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
+ {
+ if (IS_ZEBRA_DEBUG_RIB)
+ {
+ inet_ntop (rn->p.family, &rn->p.u.prefix, buf, sizeof (buf));
+ zlog_debug("%s: Filtering out %s with NH out %s due to route map",
+ __FUNCTION__, buf, nexthop->ifname);
+ }
+ UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
+ }
return CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
}
#include "nexthop.h"
#include "zebra/zserv.h"
+#include "zebra/debug.h"
+
+static u_int32_t zebra_rmap_update_timer = ZEBRA_RMAP_DEFAULT_UPDATE_TIMER;
+static struct thread *zebra_t_rmap_update = NULL;
+char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX+1]; /* "any" == ZEBRA_ROUTE_MAX */
+
+extern struct zebra_t zebrad;
/* Add zebra route map rule */
static int
zebra_route_match_add(struct vty *vty, struct route_map_index *index,
- const char *command, const char *arg)
+ const char *command, const char *arg,
+ route_map_event_t type)
{
int ret;
return CMD_WARNING;
}
}
+
+ if (type != RMAP_EVENT_MATCH_ADDED)
+ {
+ route_map_upd8_dependency (type, arg, index->map->name);
+ }
return CMD_SUCCESS;
}
/* Delete zebra route map rule. */
static int
zebra_route_match_delete (struct vty *vty, struct route_map_index *index,
- const char *command, const char *arg)
+ const char *command, const char *arg,
+ route_map_event_t type)
{
int ret;
+ char *dep_name = (char *)arg;
+ const char *tmpstr;
+ char *rmap_name = NULL;
+
+ if (type != RMAP_EVENT_MATCH_DELETED)
+ {
+ /* ignore the mundane, the types without any dependency */
+ if (arg == NULL)
+ {
+ if ((tmpstr = route_map_get_match_arg(index, command)) != NULL)
+ dep_name = XSTRDUP(MTYPE_ROUTE_MAP_RULE, tmpstr);
+ }
+ rmap_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, index->map->name);
+ }
ret = route_map_delete_match (index, command, arg);
if (ret)
return CMD_WARNING;
}
}
+
+ if (type != RMAP_EVENT_MATCH_DELETED && dep_name)
+ route_map_upd8_dependency(type, dep_name, rmap_name);
+
+ if (arg == NULL && dep_name)
+ XFREE(MTYPE_ROUTE_MAP_RULE, dep_name);
+ if (rmap_name)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
+
return CMD_SUCCESS;
}
"match first hop interface of route\n"
"Interface name\n")
{
- return zebra_route_match_add (vty, vty->index, "interface", argv[0]);
+ return zebra_route_match_add (vty, vty->index, "interface", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_interface,
"Match first hop interface of route\n")
{
if (argc == 0)
- return zebra_route_match_delete (vty, vty->index, "interface", NULL);
+ return zebra_route_match_delete (vty, vty->index, "interface", NULL, RMAP_EVENT_MATCH_DELETED);
- return zebra_route_match_delete (vty, vty->index, "interface", argv[0]);
+ return zebra_route_match_delete (vty, vty->index, "interface", argv[0], RMAP_EVENT_MATCH_DELETED);
}
ALIAS (no_match_interface,
"IP access-list number (expanded range)\n"
"IP Access-list name\n")
{
- return zebra_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
+ return zebra_route_match_add (vty, vty->index, "ip next-hop", argv[0], RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ip_next_hop,
"Match next-hop address of route\n")
{
if (argc == 0)
- return zebra_route_match_delete (vty, vty->index, "ip next-hop", NULL);
+ return zebra_route_match_delete (vty, vty->index, "ip next-hop", NULL,
+ RMAP_EVENT_FILTER_DELETED);
- return zebra_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
+ return zebra_route_match_delete (vty, vty->index, "ip next-hop", argv[0],
+ RMAP_EVENT_FILTER_DELETED);
}
ALIAS (no_match_ip_next_hop,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return zebra_route_match_add (vty, vty->index, "ip next-hop prefix-list", argv[0]);
+ return zebra_route_match_add (vty, vty->index, "ip next-hop prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ip_next_hop_prefix_list,
"Match entries of prefix-lists\n")
{
if (argc == 0)
- return zebra_route_match_delete (vty, vty->index, "ip next-hop prefix-list", NULL);
+ return zebra_route_match_delete (vty, vty->index,
+ "ip next-hop prefix-list", NULL,
+ RMAP_EVENT_PLIST_DELETED);
- return zebra_route_match_delete (vty, vty->index, "ip next-hop prefix-list", argv[0]);
+ return zebra_route_match_delete (vty, vty->index,
+ "ip next-hop prefix-list", argv[0],
+ RMAP_EVENT_PLIST_DELETED);
}
ALIAS (no_match_ip_next_hop_prefix_list,
"IP Access-list name\n")
{
- return zebra_route_match_add (vty, vty->index, "ip address", argv[0]);
+ return zebra_route_match_add (vty, vty->index, "ip address", argv[0],
+ RMAP_EVENT_FILTER_ADDED);
}
DEFUN (no_match_ip_address,
"Match address of route\n")
{
if (argc == 0)
- return zebra_route_match_delete (vty, vty->index, "ip address", NULL);
+ return zebra_route_match_delete (vty, vty->index, "ip address", NULL,
+ RMAP_EVENT_FILTER_DELETED);
- return zebra_route_match_delete (vty, vty->index, "ip address", argv[0]);
+ return zebra_route_match_delete (vty, vty->index, "ip address", argv[0],
+ RMAP_EVENT_FILTER_DELETED);
}
ALIAS (no_match_ip_address,
"Match entries of prefix-lists\n"
"IP prefix-list name\n")
{
- return zebra_route_match_add (vty, vty->index, "ip address prefix-list", argv[0]);
+ return zebra_route_match_add (vty, vty->index, "ip address prefix-list",
+ argv[0], RMAP_EVENT_PLIST_ADDED);
}
DEFUN (no_match_ip_address_prefix_list,
"Match entries of prefix-lists\n")
{
if (argc == 0)
- return zebra_route_match_delete (vty, vty->index, "ip address prefix-list", NULL);
+ return zebra_route_match_delete (vty, vty->index,
+ "ip address prefix-list", NULL,
+ RMAP_EVENT_PLIST_DELETED);
- return zebra_route_match_delete (vty, vty->index, "ip address prefix-list", argv[0]);
+ return zebra_route_match_delete (vty, vty->index,
+ "ip address prefix-list", argv[0],
+ RMAP_EVENT_PLIST_DELETED);
}
ALIAS (no_match_ip_address_prefix_list,
"src address for route\n"
"src address\n")
+DEFUN (zebra_route_map_timer,
+ zebra_route_map_timer_cmd,
+ "zebra route-map delay-timer <0-600>",
+ "Time to wait before route-map updates are\n"
+ "processed. 0 means disable event driven\n"
+ "route-map updates. Set this to a larger\n"
+ "value than protocol route-map delay timer\n"
+ "to avoid unnecessary churn in routing tables\n")
+{
+ u_int32_t rmap_delay_timer;
+
+ VTY_GET_INTEGER_RANGE ("delay-timer", rmap_delay_timer, argv[0], 0, 600);
+ zebra_route_map_set_delay_timer(rmap_delay_timer);
+
+ return (CMD_SUCCESS);
+}
+
+DEFUN (no_zebra_route_map_timer,
+ no_zebra_route_map_timer_cmd,
+ "no zebra route-map delay-timer",
+ NO_STR
+ "Reset delay-timer to default value, 30 secs\n")
+{
+ zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER);
+
+ return (CMD_SUCCESS);
+}
+
+DEFUN (ip_protocol,
+ ip_protocol_cmd,
+ "ip protocol PROTO route-map ROUTE-MAP",
+ NO_STR
+ "Apply route map to PROTO\n"
+ "Protocol name\n"
+ "Route map name\n")
+{
+ int i;
+
+ if (strcasecmp(argv[0], "any") == 0)
+ i = ZEBRA_ROUTE_MAX;
+ else
+ i = proto_name2num(argv[0]);
+ if (i < 0)
+ {
+ vty_out (vty, "invalid protocol name \"%s\"%s", argv[0] ? argv[0] : "",
+ VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+ if (proto_rm[AFI_IP][i])
+ {
+ if (strcmp(proto_rm[AFI_IP][i], argv[1]) == 0)
+ return CMD_SUCCESS;
+
+ XFREE (MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
+ }
+ proto_rm[AFI_IP][i] = XSTRDUP (MTYPE_ROUTE_MAP_NAME, argv[1]);
+ rib_update();
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ip_protocol,
+ no_ip_protocol_cmd,
+ "no ip protocol PROTO",
+ NO_STR
+ "Remove route map from PROTO\n"
+ "Protocol name\n")
+{
+ int i;
+
+ if (strcasecmp(argv[0], "any") == 0)
+ i = ZEBRA_ROUTE_MAX;
+ else
+ i = proto_name2num(argv[0]);
+ if (i < 0)
+ {
+ vty_out (vty, "invalid protocol name \"%s\"%s", argv[0] ? argv[0] : "",
+ VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+ if (!proto_rm[AFI_IP][i])
+ return CMD_SUCCESS;
+
+ XFREE (MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
+ proto_rm[AFI_IP][i] = NULL;
+ rib_update();
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_protocol,
+ show_ip_protocol_cmd,
+ "show ip protocol",
+ SHOW_STR
+ IP_STR
+ "IP protocol filtering status\n")
+{
+ int i;
+
+ vty_out(vty, "Protocol : route-map %s", VTY_NEWLINE);
+ vty_out(vty, "------------------------%s", VTY_NEWLINE);
+ for (i=0;i<ZEBRA_ROUTE_MAX;i++)
+ {
+ if (proto_rm[AFI_IP][i])
+ vty_out (vty, "%-10s : %-10s%s", zebra_route_string(i),
+ proto_rm[AFI_IP][i],
+ VTY_NEWLINE);
+ else
+ vty_out (vty, "%-10s : none%s", zebra_route_string(i), VTY_NEWLINE);
+ }
+ if (proto_rm[AFI_IP][i])
+ vty_out (vty, "%-10s : %-10s%s", "any", proto_rm[AFI_IP][i],
+ VTY_NEWLINE);
+ else
+ vty_out (vty, "%-10s : none%s", "any", VTY_NEWLINE);
+
+ return CMD_SUCCESS;
+}
+
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
/* `match ip next-hop IP_ACCESS_LIST' */
route_set_src_free,
};
+static int
+zebra_route_map_update_timer (struct thread *thread)
+{
+ zebra_t_rmap_update = NULL;
+
+ if (IS_ZEBRA_DEBUG_EVENT)
+ zlog_debug("Event driven route-map update triggered");
+
+ rib_update();
+}
+
+void
+zebra_route_map_set_delay_timer(u_int32_t value)
+{
+ zebra_rmap_update_timer = value;
+ if (!value && zebra_t_rmap_update)
+ {
+ /* Event driven route map updates is being disabled */
+ /* But there's a pending timer. Fire it off now */
+ thread_cancel(zebra_t_rmap_update);
+ zebra_route_map_update_timer(zebra_t_rmap_update);
+ }
+}
+
+void
+zebra_route_map_write_delay_timer (struct vty *vty)
+{
+ if (vty && (zebra_rmap_update_timer != ZEBRA_RMAP_DEFAULT_UPDATE_TIMER))
+ vty_out (vty, "zebra route-map delay-timer %d%s", zebra_rmap_update_timer,
+ VTY_NEWLINE);
+ return;
+}
+
+route_map_result_t
+zebra_route_map_check (int family, int rib_type, struct prefix *p,
+ struct nexthop *nexthop)
+{
+ struct route_map *rmap = NULL;
+ route_map_result_t ret = RMAP_MATCH;
+
+ if (rib_type >= 0 && rib_type < ZEBRA_ROUTE_MAX)
+ rmap = route_map_lookup_by_name (proto_rm[family][rib_type]);
+ if (!rmap && proto_rm[family][ZEBRA_ROUTE_MAX])
+ rmap = route_map_lookup_by_name (proto_rm[family][ZEBRA_ROUTE_MAX]);
+ if (rmap) {
+ ret = route_map_apply(rmap, p, RMAP_ZEBRA, nexthop);
+ }
+
+ return (ret);
+}
+
+static void
+zebra_route_map_mark_update (char *rmap_name)
+{
+ /* rmap_update_timer of 0 means don't do route updates */
+ if (zebra_rmap_update_timer && !zebra_t_rmap_update)
+ zebra_t_rmap_update =
+ thread_add_timer(zebrad.master, zebra_route_map_update_timer, NULL,
+ zebra_rmap_update_timer);
+}
+
+static void
+zebra_route_map_add (const char *rmap_name)
+{
+ zebra_route_map_mark_update(rmap_name);
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
+}
+
+static void
+zebra_route_map_delete (const char *rmap_name)
+{
+ zebra_route_map_mark_update(rmap_name);
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_DELETED);
+}
+
+static void
+zebra_route_map_event (route_map_event_t event, const char *rmap_name)
+{
+ zebra_route_map_mark_update(rmap_name);
+ route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
+}
+
+/* ip protocol configuration write function */
+static int config_write_protocol(struct vty *vty)
+{
+ int i;
+
+ for (i=0;i<ZEBRA_ROUTE_MAX;i++)
+ {
+ if (proto_rm[AFI_IP][i])
+ vty_out (vty, "ip protocol %s route-map %s%s", zebra_route_string(i),
+ proto_rm[AFI_IP][i], VTY_NEWLINE);
+ }
+ if (proto_rm[AFI_IP][ZEBRA_ROUTE_MAX])
+ vty_out (vty, "ip protocol %s route-map %s%s", "any",
+ proto_rm[AFI_IP][ZEBRA_ROUTE_MAX], VTY_NEWLINE);
+
+ if (zebra_rmap_update_timer != ZEBRA_RMAP_DEFAULT_UPDATE_TIMER)
+ vty_out (vty, "zebra route-map delay-timer %d%s", zebra_rmap_update_timer,
+ VTY_NEWLINE);
+ return 1;
+}
+/* table node for protocol filtering */
+static struct cmd_node protocol_node = { PROTOCOL_NODE, "", 1 };
+
void
zebra_route_map_init ()
{
+ install_node (&protocol_node, config_write_protocol);
+ install_element (CONFIG_NODE, &ip_protocol_cmd);
+ install_element (CONFIG_NODE, &no_ip_protocol_cmd);
+ install_element (VIEW_NODE, &show_ip_protocol_cmd);
+ install_element (ENABLE_NODE, &show_ip_protocol_cmd);
+ install_element (CONFIG_NODE, &zebra_route_map_timer_cmd);
+ install_element (CONFIG_NODE, &no_zebra_route_map_timer_cmd);
+
route_map_init ();
route_map_init_vty ();
+ route_map_add_hook (zebra_route_map_add);
+ route_map_delete_hook (zebra_route_map_delete);
+ route_map_event_hook (zebra_route_map_event);
+
route_map_install_match (&route_match_interface_cmd);
route_map_install_match (&route_match_ip_next_hop_cmd);
route_map_install_match (&route_match_ip_next_hop_prefix_list_cmd);
return zebra_static_ipv4 (vty, 0, argv[0], argv[1], NULL, argv[2], argv[3]);
}
-char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX+1]; /* "any" == ZEBRA_ROUTE_MAX */
-
-DEFUN (ip_protocol,
- ip_protocol_cmd,
- "ip protocol PROTO route-map ROUTE-MAP",
- NO_STR
- "Apply route map to PROTO\n"
- "Protocol name\n"
- "Route map name\n")
-{
- int i;
-
- if (strcasecmp(argv[0], "any") == 0)
- i = ZEBRA_ROUTE_MAX;
- else
- i = proto_name2num(argv[0]);
- if (i < 0)
- {
- vty_out (vty, "invalid protocol name \"%s\"%s", argv[0] ? argv[0] : "",
- VTY_NEWLINE);
- return CMD_WARNING;
- }
- if (proto_rm[AFI_IP][i])
- XFREE (MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
- proto_rm[AFI_IP][i] = XSTRDUP (MTYPE_ROUTE_MAP_NAME, argv[1]);
- return CMD_SUCCESS;
-}
-
-DEFUN (no_ip_protocol,
- no_ip_protocol_cmd,
- "no ip protocol PROTO",
- NO_STR
- "Remove route map from PROTO\n"
- "Protocol name\n")
-{
- int i;
-
- if (strcasecmp(argv[0], "any") == 0)
- i = ZEBRA_ROUTE_MAX;
- else
- i = proto_name2num(argv[0]);
- if (i < 0)
- {
- vty_out (vty, "invalid protocol name \"%s\"%s", argv[0] ? argv[0] : "",
- VTY_NEWLINE);
- return CMD_WARNING;
- }
- if (proto_rm[AFI_IP][i])
- XFREE (MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
- proto_rm[AFI_IP][i] = NULL;
- return CMD_SUCCESS;
-}
-
/* New RIB. Detailed information for IPv4 route. */
static void
vty_show_ip_route_detail (struct vty *vty, struct route_node *rn)
return write;
}
-DEFUN (show_ip_protocol,
- show_ip_protocol_cmd,
- "show ip protocol",
- SHOW_STR
- IP_STR
- "IP protocol filtering status\n")
-{
- int i;
-
- vty_out(vty, "Protocol : route-map %s", VTY_NEWLINE);
- vty_out(vty, "------------------------%s", VTY_NEWLINE);
- for (i=0;i<ZEBRA_ROUTE_MAX;i++)
- {
- if (proto_rm[AFI_IP][i])
- vty_out (vty, "%-10s : %-10s%s", zebra_route_string(i),
- proto_rm[AFI_IP][i],
- VTY_NEWLINE);
- else
- vty_out (vty, "%-10s : none%s", zebra_route_string(i), VTY_NEWLINE);
- }
- if (proto_rm[AFI_IP][i])
- vty_out (vty, "%-10s : %-10s%s", "any", proto_rm[AFI_IP][i],
- VTY_NEWLINE);
- else
- vty_out (vty, "%-10s : none%s", "any", VTY_NEWLINE);
-
- return CMD_SUCCESS;
-}
-
/*
* Show IP mroute command to dump the BGP Multicast
* routing table
return write;
}
-/* ip protocol configuration write function */
-static int config_write_protocol(struct vty *vty)
-{
- int i;
-
- for (i=0;i<ZEBRA_ROUTE_MAX;i++)
- {
- if (proto_rm[AFI_IP][i])
- vty_out (vty, "ip protocol %s route-map %s%s", zebra_route_string(i),
- proto_rm[AFI_IP][i], VTY_NEWLINE);
- }
- if (proto_rm[AFI_IP][ZEBRA_ROUTE_MAX])
- vty_out (vty, "ip protocol %s route-map %s%s", "any",
- proto_rm[AFI_IP][ZEBRA_ROUTE_MAX], VTY_NEWLINE);
-
- return 1;
-}
-
-/* table node for protocol filtering */
-static struct cmd_node protocol_node = { PROTOCOL_NODE, "", 1 };
-
/* IP node for static routes. */
static struct cmd_node ip_node = { IP_NODE, "", 1 };
zebra_vty_init (void)
{
install_node (&ip_node, zebra_ip_config);
- install_node (&protocol_node, config_write_protocol);
- install_element (CONFIG_NODE, &ip_protocol_cmd);
- install_element (CONFIG_NODE, &no_ip_protocol_cmd);
- install_element (VIEW_NODE, &show_ip_protocol_cmd);
- install_element (ENABLE_NODE, &show_ip_protocol_cmd);
install_element (CONFIG_NODE, &ip_route_cmd);
install_element (CONFIG_NODE, &ip_route_flags_cmd);
install_element (CONFIG_NODE, &ip_route_flags2_cmd);
#include "rib.h"
#include "if.h"
#include "workqueue.h"
+#include "routemap.h"
/* Default port information. */
#define ZEBRA_VTY_PORT 2601
/* Default configuration filename. */
#define DEFAULT_CONFIG_FILE "zebra.conf"
+#define ZEBRA_RMAP_DEFAULT_UPDATE_TIMER 5 /* disabled by default */
+
/* Client structure. */
struct zserv
{
extern void zserv_create_header(struct stream *s, uint16_t cmd);
extern int zebra_server_send_message(struct zserv *client);
+extern void zebra_route_map_write_delay_timer(struct vty *);
+extern route_map_result_t zebra_route_map_check (int family, int rib_type,
+ struct prefix *p,
+ struct nexthop *nexthop);
+
#endif /* _ZEBRA_ZEBRA_H */
projects / matthieu / frr.git / commitdiff