1 /* Zebra next hop tracking code
2 * Copyright (C) 2013 Cumulus Networks, Inc.
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "sockunion.h"
32 #include "workqueue.h"
39 #include "zebra/zebra_router.h"
40 #include "zebra/rib.h"
42 #include "zebra/zserv.h"
43 #include "zebra/zebra_ns.h"
44 #include "zebra/zebra_vrf.h"
45 #include "zebra/redistribute.h"
46 #include "zebra/debug.h"
47 #include "zebra/zebra_rnh.h"
48 #include "zebra/zebra_routemap.h"
49 #include "zebra/interface.h"
50 #include "zebra/zebra_memory.h"
51 #include "zebra/zebra_errors.h"
53 static void free_state(vrf_id_t vrf_id
, struct route_entry
*re
,
54 struct route_node
*rn
);
55 static void copy_state(struct rnh
*rnh
, struct route_entry
*re
,
56 struct route_node
*rn
);
57 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
);
58 static int send_client(struct rnh
*rnh
, struct zserv
*client
, rnh_type_t type
,
60 static void print_rnh(struct route_node
*rn
, struct vty
*vty
);
61 static int zebra_client_cleanup_rnh(struct zserv
*client
);
63 int zebra_rnh_ip_default_route
= 0;
64 int zebra_rnh_ipv6_default_route
= 0;
66 void zebra_rnh_init(void)
68 hook_register(zserv_client_close
, zebra_client_cleanup_rnh
);
71 static inline struct route_table
*get_rnh_table(vrf_id_t vrfid
, afi_t afi
,
74 struct zebra_vrf
*zvrf
;
75 struct route_table
*t
= NULL
;
77 zvrf
= zebra_vrf_lookup_by_id(vrfid
);
80 case RNH_NEXTHOP_TYPE
:
81 t
= zvrf
->rnh_table
[afi
];
83 case RNH_IMPORT_CHECK_TYPE
:
84 t
= zvrf
->import_check_table
[afi
];
91 char *rnh_str(struct rnh
*rnh
, char *buf
, int size
)
93 prefix2str(&(rnh
->node
->p
), buf
, size
);
97 static void zebra_rnh_remove_from_routing_table(struct rnh
*rnh
)
99 struct zebra_vrf
*zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
100 struct route_table
*table
= zvrf
->table
[rnh
->afi
][SAFI_UNICAST
];
101 struct route_node
*rn
;
107 rn
= route_node_match(table
, &rnh
->resolved_route
);
111 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
112 char buf
[PREFIX_STRLEN
];
113 char buf1
[PREFIX_STRLEN
];
115 zlog_debug("%s: %u:%s removed from tracking on %s",
116 __PRETTY_FUNCTION__
, rnh
->vrf_id
,
117 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
118 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
121 dest
= rib_dest_from_rnode(rn
);
122 rnh_list_del(&dest
->nht
, rnh
);
123 route_unlock_node(rn
);
126 static void zebra_rnh_store_in_routing_table(struct rnh
*rnh
)
128 struct zebra_vrf
*zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
129 struct route_table
*table
= zvrf
->table
[rnh
->afi
][SAFI_UNICAST
];
130 struct route_node
*rn
;
133 rn
= route_node_match(table
, &rnh
->resolved_route
);
137 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
138 char buf
[PREFIX_STRLEN
];
139 char buf1
[PREFIX_STRLEN
];
141 zlog_debug("%s: %u:%s added for tracking on %s",
142 __PRETTY_FUNCTION__
, rnh
->vrf_id
,
143 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
144 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
147 dest
= rib_dest_from_rnode(rn
);
148 rnh_list_add_tail(&dest
->nht
, rnh
);
149 route_unlock_node(rn
);
152 struct rnh
*zebra_add_rnh(struct prefix
*p
, vrf_id_t vrfid
, rnh_type_t type
,
155 struct route_table
*table
;
156 struct route_node
*rn
;
157 struct rnh
*rnh
= NULL
;
158 char buf
[PREFIX2STR_BUFFER
];
159 afi_t afi
= family2afi(p
->family
);
161 if (IS_ZEBRA_DEBUG_NHT
) {
162 prefix2str(p
, buf
, sizeof(buf
));
163 zlog_debug("%u: Add RNH %s type %d", vrfid
, buf
, type
);
165 table
= get_rnh_table(vrfid
, afi
, type
);
167 prefix2str(p
, buf
, sizeof(buf
));
168 flog_warn(EC_ZEBRA_RNH_NO_TABLE
,
169 "%u: Add RNH %s type %d - table not found", vrfid
,
175 /* Make it sure prefixlen is applied to the prefix. */
178 /* Lookup (or add) route node.*/
179 rn
= route_node_get(table
, p
);
182 rnh
= XCALLOC(MTYPE_RNH
, sizeof(struct rnh
));
185 * The resolved route is already 0.0.0.0/0 or
186 * 0::0/0 due to the calloc right above, but
187 * we should set the family so that future
188 * comparisons can just be done
190 rnh
->resolved_route
.family
= p
->family
;
191 rnh
->client_list
= list_new();
196 rnh
->zebra_pseudowire_list
= list_new();
202 zebra_rnh_store_in_routing_table(rnh
);
206 route_unlock_node(rn
);
210 struct rnh
*zebra_lookup_rnh(struct prefix
*p
, vrf_id_t vrfid
, rnh_type_t type
)
212 struct route_table
*table
;
213 struct route_node
*rn
;
215 table
= get_rnh_table(vrfid
, family2afi(PREFIX_FAMILY(p
)), type
);
219 /* Make it sure prefixlen is applied to the prefix. */
222 /* Lookup route node.*/
223 rn
= route_node_lookup(table
, p
);
227 route_unlock_node(rn
);
231 void zebra_free_rnh(struct rnh
*rnh
)
233 struct zebra_vrf
*zvrf
;
234 struct route_table
*table
;
236 zebra_rnh_remove_from_routing_table(rnh
);
237 rnh
->flags
|= ZEBRA_NHT_DELETED
;
238 list_delete(&rnh
->client_list
);
239 list_delete(&rnh
->zebra_pseudowire_list
);
241 zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
242 table
= zvrf
->table
[family2afi(rnh
->resolved_route
.family
)][SAFI_UNICAST
];
245 struct route_node
*rern
;
247 rern
= route_node_match(table
, &rnh
->resolved_route
);
251 route_unlock_node(rern
);
253 dest
= rib_dest_from_rnode(rern
);
254 rnh_list_del(&dest
->nht
, rnh
);
257 free_state(rnh
->vrf_id
, rnh
->state
, rnh
->node
);
258 XFREE(MTYPE_RNH
, rnh
);
261 static void zebra_delete_rnh(struct rnh
*rnh
, rnh_type_t type
)
263 struct route_node
*rn
;
265 if (!list_isempty(rnh
->client_list
)
266 || !list_isempty(rnh
->zebra_pseudowire_list
))
269 if ((rnh
->flags
& ZEBRA_NHT_DELETED
) || !(rn
= rnh
->node
))
272 if (IS_ZEBRA_DEBUG_NHT
) {
273 char buf
[PREFIX2STR_BUFFER
];
274 zlog_debug("%u: Del RNH %s type %d", rnh
->vrf_id
,
275 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
280 route_unlock_node(rn
);
284 * This code will send to the registering client
286 * For a rnh that was created, there is no data
287 * so it will send an empty nexthop group
288 * If rnh exists then we know it has been evaluated
289 * and as such it will have a resolved rnh.
291 void zebra_add_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
292 rnh_type_t type
, vrf_id_t vrf_id
)
294 if (IS_ZEBRA_DEBUG_NHT
) {
295 char buf
[PREFIX2STR_BUFFER
];
296 zlog_debug("%u: Client %s registers for RNH %s type %d", vrf_id
,
297 zebra_route_string(client
->proto
),
298 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
300 if (!listnode_lookup(rnh
->client_list
, client
))
301 listnode_add(rnh
->client_list
, client
);
304 * We always need to respond with known information,
305 * currently multiple daemons expect this behavior
307 send_client(rnh
, client
, type
, vrf_id
);
310 void zebra_remove_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
313 if (IS_ZEBRA_DEBUG_NHT
) {
314 char buf
[PREFIX2STR_BUFFER
];
315 zlog_debug("Client %s unregisters for RNH %s type %d",
316 zebra_route_string(client
->proto
),
317 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
319 listnode_delete(rnh
->client_list
, client
);
320 zebra_delete_rnh(rnh
, type
);
323 /* XXX move this utility function elsewhere? */
324 static void addr2hostprefix(int af
, const union g_addr
*addr
,
325 struct prefix
*prefix
)
329 prefix
->family
= AF_INET
;
330 prefix
->prefixlen
= IPV4_MAX_BITLEN
;
331 prefix
->u
.prefix4
= addr
->ipv4
;
334 prefix
->family
= AF_INET6
;
335 prefix
->prefixlen
= IPV6_MAX_BITLEN
;
336 prefix
->u
.prefix6
= addr
->ipv6
;
339 memset(prefix
, 0, sizeof(*prefix
));
340 zlog_debug("%s: unknown address family %d", __func__
, af
);
345 void zebra_register_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
350 struct zebra_vrf
*zvrf
;
352 zvrf
= vrf_info_lookup(vrf_id
);
356 addr2hostprefix(pw
->af
, &pw
->nexthop
, &nh
);
357 rnh
= zebra_add_rnh(&nh
, vrf_id
, RNH_NEXTHOP_TYPE
, &exists
);
358 if (rnh
&& !listnode_lookup(rnh
->zebra_pseudowire_list
, pw
)) {
359 listnode_add(rnh
->zebra_pseudowire_list
, pw
);
361 zebra_evaluate_rnh(zvrf
, family2afi(pw
->af
), 1,
362 RNH_NEXTHOP_TYPE
, &nh
);
366 void zebra_deregister_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
374 listnode_delete(rnh
->zebra_pseudowire_list
, pw
);
377 zebra_delete_rnh(rnh
, RNH_NEXTHOP_TYPE
);
380 /* Clear the NEXTHOP_FLAG_RNH_FILTERED flags on all nexthops
382 static void zebra_rnh_clear_nexthop_rnh_filters(struct route_entry
*re
)
384 struct nexthop
*nexthop
;
387 for (nexthop
= re
->ng
.nexthop
; nexthop
;
388 nexthop
= nexthop
->next
) {
389 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_RNH_FILTERED
);
394 /* Apply the NHT route-map for a client to the route (and nexthops)
397 static int zebra_rnh_apply_nht_rmap(afi_t afi
, struct zebra_vrf
*zvrf
,
398 struct route_node
*prn
,
399 struct route_entry
*re
, int proto
)
401 int at_least_one
= 0;
402 struct nexthop
*nexthop
;
406 for (nexthop
= re
->ng
.nexthop
; nexthop
;
407 nexthop
= nexthop
->next
) {
408 ret
= zebra_nht_route_map_check(
409 afi
, proto
, &prn
->p
, zvrf
, re
, nexthop
);
410 if (ret
!= RMAP_DENYMATCH
)
411 at_least_one
++; /* at least one valid NH */
413 SET_FLAG(nexthop
->flags
,
414 NEXTHOP_FLAG_RNH_FILTERED
);
418 return (at_least_one
);
422 * Determine appropriate route (RE entry) resolving a tracked BGP route
423 * for BGP route for import.
425 static struct route_entry
*
426 zebra_rnh_resolve_import_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
427 struct route_node
*nrn
, struct rnh
*rnh
,
428 struct route_node
**prn
)
430 struct route_table
*route_table
;
431 struct route_node
*rn
;
432 struct route_entry
*re
;
436 route_table
= zvrf
->table
[afi
][SAFI_UNICAST
];
437 if (!route_table
) // unexpected
440 rn
= route_node_match(route_table
, &nrn
->p
);
444 /* Unlock route node - we don't need to lock when walking the tree. */
445 route_unlock_node(rn
);
447 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_EXACT_MATCH
)
448 && !prefix_same(&nrn
->p
, &rn
->p
))
451 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
452 char buf
[PREFIX_STRLEN
];
453 char buf1
[PREFIX_STRLEN
];
455 zlog_debug("%s: %u:%s Resolved Import Entry to %s",
456 __PRETTY_FUNCTION__
, rnh
->vrf_id
,
457 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
458 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
461 /* Identify appropriate route entry. */
462 RNODE_FOREACH_RE (rn
, re
) {
463 if (!CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
)
464 && CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
)
465 && (re
->type
!= ZEBRA_ROUTE_BGP
))
472 if (!re
&& IS_ZEBRA_DEBUG_NHT_DETAILED
)
473 zlog_debug("\tRejected due to removed or is a bgp route");
479 * See if a tracked route entry for import (by BGP) has undergone any
480 * change, and if so, notify the client.
482 static void zebra_rnh_eval_import_check_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
483 int force
, struct route_node
*nrn
,
485 struct route_node
*prn
,
486 struct route_entry
*re
)
488 int state_changed
= 0;
489 struct zserv
*client
;
490 char bufn
[INET6_ADDRSTRLEN
];
491 struct listnode
*node
;
493 zebra_rnh_remove_from_routing_table(rnh
);
495 prefix_copy(&rnh
->resolved_route
, &prn
->p
);
497 int family
= rnh
->resolved_route
.family
;
499 memset(&rnh
->resolved_route
.family
, 0, sizeof(struct prefix
));
500 rnh
->resolved_route
.family
= family
;
502 zebra_rnh_store_in_routing_table(rnh
);
504 if (re
&& (rnh
->state
== NULL
)) {
505 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
))
507 } else if (!re
&& (rnh
->state
!= NULL
))
510 if (compare_state(re
, rnh
->state
)) {
511 copy_state(rnh
, re
, nrn
);
515 if (state_changed
|| force
) {
516 if (IS_ZEBRA_DEBUG_NHT
) {
517 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
518 zlog_debug("%u:%s: Route import check %s %s",
520 bufn
, rnh
->state
? "passed" : "failed",
521 state_changed
? "(state changed)" : "");
523 /* state changed, notify clients */
524 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
525 send_client(rnh
, client
,
526 RNH_IMPORT_CHECK_TYPE
, zvrf
->vrf
->vrf_id
);
532 * Notify clients registered for this nexthop about a change.
534 static void zebra_rnh_notify_protocol_clients(struct zebra_vrf
*zvrf
, afi_t afi
,
535 struct route_node
*nrn
,
537 struct route_node
*prn
,
538 struct route_entry
*re
)
540 struct listnode
*node
;
541 struct zserv
*client
;
542 char bufn
[INET6_ADDRSTRLEN
];
543 char bufp
[INET6_ADDRSTRLEN
];
544 int num_resolving_nh
;
546 if (IS_ZEBRA_DEBUG_NHT
) {
547 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
549 srcdest_rnode2str(prn
, bufp
, INET6_ADDRSTRLEN
);
550 zlog_debug("%u:%s: NH resolved over route %s",
551 zvrf
->vrf
->vrf_id
, bufn
, bufp
);
553 zlog_debug("%u:%s: NH has become unresolved",
554 zvrf
->vrf
->vrf_id
, bufn
);
557 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
559 /* Apply route-map for this client to route resolving
561 * nexthop to see if it is filtered or not.
563 zebra_rnh_clear_nexthop_rnh_filters(re
);
564 num_resolving_nh
= zebra_rnh_apply_nht_rmap(
565 afi
, zvrf
, prn
, re
, client
->proto
);
566 if (num_resolving_nh
)
567 rnh
->filtered
[client
->proto
] = 0;
569 rnh
->filtered
[client
->proto
] = 1;
571 if (IS_ZEBRA_DEBUG_NHT
)
573 "%u:%s: Notifying client %s about NH %s",
574 zvrf
->vrf
->vrf_id
, bufn
,
575 zebra_route_string(client
->proto
),
578 : "(filtered by route-map)");
580 rnh
->filtered
[client
->proto
] = 0;
581 if (IS_ZEBRA_DEBUG_NHT
)
583 "%u:%s: Notifying client %s about NH (unreachable)",
584 zvrf
->vrf
->vrf_id
, bufn
,
585 zebra_route_string(client
->proto
));
588 send_client(rnh
, client
, RNH_NEXTHOP_TYPE
, zvrf
->vrf
->vrf_id
);
592 zebra_rnh_clear_nexthop_rnh_filters(re
);
595 static void zebra_rnh_process_pbr_tables(afi_t afi
, struct route_node
*nrn
,
597 struct route_node
*prn
,
598 struct route_entry
*re
)
600 struct zebra_router_table
*zrt
;
601 struct route_entry
*o_re
;
602 struct route_node
*o_rn
;
603 struct listnode
*node
;
604 struct zserv
*client
;
607 * We are only concerned about nexthops that change for
610 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
611 if (client
->proto
== ZEBRA_ROUTE_PBR
)
618 RB_FOREACH (zrt
, zebra_router_table_head
, &zrouter
.tables
) {
622 for (o_rn
= route_top(zrt
->table
); o_rn
;
623 o_rn
= srcdest_route_next(o_rn
)) {
624 RNODE_FOREACH_RE (o_rn
, o_re
) {
625 if (o_re
->type
== ZEBRA_ROUTE_PBR
)
631 * If we have a PBR route and a nexthop changes
632 * just rethink it. Yes this is a hammer, but
636 SET_FLAG(o_re
->status
, ROUTE_ENTRY_CHANGED
);
644 * Utility to determine whether a candidate nexthop is useable. We make this
645 * check in a couple of places, so this is a single home for the logic we
648 static bool rnh_nexthop_valid(const struct route_entry
*re
,
649 const struct nexthop
*nh
)
651 return (CHECK_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
)
652 && CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_ACTIVE
)
653 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_RECURSIVE
)
654 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_DUPLICATE
)
655 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_RNH_FILTERED
));
659 * Determine appropriate route (route entry) resolving a tracked
662 static struct route_entry
*
663 zebra_rnh_resolve_nexthop_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
664 struct route_node
*nrn
, struct rnh
*rnh
,
665 struct route_node
**prn
)
667 struct route_table
*route_table
;
668 struct route_node
*rn
;
669 struct route_entry
*re
;
670 struct nexthop
*nexthop
;
674 route_table
= zvrf
->table
[afi
][SAFI_UNICAST
];
678 rn
= route_node_match(route_table
, &nrn
->p
);
682 /* Unlock route node - we don't need to lock when walking the tree. */
683 route_unlock_node(rn
);
685 /* While resolving nexthops, we may need to walk up the tree from the
686 * most-specific match. Do similar logic as in zebra_rib.c
689 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
690 char buf
[PREFIX_STRLEN
];
691 char buf1
[PREFIX_STRLEN
];
693 zlog_debug("%s: %u:%s Possible Match to %s",
694 __PRETTY_FUNCTION__
, rnh
->vrf_id
,
695 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
696 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
699 /* Do not resolve over default route unless allowed &&
700 * match route to be exact if so specified
702 if (is_default_prefix(&rn
->p
)
703 && !rnh_resolve_via_default(rn
->p
.family
)) {
704 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
706 "\tNot allowed to resolve through default prefix");
710 /* Identify appropriate route entry. */
711 RNODE_FOREACH_RE (rn
, re
) {
712 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
)) {
713 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
715 "\tRoute Entry %s removed",
716 zebra_route_string(re
->type
));
719 if (!CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
)) {
720 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
722 "\tRoute Entry %s !selected",
723 zebra_route_string(re
->type
));
727 /* Just being SELECTED isn't quite enough - must
728 * have an installed nexthop to be useful.
730 for (ALL_NEXTHOPS(re
->ng
, nexthop
)) {
731 if (rnh_nexthop_valid(re
, nexthop
))
735 if (nexthop
== NULL
) {
736 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
738 "\tRoute Entry %s no nexthops",
739 zebra_route_string(re
->type
));
743 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)) {
744 if ((re
->type
== ZEBRA_ROUTE_CONNECT
)
745 || (re
->type
== ZEBRA_ROUTE_STATIC
))
747 if (re
->type
== ZEBRA_ROUTE_NHRP
) {
749 for (nexthop
= re
->ng
.nexthop
; nexthop
;
750 nexthop
= nexthop
->next
)
752 == NEXTHOP_TYPE_IFINDEX
)
761 /* Route entry found, we're done; else, walk up the tree. */
767 if (!CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
))
770 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
772 "\tNexthop must be connected, cannot recurse up");
780 static void zebra_rnh_process_pseudowires(vrf_id_t vrfid
, struct rnh
*rnh
)
783 struct listnode
*node
;
785 for (ALL_LIST_ELEMENTS_RO(rnh
->zebra_pseudowire_list
, node
, pw
))
790 * See if a tracked nexthop entry has undergone any change, and if so,
791 * take appropriate action; this involves notifying any clients and/or
792 * scheduling dependent static routes for processing.
794 static void zebra_rnh_eval_nexthop_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
795 int force
, struct route_node
*nrn
,
797 struct route_node
*prn
,
798 struct route_entry
*re
)
800 int state_changed
= 0;
802 /* If we're resolving over a different route, resolution has changed or
803 * the resolving route has some change (e.g., metric), there is a state
806 zebra_rnh_remove_from_routing_table(rnh
);
807 if (!prefix_same(&rnh
->resolved_route
, prn
? NULL
: &prn
->p
)) {
809 prefix_copy(&rnh
->resolved_route
, &prn
->p
);
812 * Just quickly store the family of the resolved
813 * route so that we can reset it in a second here
815 int family
= rnh
->resolved_route
.family
;
817 memset(&rnh
->resolved_route
, 0, sizeof(struct prefix
));
818 rnh
->resolved_route
.family
= family
;
821 copy_state(rnh
, re
, nrn
);
823 } else if (compare_state(re
, rnh
->state
)) {
824 copy_state(rnh
, re
, nrn
);
827 zebra_rnh_store_in_routing_table(rnh
);
829 if (state_changed
|| force
) {
830 /* NOTE: Use the "copy" of resolving route stored in 'rnh' i.e.,
833 /* Notify registered protocol clients. */
834 zebra_rnh_notify_protocol_clients(zvrf
, afi
, nrn
, rnh
, prn
,
837 zebra_rnh_process_pbr_tables(afi
, nrn
, rnh
, prn
, rnh
->state
);
839 /* Process pseudowires attached to this nexthop */
840 zebra_rnh_process_pseudowires(zvrf
->vrf
->vrf_id
, rnh
);
844 /* Evaluate one tracked entry */
845 static void zebra_rnh_evaluate_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
846 int force
, rnh_type_t type
,
847 struct route_node
*nrn
)
850 struct route_entry
*re
;
851 struct route_node
*prn
;
852 char bufn
[INET6_ADDRSTRLEN
];
854 if (IS_ZEBRA_DEBUG_NHT
) {
855 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
856 zlog_debug("%u:%s: Evaluate RNH, type %d %s", zvrf
->vrf
->vrf_id
,
857 bufn
, type
, force
? "(force)" : "");
862 /* Identify route entry (RE) resolving this tracked entry. */
863 if (type
== RNH_IMPORT_CHECK_TYPE
)
864 re
= zebra_rnh_resolve_import_entry(zvrf
, afi
, nrn
, rnh
, &prn
);
866 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, afi
, nrn
, rnh
, &prn
);
868 /* If the entry cannot be resolved and that is also the existing state,
869 * there is nothing further to do.
871 if (!re
&& rnh
->state
== NULL
&& !force
)
874 /* Process based on type of entry. */
875 if (type
== RNH_IMPORT_CHECK_TYPE
)
876 zebra_rnh_eval_import_check_entry(zvrf
, afi
, force
, nrn
, rnh
,
879 zebra_rnh_eval_nexthop_entry(zvrf
, afi
, force
, nrn
, rnh
, prn
,
884 * Clear the ROUTE_ENTRY_NEXTHOPS_CHANGED flag
885 * from the re entries.
887 * Please note we are doing this *after* we have
888 * notified the world about each nexthop as that
889 * we can have a situation where one re entry
890 * covers multiple nexthops we are interested in.
892 static void zebra_rnh_clear_nhc_flag(struct zebra_vrf
*zvrf
, afi_t afi
,
893 rnh_type_t type
, struct route_node
*nrn
)
896 struct route_entry
*re
;
897 struct route_node
*prn
;
901 /* Identify route entry (RIB) resolving this tracked entry. */
902 if (type
== RNH_IMPORT_CHECK_TYPE
)
903 re
= zebra_rnh_resolve_import_entry(zvrf
, afi
, nrn
, rnh
,
906 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, afi
, nrn
, rnh
,
910 UNSET_FLAG(re
->status
, ROUTE_ENTRY_NEXTHOPS_CHANGED
);
911 UNSET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
915 /* Evaluate all tracked entries (nexthops or routes for import into BGP)
916 * of a particular VRF and address-family or a specific prefix.
918 void zebra_evaluate_rnh(struct zebra_vrf
*zvrf
, afi_t afi
, int force
,
919 rnh_type_t type
, struct prefix
*p
)
921 struct route_table
*rnh_table
;
922 struct route_node
*nrn
;
924 rnh_table
= get_rnh_table(zvrf
->vrf
->vrf_id
, afi
, type
);
925 if (!rnh_table
) // unexpected
929 /* Evaluating a specific entry, make sure it exists. */
930 nrn
= route_node_lookup(rnh_table
, p
);
931 if (nrn
&& nrn
->info
)
932 zebra_rnh_evaluate_entry(zvrf
, afi
, force
, type
, nrn
);
935 route_unlock_node(nrn
);
937 /* Evaluate entire table. */
938 nrn
= route_top(rnh_table
);
941 zebra_rnh_evaluate_entry(zvrf
, afi
, force
, type
,
943 nrn
= route_next(nrn
); /* this will also unlock nrn */
945 nrn
= route_top(rnh_table
);
948 zebra_rnh_clear_nhc_flag(zvrf
, afi
, type
, nrn
);
949 nrn
= route_next(nrn
); /* this will also unlock nrn */
954 void zebra_print_rnh_table(vrf_id_t vrfid
, afi_t afi
, struct vty
*vty
,
955 rnh_type_t type
, struct prefix
*p
)
957 struct route_table
*table
;
958 struct route_node
*rn
;
960 table
= get_rnh_table(vrfid
, afi
, type
);
962 zlog_debug("print_rnhs: rnh table not found");
966 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
967 if (p
&& prefix_cmp(&rn
->p
, p
) != 0)
976 * free_state - free up the re structure associated with the rnh.
978 static void free_state(vrf_id_t vrf_id
, struct route_entry
*re
,
979 struct route_node
*rn
)
984 /* free RE and nexthops */
985 nexthops_free(re
->ng
.nexthop
);
989 static void copy_state(struct rnh
*rnh
, struct route_entry
*re
,
990 struct route_node
*rn
)
992 struct route_entry
*state
;
995 free_state(rnh
->vrf_id
, rnh
->state
, rn
);
1002 state
= XCALLOC(MTYPE_RE
, sizeof(struct route_entry
));
1003 state
->type
= re
->type
;
1004 state
->distance
= re
->distance
;
1005 state
->metric
= re
->metric
;
1006 state
->vrf_id
= re
->vrf_id
;
1007 state
->status
= re
->status
;
1009 route_entry_copy_nexthops(state
, re
->ng
.nexthop
);
1013 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
)
1019 if ((!r1
&& r2
) || (r1
&& !r2
))
1022 if (r1
->distance
!= r2
->distance
)
1025 if (r1
->metric
!= r2
->metric
)
1028 if (r1
->nexthop_num
!= r2
->nexthop_num
)
1031 if (CHECK_FLAG(r1
->status
, ROUTE_ENTRY_NEXTHOPS_CHANGED
)
1032 || CHECK_FLAG(r1
->status
, ROUTE_ENTRY_LABELS_CHANGED
))
1038 static int send_client(struct rnh
*rnh
, struct zserv
*client
, rnh_type_t type
,
1042 struct route_entry
*re
;
1046 struct route_node
*rn
;
1047 int cmd
= (type
== RNH_IMPORT_CHECK_TYPE
) ? ZEBRA_IMPORT_CHECK_UPDATE
1048 : ZEBRA_NEXTHOP_UPDATE
;
1053 /* Get output stream. */
1054 s
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
1056 zclient_create_header(s
, cmd
, vrf_id
);
1058 stream_putw(s
, rn
->p
.family
);
1059 switch (rn
->p
.family
) {
1061 stream_putc(s
, rn
->p
.prefixlen
);
1062 stream_put_in_addr(s
, &rn
->p
.u
.prefix4
);
1065 stream_putc(s
, rn
->p
.prefixlen
);
1066 stream_put(s
, &rn
->p
.u
.prefix6
, IPV6_MAX_BYTELEN
);
1069 flog_err(EC_ZEBRA_RNH_UNKNOWN_FAMILY
,
1070 "%s: Unknown family (%d) notification attempted\n",
1071 __FUNCTION__
, rn
->p
.family
);
1075 stream_putc(s
, re
->type
);
1076 stream_putw(s
, re
->instance
);
1077 stream_putc(s
, re
->distance
);
1078 stream_putl(s
, re
->metric
);
1080 nump
= stream_get_endp(s
);
1082 for (ALL_NEXTHOPS(re
->ng
, nh
))
1083 if (rnh_nexthop_valid(re
, nh
)) {
1084 stream_putl(s
, nh
->vrf_id
);
1085 stream_putc(s
, nh
->type
);
1087 case NEXTHOP_TYPE_IPV4
:
1088 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1089 stream_put_in_addr(s
, &nh
->gate
.ipv4
);
1090 stream_putl(s
, nh
->ifindex
);
1092 case NEXTHOP_TYPE_IFINDEX
:
1093 stream_putl(s
, nh
->ifindex
);
1095 case NEXTHOP_TYPE_IPV6
:
1096 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1097 stream_put(s
, &nh
->gate
.ipv6
, 16);
1098 stream_putl(s
, nh
->ifindex
);
1106 nh
->nh_label
->num_labels
);
1107 if (nh
->nh_label
->num_labels
)
1110 &nh
->nh_label
->label
[0],
1111 nh
->nh_label
->num_labels
1112 * sizeof(mpls_label_t
));
1117 stream_putc_at(s
, nump
, num
);
1119 stream_putc(s
, 0); // type
1120 stream_putw(s
, 0); // instance
1121 stream_putc(s
, 0); // distance
1122 stream_putl(s
, 0); // metric
1123 stream_putc(s
, 0); // nexthops
1125 stream_putw_at(s
, 0, stream_get_endp(s
));
1127 client
->nh_last_upd_time
= monotime(NULL
);
1128 client
->last_write_cmd
= cmd
;
1129 return zserv_send_message(client
, s
);
1132 static void print_nh(struct nexthop
*nexthop
, struct vty
*vty
)
1135 struct zebra_ns
*zns
= zebra_ns_lookup(NS_DEFAULT
);
1137 switch (nexthop
->type
) {
1138 case NEXTHOP_TYPE_IPV4
:
1139 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1140 vty_out(vty
, " via %s", inet_ntoa(nexthop
->gate
.ipv4
));
1141 if (nexthop
->ifindex
)
1142 vty_out(vty
, ", %s",
1143 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1145 case NEXTHOP_TYPE_IPV6
:
1146 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1148 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, BUFSIZ
));
1149 if (nexthop
->ifindex
)
1150 vty_out(vty
, ", via %s",
1151 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1153 case NEXTHOP_TYPE_IFINDEX
:
1154 vty_out(vty
, " is directly connected, %s",
1155 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1157 case NEXTHOP_TYPE_BLACKHOLE
:
1158 vty_out(vty
, " is directly connected, Null0");
1166 static void print_rnh(struct route_node
*rn
, struct vty
*vty
)
1169 struct nexthop
*nexthop
;
1170 struct listnode
*node
;
1171 struct zserv
*client
;
1175 vty_out(vty
, "%s%s\n",
1176 inet_ntop(rn
->p
.family
, &rn
->p
.u
.prefix
, buf
, BUFSIZ
),
1177 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
) ? "(Connected)"
1180 vty_out(vty
, " resolved via %s\n",
1181 zebra_route_string(rnh
->state
->type
));
1182 for (nexthop
= rnh
->state
->ng
.nexthop
; nexthop
;
1183 nexthop
= nexthop
->next
)
1184 print_nh(nexthop
, vty
);
1186 vty_out(vty
, " unresolved%s\n",
1187 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)
1191 vty_out(vty
, " Client list:");
1192 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
))
1193 vty_out(vty
, " %s(fd %d)%s", zebra_route_string(client
->proto
),
1195 rnh
->filtered
[client
->proto
] ? "(filtered)" : "");
1196 if (!list_isempty(rnh
->zebra_pseudowire_list
))
1197 vty_out(vty
, " zebra[pseudowires]");
1201 static int zebra_cleanup_rnh_client(vrf_id_t vrf_id
, afi_t afi
,
1202 struct zserv
*client
, rnh_type_t type
)
1204 struct route_table
*ntable
;
1205 struct route_node
*nrn
;
1208 if (IS_ZEBRA_DEBUG_NHT
)
1209 zlog_debug("%u: Client %s RNH cleanup for family %s type %d",
1210 vrf_id
, zebra_route_string(client
->proto
),
1211 afi2str(afi
), type
);
1213 ntable
= get_rnh_table(vrf_id
, afi
, type
);
1215 zlog_debug("cleanup_rnh_client: rnh table not found");
1219 for (nrn
= route_top(ntable
); nrn
; nrn
= route_next(nrn
)) {
1224 zebra_remove_rnh_client(rnh
, client
, type
);
1229 /* Cleanup registered nexthops (across VRFs) upon client disconnect. */
1230 static int zebra_client_cleanup_rnh(struct zserv
*client
)
1233 struct zebra_vrf
*zvrf
;
1235 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
1238 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP
, client
,
1240 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP6
, client
,
1242 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP
, client
,
1243 RNH_IMPORT_CHECK_TYPE
);
1244 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP6
, client
,
1245 RNH_IMPORT_CHECK_TYPE
);
1246 if (client
->proto
== ZEBRA_ROUTE_LDP
) {
1247 hash_iterate(zvrf
->lsp_table
,
1248 mpls_ldp_lsp_uninstall_all
,
1250 mpls_ldp_ftn_uninstall_all(zvrf
, AFI_IP
);
1251 mpls_ldp_ftn_uninstall_all(zvrf
, AFI_IP6
);