#include "zebra/zebra_routemap.h"
#include "zebra/interface.h"
#include "zebra/zebra_memory.h"
+#include "zebra/zebra_errors.h"
static void free_state(vrf_id_t vrf_id, struct route_entry *re,
struct route_node *rn);
static int send_client(struct rnh *rnh, struct zserv *client, rnh_type_t type,
vrf_id_t vrf_id);
static void print_rnh(struct route_node *rn, struct vty *vty);
+static int zebra_client_cleanup_rnh(struct zserv *client);
int zebra_rnh_ip_default_route = 0;
int zebra_rnh_ipv6_default_route = 0;
+void zebra_rnh_init(void)
+{
+ hook_register(zserv_client_close, zebra_client_cleanup_rnh);
+}
+
static inline struct route_table *get_rnh_table(vrf_id_t vrfid, int family,
rnh_type_t type)
{
rnh = XCALLOC(MTYPE_RNH, sizeof(struct rnh));
rnh->client_list = list_new();
rnh->vrf_id = vrfid;
- rnh->zebra_static_route_list = list_new();
rnh->zebra_pseudowire_list = list_new();
route_lock_node(rn);
rn->info = rnh;
{
rnh->flags |= ZEBRA_NHT_DELETED;
list_delete_and_null(&rnh->client_list);
- list_delete_and_null(&rnh->zebra_static_route_list);
list_delete_and_null(&rnh->zebra_pseudowire_list);
free_state(rnh->vrf_id, rnh->state, rnh->node);
XFREE(MTYPE_RNH, rnh);
}
listnode_delete(rnh->client_list, client);
if (list_isempty(rnh->client_list)
- && list_isempty(rnh->zebra_static_route_list)
&& list_isempty(rnh->zebra_pseudowire_list))
zebra_delete_rnh(rnh, type);
}
-void zebra_register_rnh_static_nh(vrf_id_t vrf_id, struct prefix *nh,
- struct route_node *static_rn)
-{
- struct rnh *rnh;
-
- rnh = zebra_add_rnh(nh, vrf_id, RNH_NEXTHOP_TYPE);
- if (rnh && !listnode_lookup(rnh->zebra_static_route_list, static_rn)) {
- listnode_add(rnh->zebra_static_route_list, static_rn);
- }
-}
-
-void zebra_deregister_rnh_static_nh(vrf_id_t vrf_id, struct prefix *nh,
- struct route_node *static_rn)
-{
- struct rnh *rnh;
-
- rnh = zebra_lookup_rnh(nh, vrf_id, RNH_NEXTHOP_TYPE);
- if (!rnh || (rnh->flags & ZEBRA_NHT_DELETED))
- return;
-
- listnode_delete(rnh->zebra_static_route_list, static_rn);
-
- if (list_isempty(rnh->client_list)
- && list_isempty(rnh->zebra_static_route_list)
- && list_isempty(rnh->zebra_pseudowire_list))
- zebra_delete_rnh(rnh, RNH_NEXTHOP_TYPE);
-}
-
-void zebra_deregister_rnh_static_nexthops(vrf_id_t vrf_id,
- struct nexthop *nexthop,
- struct route_node *rn)
-{
- struct nexthop *nh;
- struct prefix nh_p;
-
- for (nh = nexthop; nh; nh = nh->next) {
- switch (nh->type) {
- case NEXTHOP_TYPE_IPV4:
- case NEXTHOP_TYPE_IPV4_IFINDEX:
- nh_p.family = AF_INET;
- nh_p.prefixlen = IPV4_MAX_BITLEN;
- nh_p.u.prefix4 = nh->gate.ipv4;
- break;
- case NEXTHOP_TYPE_IPV6:
- case NEXTHOP_TYPE_IPV6_IFINDEX:
- nh_p.family = AF_INET6;
- nh_p.prefixlen = IPV6_MAX_BITLEN;
- nh_p.u.prefix6 = nh->gate.ipv6;
- break;
- /*
- * Not sure what really to do here, we are not
- * supposed to have either of these for NHT
- * and the code has no way to know what prefix
- * to use. So I'm going to just continue
- * for the moment, which is preferable to
- * what is currently happening which is a
- * CRASH and BURN.
- * Some simple testing shows that we
- * are not leaving slag around for these
- * skipped static routes. Since
- * they don't appear to be installed
- */
- case NEXTHOP_TYPE_IFINDEX:
- case NEXTHOP_TYPE_BLACKHOLE:
- continue;
- break;
- }
- zebra_deregister_rnh_static_nh(vrf_id, &nh_p, rn);
- }
-}
-
/* XXX move this utility function elsewhere? */
static void addr2hostprefix(int af, const union g_addr *addr,
struct prefix *prefix)
pw->rnh = NULL;
if (list_isempty(rnh->client_list)
- && list_isempty(rnh->zebra_static_route_list)
&& list_isempty(rnh->zebra_pseudowire_list))
zebra_delete_rnh(rnh, RNH_NEXTHOP_TYPE);
}
rmap_family = (family == AF_INET) ? AFI_IP : AFI_IP6;
if (prn && re) {
- for (nexthop = re->nexthop; nexthop; nexthop = nexthop->next) {
+ for (nexthop = re->ng.nexthop; nexthop;
+ nexthop = nexthop->next) {
ret = zebra_nht_route_map_check(rmap_family, proto,
&prn->p, re, nexthop);
if (ret != RMAP_DENYMATCH) {
struct nexthop *nexthop;
if (re && (rnh->state == NULL)) {
- for (ALL_NEXTHOPS(re->nexthop, nexthop))
+ for (ALL_NEXTHOPS(re->ng, nexthop))
if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)) {
state_changed = 1;
break;
}
}
-static void zebra_rnh_process_static_routes(vrf_id_t vrfid, int family,
- struct route_node *nrn,
- struct rnh *rnh,
- struct route_node *prn,
- struct route_entry *re)
+static void zebra_rnh_process_pbr_tables(int family,
+ struct route_node *nrn,
+ struct rnh *rnh,
+ struct route_node *prn,
+ struct route_entry *re)
{
+ struct zebra_ns_table *znst;
+ struct route_entry *o_re;
+ struct route_node *o_rn;
struct listnode *node;
- int num_resolving_nh = 0;
- struct route_node *static_rn;
- struct route_entry *sre;
- struct nexthop *nexthop;
- char bufn[INET6_ADDRSTRLEN];
- char bufp[INET6_ADDRSTRLEN];
- char bufs[INET6_ADDRSTRLEN];
+ struct zserv *client;
+ struct zebra_ns *zns;
+ afi_t afi = AFI_IP;
- if (IS_ZEBRA_DEBUG_NHT) {
- prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
- if (prn)
- prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
+ if (family == AF_INET6)
+ afi = AFI_IP6;
+
+ /*
+ * We are only concerned about nexthops that change for
+ * anyone using PBR
+ */
+ for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client)) {
+ if (client->proto == ZEBRA_ROUTE_PBR)
+ break;
}
- if (prn && re) {
- /* Apply route-map for "static" to route resolving this
- * nexthop to see if it is filtered or not.
- */
- num_resolving_nh = zebra_rnh_apply_nht_rmap(family, prn, re,
- ZEBRA_ROUTE_STATIC);
- if (num_resolving_nh)
- rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
- else
- rnh->filtered[ZEBRA_ROUTE_STATIC] = 1;
- } else
- rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
+ if (!client)
+ return;
- /* Evaluate each static route associated with this nexthop. */
- for (ALL_LIST_ELEMENTS_RO(rnh->zebra_static_route_list, node,
- static_rn)) {
- RNODE_FOREACH_RE (static_rn, sre) {
- if (sre->type != ZEBRA_ROUTE_STATIC)
- continue;
+ zns = zebra_ns_lookup(NS_DEFAULT);
+ RB_FOREACH (znst, zebra_ns_table_head, &zns->ns_tables) {
+ if (afi != znst->afi)
+ continue;
- /* Set the filter flag for the correct nexthop - static
- * route may
- * be having multiple. We care here only about
- * registered nexthops.
- */
- for (nexthop = sre->nexthop; nexthop;
- nexthop = nexthop->next) {
- switch (nexthop->type) {
- case NEXTHOP_TYPE_IPV4:
- case NEXTHOP_TYPE_IPV4_IFINDEX:
- if (nexthop->gate.ipv4.s_addr
- == nrn->p.u.prefix4.s_addr) {
- if (num_resolving_nh)
- UNSET_FLAG(
- nexthop->flags,
- NEXTHOP_FLAG_FILTERED);
- else
- SET_FLAG(
- nexthop->flags,
- NEXTHOP_FLAG_FILTERED);
- }
+ for (o_rn = route_top(znst->table);
+ o_rn; o_rn = srcdest_route_next(o_rn)) {
+ RNODE_FOREACH_RE (o_rn, o_re) {
+ if (o_re->type == ZEBRA_ROUTE_PBR)
break;
- case NEXTHOP_TYPE_IPV6:
- case NEXTHOP_TYPE_IPV6_IFINDEX:
- if (memcmp(&nexthop->gate.ipv6,
- &nrn->p.u.prefix6, 16)
- == 0) {
- if (num_resolving_nh)
- UNSET_FLAG(
- nexthop->flags,
- NEXTHOP_FLAG_FILTERED);
- else
- SET_FLAG(
- nexthop->flags,
- NEXTHOP_FLAG_FILTERED);
- }
- break;
- default:
- break;
- }
}
- if (IS_ZEBRA_DEBUG_NHT) {
- prefix2str(&static_rn->p, bufs,
- INET6_ADDRSTRLEN);
- if (prn && re)
- zlog_debug(
- "%u:%s: NH change %s, scheduling static route %s",
- vrfid, bufn,
- num_resolving_nh
- ? ""
- : "(filtered by route-map)",
- bufs);
- else
- zlog_debug(
- "%u:%s: NH unreachable, scheduling static route %s",
- vrfid, bufn, bufs);
+ /*
+ * If we have a PBR route and a nexthop changes
+ * just rethink it. Yes this is a hammer, but
+ * a small one
+ */
+ if (o_re) {
+ SET_FLAG(o_re->status, ROUTE_ENTRY_CHANGED);
+ rib_queue_add(o_rn);
}
-
- SET_FLAG(sre->status, ROUTE_ENTRY_CHANGED);
- SET_FLAG(sre->status, ROUTE_ENTRY_NEXTHOPS_CHANGED);
}
-
- rib_queue_add(static_rn);
}
}
if (re->type == ZEBRA_ROUTE_NHRP) {
struct nexthop *nexthop;
- for (nexthop = re->nexthop; nexthop;
+ for (nexthop = re->ng.nexthop; nexthop;
nexthop = nexthop->next)
if (nexthop->type
== NEXTHOP_TYPE_IFINDEX)
zebra_rnh_notify_protocol_clients(vrfid, family, nrn, rnh, prn,
rnh->state);
- /* Process static routes attached to this nexthop */
- zebra_rnh_process_static_routes(vrfid, family, nrn, rnh, prn,
- rnh->state);
+ zebra_rnh_process_pbr_tables(family, nrn, rnh, prn,
+ rnh->state);
/* Process pseudowires attached to this nexthop */
zebra_rnh_process_pseudowires(vrfid, rnh);
print_rnh(rn, vty);
}
-int zebra_cleanup_rnh_client(vrf_id_t vrf_id, int family, struct zserv *client,
- rnh_type_t type)
-{
- struct route_table *ntable;
- struct route_node *nrn;
- struct rnh *rnh;
-
- if (IS_ZEBRA_DEBUG_NHT)
- zlog_debug("%u: Client %s RNH cleanup for family %d type %d",
- vrf_id, zebra_route_string(client->proto), family,
- type);
-
- ntable = get_rnh_table(vrf_id, family, type);
- if (!ntable) {
- zlog_debug("cleanup_rnh_client: rnh table not found\n");
- return -1;
- }
-
- for (nrn = route_top(ntable); nrn; nrn = route_next(nrn)) {
- if (!nrn->info)
- continue;
-
- rnh = nrn->info;
- zebra_remove_rnh_client(rnh, client, type);
- }
- return 1;
-}
-
/**
* free_state - free up the re structure associated with the rnh.
*/
return;
/* free RE and nexthops */
- zebra_deregister_rnh_static_nexthops(vrf_id, re->nexthop, rn);
- nexthops_free(re->nexthop);
+ nexthops_free(re->ng.nexthop);
XFREE(MTYPE_RE, re);
}
state->metric = re->metric;
state->vrf_id = re->vrf_id;
- route_entry_copy_nexthops(state, re->nexthop);
+ route_entry_copy_nexthops(state, re->ng.nexthop);
rnh->state = state;
}
struct stream *s;
struct route_entry *re;
unsigned long nump;
- u_char num;
- struct nexthop *nexthop;
+ uint8_t num;
+ struct nexthop *nh;
struct route_node *rn;
int cmd = (type == RNH_IMPORT_CHECK_TYPE) ? ZEBRA_IMPORT_CHECK_UPDATE
: ZEBRA_NEXTHOP_UPDATE;
re = rnh->state;
/* Get output stream. */
- s = client->obuf;
- stream_reset(s);
+ s = stream_new(ZEBRA_MAX_PACKET_SIZ);
zclient_create_header(s, cmd, vrf_id);
stream_put(s, &rn->p.u.prefix6, IPV6_MAX_BYTELEN);
break;
default:
- zlog_err("%s: Unknown family (%d) notification attempted\n",
- __FUNCTION__, rn->p.family);
+ flog_err(ZEBRA_ERR_RNH_UNKNOWN_FAMILY,
+ "%s: Unknown family (%d) notification attempted\n",
+ __FUNCTION__, rn->p.family);
break;
}
if (re) {
num = 0;
nump = stream_get_endp(s);
stream_putc(s, 0);
- for (nexthop = re->nexthop; nexthop; nexthop = nexthop->next)
- if ((CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
- || CHECK_FLAG(nexthop->flags,
- NEXTHOP_FLAG_RECURSIVE))
- && CHECK_FLAG(nexthop->flags,
- NEXTHOP_FLAG_ACTIVE)) {
- stream_putc(s, nexthop->type);
- switch (nexthop->type) {
+ for (nh = re->ng.nexthop; nh; nh = nh->next)
+ if ((CHECK_FLAG(nh->flags, NEXTHOP_FLAG_FIB)
+ || CHECK_FLAG(nh->flags, NEXTHOP_FLAG_RECURSIVE))
+ && CHECK_FLAG(nh->flags, NEXTHOP_FLAG_ACTIVE)) {
+ stream_putc(s, nh->type);
+ switch (nh->type) {
case NEXTHOP_TYPE_IPV4:
case NEXTHOP_TYPE_IPV4_IFINDEX:
- stream_put_in_addr(s,
- &nexthop->gate.ipv4);
- stream_putl(s, nexthop->ifindex);
+ stream_put_in_addr(s, &nh->gate.ipv4);
+ stream_putl(s, nh->ifindex);
break;
case NEXTHOP_TYPE_IFINDEX:
- stream_putl(s, nexthop->ifindex);
+ stream_putl(s, nh->ifindex);
break;
case NEXTHOP_TYPE_IPV6:
case NEXTHOP_TYPE_IPV6_IFINDEX:
- stream_put(s, &nexthop->gate.ipv6, 16);
- stream_putl(s, nexthop->ifindex);
+ stream_put(s, &nh->gate.ipv6, 16);
+ stream_putl(s, nh->ifindex);
break;
default:
/* do nothing */
break;
}
+ if (nh->nh_label) {
+ stream_putc(s,
+ nh->nh_label->num_labels);
+ if (nh->nh_label->num_labels)
+ stream_put(
+ s,
+ &nh->nh_label->label[0],
+ nh->nh_label->num_labels
+ * sizeof(mpls_label_t));
+ } else
+ stream_putc(s, 0);
num++;
}
stream_putc_at(s, nump, num);
client->nh_last_upd_time = monotime(NULL);
client->last_write_cmd = cmd;
- return zebra_server_send_message(client);
+ return zserv_send_message(client, s);
}
static void print_nh(struct nexthop *nexthop, struct vty *vty)
if (rnh->state) {
vty_out(vty, " resolved via %s\n",
zebra_route_string(rnh->state->type));
- for (nexthop = rnh->state->nexthop; nexthop;
+ for (nexthop = rnh->state->ng.nexthop; nexthop;
nexthop = nexthop->next)
print_nh(nexthop, vty);
} else
vty_out(vty, " %s(fd %d)%s", zebra_route_string(client->proto),
client->sock,
rnh->filtered[client->proto] ? "(filtered)" : "");
- if (!list_isempty(rnh->zebra_static_route_list))
- vty_out(vty, " zebra%s",
- rnh->filtered[ZEBRA_ROUTE_STATIC] ? "(filtered)" : "");
if (!list_isempty(rnh->zebra_pseudowire_list))
vty_out(vty, " zebra[pseudowires]");
vty_out(vty, "\n");
}
+
+static int zebra_cleanup_rnh_client(vrf_id_t vrf_id, int family,
+ struct zserv *client, rnh_type_t type)
+{
+ struct route_table *ntable;
+ struct route_node *nrn;
+ struct rnh *rnh;
+
+ if (IS_ZEBRA_DEBUG_NHT)
+ zlog_debug("%u: Client %s RNH cleanup for family %d type %d",
+ vrf_id, zebra_route_string(client->proto), family,
+ type);
+
+ ntable = get_rnh_table(vrf_id, family, type);
+ if (!ntable) {
+ zlog_debug("cleanup_rnh_client: rnh table not found\n");
+ return -1;
+ }
+
+ for (nrn = route_top(ntable); nrn; nrn = route_next(nrn)) {
+ if (!nrn->info)
+ continue;
+
+ rnh = nrn->info;
+ zebra_remove_rnh_client(rnh, client, type);
+ }
+ return 1;
+}
+
+/* Cleanup registered nexthops (across VRFs) upon client disconnect. */
+static int zebra_client_cleanup_rnh(struct zserv *client)
+{
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+
+ RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
+ zvrf = vrf->info;
+ if (zvrf) {
+ zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET, client,
+ RNH_NEXTHOP_TYPE);
+ zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET6,
+ client, RNH_NEXTHOP_TYPE);
+ zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET, client,
+ RNH_IMPORT_CHECK_TYPE);
+ zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET6,
+ client, RNH_IMPORT_CHECK_TYPE);
+ if (client->proto == ZEBRA_ROUTE_LDP) {
+ hash_iterate(zvrf->lsp_table,
+ mpls_ldp_lsp_uninstall_all,
+ zvrf->lsp_table);
+ mpls_ldp_ftn_uninstall_all(zvrf, AFI_IP);
+ mpls_ldp_ftn_uninstall_all(zvrf, AFI_IP6);
+ }
+ }
+ }
+
+ return 0;
+}
projects / mirror_frr.git / blobdiff