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 DEFINE_MTYPE_STATIC(ZEBRA
, RNH
, "Nexthop tracking object")
55 static void free_state(vrf_id_t vrf_id
, struct route_entry
*re
,
56 struct route_node
*rn
);
57 static void copy_state(struct rnh
*rnh
, const struct route_entry
*re
,
58 struct route_node
*rn
);
59 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
);
60 static int send_client(struct rnh
*rnh
, struct zserv
*client
,
61 enum rnh_type type
, vrf_id_t vrf_id
);
62 static void print_rnh(struct route_node
*rn
, struct vty
*vty
);
63 static int zebra_client_cleanup_rnh(struct zserv
*client
);
65 void zebra_rnh_init(void)
67 hook_register(zserv_client_close
, zebra_client_cleanup_rnh
);
70 static inline struct route_table
*get_rnh_table(vrf_id_t vrfid
, afi_t afi
,
73 struct zebra_vrf
*zvrf
;
74 struct route_table
*t
= NULL
;
76 zvrf
= zebra_vrf_lookup_by_id(vrfid
);
79 case RNH_NEXTHOP_TYPE
:
80 t
= zvrf
->rnh_table
[afi
];
82 case RNH_IMPORT_CHECK_TYPE
:
83 t
= zvrf
->import_check_table
[afi
];
90 char *rnh_str(struct rnh
*rnh
, char *buf
, int size
)
92 prefix2str(&(rnh
->node
->p
), buf
, size
);
96 static void zebra_rnh_remove_from_routing_table(struct rnh
*rnh
)
98 struct zebra_vrf
*zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
99 struct route_table
*table
= zvrf
->table
[rnh
->afi
][SAFI_UNICAST
];
100 struct route_node
*rn
;
106 rn
= route_node_match(table
, &rnh
->resolved_route
);
110 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
111 char buf
[PREFIX_STRLEN
];
112 char buf1
[PREFIX_STRLEN
];
114 zlog_debug("%s: %u:%s removed from tracking on %s", __func__
,
116 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
117 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
120 dest
= rib_dest_from_rnode(rn
);
121 rnh_list_del(&dest
->nht
, rnh
);
122 route_unlock_node(rn
);
125 static void zebra_rnh_store_in_routing_table(struct rnh
*rnh
)
127 struct zebra_vrf
*zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
128 struct route_table
*table
= zvrf
->table
[rnh
->afi
][SAFI_UNICAST
];
129 struct route_node
*rn
;
132 rn
= route_node_match(table
, &rnh
->resolved_route
);
136 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
137 char buf
[PREFIX_STRLEN
];
138 char buf1
[PREFIX_STRLEN
];
140 zlog_debug("%s: %u:%s added for tracking on %s", __func__
,
142 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
143 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
146 dest
= rib_dest_from_rnode(rn
);
147 rnh_list_add_tail(&dest
->nht
, rnh
);
148 route_unlock_node(rn
);
151 struct rnh
*zebra_add_rnh(struct prefix
*p
, vrf_id_t vrfid
, enum rnh_type type
,
154 struct route_table
*table
;
155 struct route_node
*rn
;
156 struct rnh
*rnh
= NULL
;
157 char buf
[PREFIX2STR_BUFFER
];
158 afi_t afi
= family2afi(p
->family
);
160 if (IS_ZEBRA_DEBUG_NHT
) {
161 prefix2str(p
, buf
, sizeof(buf
));
162 zlog_debug("%u: Add RNH %s type %s", vrfid
, buf
,
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 %s - table not found", vrfid
,
170 buf
, rnh_type2str(type
));
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
,
213 struct route_table
*table
;
214 struct route_node
*rn
;
216 table
= get_rnh_table(vrfid
, family2afi(PREFIX_FAMILY(p
)), type
);
220 /* Make it sure prefixlen is applied to the prefix. */
223 /* Lookup route node.*/
224 rn
= route_node_lookup(table
, p
);
228 route_unlock_node(rn
);
232 void zebra_free_rnh(struct rnh
*rnh
)
234 struct zebra_vrf
*zvrf
;
235 struct route_table
*table
;
237 zebra_rnh_remove_from_routing_table(rnh
);
238 rnh
->flags
|= ZEBRA_NHT_DELETED
;
239 list_delete(&rnh
->client_list
);
240 list_delete(&rnh
->zebra_pseudowire_list
);
242 zvrf
= zebra_vrf_lookup_by_id(rnh
->vrf_id
);
243 table
= zvrf
->table
[family2afi(rnh
->resolved_route
.family
)][SAFI_UNICAST
];
246 struct route_node
*rern
;
248 rern
= route_node_match(table
, &rnh
->resolved_route
);
252 route_unlock_node(rern
);
254 dest
= rib_dest_from_rnode(rern
);
255 rnh_list_del(&dest
->nht
, rnh
);
258 free_state(rnh
->vrf_id
, rnh
->state
, rnh
->node
);
259 XFREE(MTYPE_RNH
, rnh
);
262 static void zebra_delete_rnh(struct rnh
*rnh
, enum rnh_type type
)
264 struct route_node
*rn
;
266 if (!list_isempty(rnh
->client_list
)
267 || !list_isempty(rnh
->zebra_pseudowire_list
))
270 if ((rnh
->flags
& ZEBRA_NHT_DELETED
) || !(rn
= rnh
->node
))
273 if (IS_ZEBRA_DEBUG_NHT
) {
274 char buf
[PREFIX2STR_BUFFER
];
275 zlog_debug("%u: Del RNH %s type %s", rnh
->vrf_id
,
276 rnh_str(rnh
, buf
, sizeof(buf
)), rnh_type2str(type
));
281 route_unlock_node(rn
);
285 * This code will send to the registering client
287 * For a rnh that was created, there is no data
288 * so it will send an empty nexthop group
289 * If rnh exists then we know it has been evaluated
290 * and as such it will have a resolved rnh.
292 void zebra_add_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
293 enum rnh_type type
, vrf_id_t vrf_id
)
295 if (IS_ZEBRA_DEBUG_NHT
) {
296 char buf
[PREFIX2STR_BUFFER
];
297 zlog_debug("%u: Client %s registers for RNH %s type %s", vrf_id
,
298 zebra_route_string(client
->proto
),
299 rnh_str(rnh
, buf
, sizeof(buf
)), rnh_type2str(type
));
301 if (!listnode_lookup(rnh
->client_list
, client
))
302 listnode_add(rnh
->client_list
, client
);
305 * We always need to respond with known information,
306 * currently multiple daemons expect this behavior
308 send_client(rnh
, client
, type
, vrf_id
);
311 void zebra_remove_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
314 if (IS_ZEBRA_DEBUG_NHT
) {
315 char buf
[PREFIX2STR_BUFFER
];
316 zlog_debug("Client %s unregisters for RNH %s type %s",
317 zebra_route_string(client
->proto
),
318 rnh_str(rnh
, buf
, sizeof(buf
)), rnh_type2str(type
));
320 listnode_delete(rnh
->client_list
, client
);
321 zebra_delete_rnh(rnh
, type
);
324 /* XXX move this utility function elsewhere? */
325 static void addr2hostprefix(int af
, const union g_addr
*addr
,
326 struct prefix
*prefix
)
330 prefix
->family
= AF_INET
;
331 prefix
->prefixlen
= IPV4_MAX_BITLEN
;
332 prefix
->u
.prefix4
= addr
->ipv4
;
335 prefix
->family
= AF_INET6
;
336 prefix
->prefixlen
= IPV6_MAX_BITLEN
;
337 prefix
->u
.prefix6
= addr
->ipv6
;
340 memset(prefix
, 0, sizeof(*prefix
));
341 zlog_warn("%s: unknown address family %d", __func__
, af
);
346 void zebra_register_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
351 struct zebra_vrf
*zvrf
;
353 zvrf
= vrf_info_lookup(vrf_id
);
357 addr2hostprefix(pw
->af
, &pw
->nexthop
, &nh
);
358 rnh
= zebra_add_rnh(&nh
, vrf_id
, RNH_NEXTHOP_TYPE
, &exists
);
359 if (rnh
&& !listnode_lookup(rnh
->zebra_pseudowire_list
, pw
)) {
360 listnode_add(rnh
->zebra_pseudowire_list
, pw
);
362 zebra_evaluate_rnh(zvrf
, family2afi(pw
->af
), 1,
363 RNH_NEXTHOP_TYPE
, &nh
);
367 void zebra_deregister_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
375 listnode_delete(rnh
->zebra_pseudowire_list
, pw
);
378 zebra_delete_rnh(rnh
, RNH_NEXTHOP_TYPE
);
381 /* Clear the NEXTHOP_FLAG_RNH_FILTERED flags on all nexthops
383 static void zebra_rnh_clear_nexthop_rnh_filters(struct route_entry
*re
)
385 struct nexthop
*nexthop
;
388 for (nexthop
= re
->nhe
->nhg
.nexthop
; nexthop
;
389 nexthop
= nexthop
->next
) {
390 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_RNH_FILTERED
);
395 /* Apply the NHT route-map for a client to the route (and nexthops)
398 static int zebra_rnh_apply_nht_rmap(afi_t afi
, struct zebra_vrf
*zvrf
,
399 struct route_node
*prn
,
400 struct route_entry
*re
, int proto
)
402 int at_least_one
= 0;
403 struct nexthop
*nexthop
;
404 route_map_result_t ret
;
407 for (nexthop
= re
->nhe
->nhg
.nexthop
; nexthop
;
408 nexthop
= nexthop
->next
) {
409 ret
= zebra_nht_route_map_check(
410 afi
, proto
, &prn
->p
, zvrf
, re
, nexthop
);
411 if (ret
!= RMAP_DENYMATCH
)
412 at_least_one
++; /* at least one valid NH */
414 SET_FLAG(nexthop
->flags
,
415 NEXTHOP_FLAG_RNH_FILTERED
);
419 return (at_least_one
);
423 * Determine appropriate route (RE entry) resolving a tracked BGP route
424 * for BGP route for import.
426 static struct route_entry
*
427 zebra_rnh_resolve_import_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
428 struct route_node
*nrn
, struct rnh
*rnh
,
429 struct route_node
**prn
)
431 struct route_table
*route_table
;
432 struct route_node
*rn
;
433 struct route_entry
*re
;
437 route_table
= zvrf
->table
[afi
][SAFI_UNICAST
];
438 if (!route_table
) // unexpected
441 rn
= route_node_match(route_table
, &nrn
->p
);
445 /* Unlock route node - we don't need to lock when walking the tree. */
446 route_unlock_node(rn
);
448 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_EXACT_MATCH
)
449 && !prefix_same(&nrn
->p
, &rn
->p
))
452 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
453 char buf
[PREFIX_STRLEN
];
454 char buf1
[PREFIX_STRLEN
];
456 zlog_debug("%s: %u:%s Resolved Import Entry to %s", __func__
,
458 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
459 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
462 /* Identify appropriate route entry. */
463 RNODE_FOREACH_RE (rn
, re
) {
464 if (!CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
)
465 && CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
)
466 && !CHECK_FLAG(re
->status
, ROUTE_ENTRY_QUEUED
)
467 && (re
->type
!= ZEBRA_ROUTE_BGP
))
474 if (!re
&& IS_ZEBRA_DEBUG_NHT_DETAILED
)
475 zlog_debug(" Rejected due to removed or is a bgp route");
481 * See if a tracked route entry for import (by BGP) has undergone any
482 * change, and if so, notify the client.
484 static void zebra_rnh_eval_import_check_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
485 int force
, struct route_node
*nrn
,
487 struct route_node
*prn
,
488 struct route_entry
*re
)
490 int state_changed
= 0;
491 struct zserv
*client
;
492 char bufn
[INET6_ADDRSTRLEN
];
493 struct listnode
*node
;
495 zebra_rnh_remove_from_routing_table(rnh
);
497 prefix_copy(&rnh
->resolved_route
, &prn
->p
);
499 int family
= rnh
->resolved_route
.family
;
501 memset(&rnh
->resolved_route
.family
, 0, sizeof(struct prefix
));
502 rnh
->resolved_route
.family
= family
;
504 zebra_rnh_store_in_routing_table(rnh
);
506 if (re
&& (rnh
->state
== NULL
)) {
507 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
))
509 } else if (!re
&& (rnh
->state
!= NULL
))
512 if (compare_state(re
, rnh
->state
)) {
513 copy_state(rnh
, re
, nrn
);
517 if (state_changed
|| force
) {
518 if (IS_ZEBRA_DEBUG_NHT
) {
519 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
520 zlog_debug("%u:%s: Route import check %s %s",
522 bufn
, rnh
->state
? "passed" : "failed",
523 state_changed
? "(state changed)" : "");
525 /* state changed, notify clients */
526 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
527 send_client(rnh
, client
,
528 RNH_IMPORT_CHECK_TYPE
, zvrf
->vrf
->vrf_id
);
534 * Notify clients registered for this nexthop about a change.
536 static void zebra_rnh_notify_protocol_clients(struct zebra_vrf
*zvrf
, afi_t afi
,
537 struct route_node
*nrn
,
539 struct route_node
*prn
,
540 struct route_entry
*re
)
542 struct listnode
*node
;
543 struct zserv
*client
;
544 char bufn
[INET6_ADDRSTRLEN
];
545 char bufp
[INET6_ADDRSTRLEN
];
546 int num_resolving_nh
;
548 if (IS_ZEBRA_DEBUG_NHT
) {
549 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
551 srcdest_rnode2str(prn
, bufp
, INET6_ADDRSTRLEN
);
552 zlog_debug("%u:%s: NH resolved over route %s",
553 zvrf
->vrf
->vrf_id
, bufn
, bufp
);
555 zlog_debug("%u:%s: NH has become unresolved",
556 zvrf
->vrf
->vrf_id
, bufn
);
559 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
561 /* Apply route-map for this client to route resolving
563 * nexthop to see if it is filtered or not.
565 zebra_rnh_clear_nexthop_rnh_filters(re
);
566 num_resolving_nh
= zebra_rnh_apply_nht_rmap(
567 afi
, zvrf
, prn
, re
, client
->proto
);
568 if (num_resolving_nh
)
569 rnh
->filtered
[client
->proto
] = 0;
571 rnh
->filtered
[client
->proto
] = 1;
573 if (IS_ZEBRA_DEBUG_NHT
)
575 "%u:%s: Notifying client %s about NH %s",
576 zvrf
->vrf
->vrf_id
, bufn
,
577 zebra_route_string(client
->proto
),
580 : "(filtered by route-map)");
582 rnh
->filtered
[client
->proto
] = 0;
583 if (IS_ZEBRA_DEBUG_NHT
)
585 "%u:%s: Notifying client %s about NH (unreachable)",
586 zvrf
->vrf
->vrf_id
, bufn
,
587 zebra_route_string(client
->proto
));
590 send_client(rnh
, client
, RNH_NEXTHOP_TYPE
, zvrf
->vrf
->vrf_id
);
594 zebra_rnh_clear_nexthop_rnh_filters(re
);
598 * Utility to determine whether a candidate nexthop is useable. We make this
599 * check in a couple of places, so this is a single home for the logic we
602 static bool rnh_nexthop_valid(const struct route_entry
*re
,
603 const struct nexthop
*nh
)
605 return (CHECK_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
)
606 && CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_ACTIVE
)
607 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_RECURSIVE
)
608 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_DUPLICATE
)
609 && !CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_RNH_FILTERED
));
613 * Determine appropriate route (route entry) resolving a tracked
616 static struct route_entry
*
617 zebra_rnh_resolve_nexthop_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
618 struct route_node
*nrn
, struct rnh
*rnh
,
619 struct route_node
**prn
)
621 struct route_table
*route_table
;
622 struct route_node
*rn
;
623 struct route_entry
*re
;
624 struct nexthop
*nexthop
;
628 route_table
= zvrf
->table
[afi
][SAFI_UNICAST
];
632 rn
= route_node_match(route_table
, &nrn
->p
);
636 /* Unlock route node - we don't need to lock when walking the tree. */
637 route_unlock_node(rn
);
639 /* While resolving nexthops, we may need to walk up the tree from the
640 * most-specific match. Do similar logic as in zebra_rib.c
643 if (IS_ZEBRA_DEBUG_NHT_DETAILED
) {
644 char buf
[PREFIX_STRLEN
];
645 char buf1
[PREFIX_STRLEN
];
647 zlog_debug("%s: %u:%s Possible Match to %s", __func__
,
649 prefix2str(&rnh
->node
->p
, buf
, sizeof(buf
)),
650 srcdest_rnode2str(rn
, buf1
, sizeof(buf
)));
653 /* Do not resolve over default route unless allowed &&
654 * match route to be exact if so specified
656 if (is_default_prefix(&rn
->p
)
657 && !rnh_resolve_via_default(zvrf
, rn
->p
.family
)) {
658 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
660 " Not allowed to resolve through default prefix");
664 /* Identify appropriate route entry. */
665 RNODE_FOREACH_RE (rn
, re
) {
666 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
)) {
667 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
669 " Route Entry %s removed",
670 zebra_route_string(re
->type
));
673 if (!CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
) &&
674 !CHECK_FLAG(re
->flags
, ZEBRA_FLAG_FIB_OVERRIDE
)) {
675 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
677 " Route Entry %s !selected",
678 zebra_route_string(re
->type
));
682 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_QUEUED
)) {
683 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
685 " Route Entry %s queued",
686 zebra_route_string(re
->type
));
690 /* Just being SELECTED isn't quite enough - must
691 * have an installed nexthop to be useful.
693 for (ALL_NEXTHOPS(re
->nhe
->nhg
, nexthop
)) {
694 if (rnh_nexthop_valid(re
, nexthop
))
698 if (nexthop
== NULL
) {
699 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
701 " Route Entry %s no nexthops",
702 zebra_route_string(re
->type
));
706 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)) {
707 if ((re
->type
== ZEBRA_ROUTE_CONNECT
)
708 || (re
->type
== ZEBRA_ROUTE_STATIC
))
710 if (re
->type
== ZEBRA_ROUTE_NHRP
) {
712 for (nexthop
= re
->nhe
->nhg
.nexthop
;
714 nexthop
= nexthop
->next
)
716 == NEXTHOP_TYPE_IFINDEX
)
725 /* Route entry found, we're done; else, walk up the tree. */
731 if (!CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
))
734 if (IS_ZEBRA_DEBUG_NHT_DETAILED
)
736 " Nexthop must be connected, cannot recurse up");
744 static void zebra_rnh_process_pseudowires(vrf_id_t vrfid
, struct rnh
*rnh
)
747 struct listnode
*node
;
749 for (ALL_LIST_ELEMENTS_RO(rnh
->zebra_pseudowire_list
, node
, pw
))
754 * See if a tracked nexthop entry has undergone any change, and if so,
755 * take appropriate action; this involves notifying any clients and/or
756 * scheduling dependent static routes for processing.
758 static void zebra_rnh_eval_nexthop_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
759 int force
, struct route_node
*nrn
,
761 struct route_node
*prn
,
762 struct route_entry
*re
)
764 int state_changed
= 0;
766 /* If we're resolving over a different route, resolution has changed or
767 * the resolving route has some change (e.g., metric), there is a state
770 zebra_rnh_remove_from_routing_table(rnh
);
771 if (!prefix_same(&rnh
->resolved_route
, prn
? &prn
->p
: NULL
)) {
773 prefix_copy(&rnh
->resolved_route
, &prn
->p
);
776 * Just quickly store the family of the resolved
777 * route so that we can reset it in a second here
779 int family
= rnh
->resolved_route
.family
;
781 memset(&rnh
->resolved_route
, 0, sizeof(struct prefix
));
782 rnh
->resolved_route
.family
= family
;
785 copy_state(rnh
, re
, nrn
);
787 } else if (compare_state(re
, rnh
->state
)) {
788 copy_state(rnh
, re
, nrn
);
791 zebra_rnh_store_in_routing_table(rnh
);
793 if (state_changed
|| force
) {
794 /* NOTE: Use the "copy" of resolving route stored in 'rnh' i.e.,
797 /* Notify registered protocol clients. */
798 zebra_rnh_notify_protocol_clients(zvrf
, afi
, nrn
, rnh
, prn
,
801 /* Process pseudowires attached to this nexthop */
802 zebra_rnh_process_pseudowires(zvrf
->vrf
->vrf_id
, rnh
);
806 /* Evaluate one tracked entry */
807 static void zebra_rnh_evaluate_entry(struct zebra_vrf
*zvrf
, afi_t afi
,
808 int force
, enum rnh_type type
,
809 struct route_node
*nrn
)
812 struct route_entry
*re
;
813 struct route_node
*prn
;
814 char bufn
[INET6_ADDRSTRLEN
];
816 if (IS_ZEBRA_DEBUG_NHT
) {
817 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
818 zlog_debug("%u:%s: Evaluate RNH, type %s %s", zvrf
->vrf
->vrf_id
,
819 bufn
, rnh_type2str(type
), force
? "(force)" : "");
824 /* Identify route entry (RE) resolving this tracked entry. */
825 if (type
== RNH_IMPORT_CHECK_TYPE
)
826 re
= zebra_rnh_resolve_import_entry(zvrf
, afi
, nrn
, rnh
, &prn
);
828 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, afi
, nrn
, rnh
, &prn
);
830 /* If the entry cannot be resolved and that is also the existing state,
831 * there is nothing further to do.
833 if (!re
&& rnh
->state
== NULL
&& !force
)
836 /* Process based on type of entry. */
837 if (type
== RNH_IMPORT_CHECK_TYPE
)
838 zebra_rnh_eval_import_check_entry(zvrf
, afi
, force
, nrn
, rnh
,
841 zebra_rnh_eval_nexthop_entry(zvrf
, afi
, force
, nrn
, rnh
, prn
,
846 * Clear the ROUTE_ENTRY_NEXTHOPS_CHANGED flag
847 * from the re entries.
849 * Please note we are doing this *after* we have
850 * notified the world about each nexthop as that
851 * we can have a situation where one re entry
852 * covers multiple nexthops we are interested in.
854 static void zebra_rnh_clear_nhc_flag(struct zebra_vrf
*zvrf
, afi_t afi
,
855 enum rnh_type type
, struct route_node
*nrn
)
858 struct route_entry
*re
;
859 struct route_node
*prn
;
863 /* Identify route entry (RIB) resolving this tracked entry. */
864 if (type
== RNH_IMPORT_CHECK_TYPE
)
865 re
= zebra_rnh_resolve_import_entry(zvrf
, afi
, nrn
, rnh
,
868 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, afi
, nrn
, rnh
,
872 UNSET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
875 /* Evaluate all tracked entries (nexthops or routes for import into BGP)
876 * of a particular VRF and address-family or a specific prefix.
878 void zebra_evaluate_rnh(struct zebra_vrf
*zvrf
, afi_t afi
, int force
,
879 enum rnh_type type
, struct prefix
*p
)
881 struct route_table
*rnh_table
;
882 struct route_node
*nrn
;
884 rnh_table
= get_rnh_table(zvrf
->vrf
->vrf_id
, afi
, type
);
885 if (!rnh_table
) // unexpected
889 /* Evaluating a specific entry, make sure it exists. */
890 nrn
= route_node_lookup(rnh_table
, p
);
891 if (nrn
&& nrn
->info
)
892 zebra_rnh_evaluate_entry(zvrf
, afi
, force
, type
, nrn
);
895 route_unlock_node(nrn
);
897 /* Evaluate entire table. */
898 nrn
= route_top(rnh_table
);
901 zebra_rnh_evaluate_entry(zvrf
, afi
, force
, type
,
903 nrn
= route_next(nrn
); /* this will also unlock nrn */
905 nrn
= route_top(rnh_table
);
908 zebra_rnh_clear_nhc_flag(zvrf
, afi
, type
, nrn
);
909 nrn
= route_next(nrn
); /* this will also unlock nrn */
914 void zebra_print_rnh_table(vrf_id_t vrfid
, afi_t afi
, struct vty
*vty
,
915 enum rnh_type type
, struct prefix
*p
)
917 struct route_table
*table
;
918 struct route_node
*rn
;
920 table
= get_rnh_table(vrfid
, afi
, type
);
922 if (IS_ZEBRA_DEBUG_NHT
)
923 zlog_debug("print_rnhs: rnh table not found");
927 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
928 if (p
&& !prefix_match(&rn
->p
, p
))
937 * free_state - free up the re structure associated with the rnh.
939 static void free_state(vrf_id_t vrf_id
, struct route_entry
*re
,
940 struct route_node
*rn
)
945 /* free RE and nexthops */
946 zebra_nhg_free(re
->nhe
);
950 static void copy_state(struct rnh
*rnh
, const struct route_entry
*re
,
951 struct route_node
*rn
)
953 struct route_entry
*state
;
956 free_state(rnh
->vrf_id
, rnh
->state
, rn
);
963 state
= XCALLOC(MTYPE_RE
, sizeof(struct route_entry
));
964 state
->type
= re
->type
;
965 state
->distance
= re
->distance
;
966 state
->metric
= re
->metric
;
967 state
->vrf_id
= re
->vrf_id
;
968 state
->status
= re
->status
;
970 state
->nhe
= zebra_nhg_alloc();
972 nexthop_group_copy(&(state
->nhe
->nhg
), &(re
->nhe
->nhg
));
976 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
)
981 if ((!r1
&& r2
) || (r1
&& !r2
))
984 if (r1
->distance
!= r2
->distance
)
987 if (r1
->metric
!= r2
->metric
)
990 if (nexthop_group_nexthop_num(&(r1
->nhe
->nhg
))
991 != nexthop_group_nexthop_num(&(r2
->nhe
->nhg
)))
994 if (nexthop_group_hash(&(r1
->nhe
->nhg
)) !=
995 nexthop_group_hash(&(r2
->nhe
->nhg
)))
1001 static int send_client(struct rnh
*rnh
, struct zserv
*client
,
1002 enum rnh_type type
, vrf_id_t vrf_id
)
1005 struct route_entry
*re
;
1009 struct route_node
*rn
;
1010 int cmd
= (type
== RNH_IMPORT_CHECK_TYPE
) ? ZEBRA_IMPORT_CHECK_UPDATE
1011 : ZEBRA_NEXTHOP_UPDATE
;
1016 /* Get output stream. */
1017 s
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
1019 zclient_create_header(s
, cmd
, vrf_id
);
1021 stream_putw(s
, rn
->p
.family
);
1022 switch (rn
->p
.family
) {
1024 stream_putc(s
, rn
->p
.prefixlen
);
1025 stream_put_in_addr(s
, &rn
->p
.u
.prefix4
);
1028 stream_putc(s
, rn
->p
.prefixlen
);
1029 stream_put(s
, &rn
->p
.u
.prefix6
, IPV6_MAX_BYTELEN
);
1032 flog_err(EC_ZEBRA_RNH_UNKNOWN_FAMILY
,
1033 "%s: Unknown family (%d) notification attempted\n",
1034 __func__
, rn
->p
.family
);
1038 struct zapi_nexthop znh
;
1040 stream_putc(s
, re
->type
);
1041 stream_putw(s
, re
->instance
);
1042 stream_putc(s
, re
->distance
);
1043 stream_putl(s
, re
->metric
);
1045 nump
= stream_get_endp(s
);
1047 for (ALL_NEXTHOPS(re
->nhe
->nhg
, nh
))
1048 if (rnh_nexthop_valid(re
, nh
)) {
1049 zapi_nexthop_from_nexthop(&znh
, nh
);
1050 zapi_nexthop_encode(s
, &znh
, 0 /* flags */);
1053 stream_putc_at(s
, nump
, num
);
1055 stream_putc(s
, 0); // type
1056 stream_putw(s
, 0); // instance
1057 stream_putc(s
, 0); // distance
1058 stream_putl(s
, 0); // metric
1059 stream_putc(s
, 0); // nexthops
1061 stream_putw_at(s
, 0, stream_get_endp(s
));
1063 client
->nh_last_upd_time
= monotime(NULL
);
1064 client
->last_write_cmd
= cmd
;
1065 return zserv_send_message(client
, s
);
1068 static void print_nh(struct nexthop
*nexthop
, struct vty
*vty
)
1071 struct zebra_ns
*zns
= zebra_ns_lookup(nexthop
->vrf_id
);
1073 switch (nexthop
->type
) {
1074 case NEXTHOP_TYPE_IPV4
:
1075 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1076 vty_out(vty
, " via %s", inet_ntoa(nexthop
->gate
.ipv4
));
1077 if (nexthop
->ifindex
)
1078 vty_out(vty
, ", %s",
1079 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1081 case NEXTHOP_TYPE_IPV6
:
1082 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1084 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, BUFSIZ
));
1085 if (nexthop
->ifindex
)
1086 vty_out(vty
, ", via %s",
1087 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1089 case NEXTHOP_TYPE_IFINDEX
:
1090 vty_out(vty
, " is directly connected, %s",
1091 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
1093 case NEXTHOP_TYPE_BLACKHOLE
:
1094 vty_out(vty
, " is directly connected, Null0");
1102 static void print_rnh(struct route_node
*rn
, struct vty
*vty
)
1105 struct nexthop
*nexthop
;
1106 struct listnode
*node
;
1107 struct zserv
*client
;
1111 vty_out(vty
, "%s%s\n",
1112 inet_ntop(rn
->p
.family
, &rn
->p
.u
.prefix
, buf
, BUFSIZ
),
1113 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
) ? "(Connected)"
1116 vty_out(vty
, " resolved via %s\n",
1117 zebra_route_string(rnh
->state
->type
));
1118 for (nexthop
= rnh
->state
->nhe
->nhg
.nexthop
; nexthop
;
1119 nexthop
= nexthop
->next
)
1120 print_nh(nexthop
, vty
);
1122 vty_out(vty
, " unresolved%s\n",
1123 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)
1127 vty_out(vty
, " Client list:");
1128 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
))
1129 vty_out(vty
, " %s(fd %d)%s", zebra_route_string(client
->proto
),
1131 rnh
->filtered
[client
->proto
] ? "(filtered)" : "");
1132 if (!list_isempty(rnh
->zebra_pseudowire_list
))
1133 vty_out(vty
, " zebra[pseudowires]");
1137 static int zebra_cleanup_rnh_client(vrf_id_t vrf_id
, afi_t afi
,
1138 struct zserv
*client
, enum rnh_type type
)
1140 struct route_table
*ntable
;
1141 struct route_node
*nrn
;
1144 if (IS_ZEBRA_DEBUG_NHT
)
1145 zlog_debug("%u: Client %s RNH cleanup for family %s type %s",
1146 vrf_id
, zebra_route_string(client
->proto
),
1147 afi2str(afi
), rnh_type2str(type
));
1149 ntable
= get_rnh_table(vrf_id
, afi
, type
);
1151 zlog_debug("cleanup_rnh_client: rnh table not found");
1155 for (nrn
= route_top(ntable
); nrn
; nrn
= route_next(nrn
)) {
1160 zebra_remove_rnh_client(rnh
, client
, type
);
1165 /* Cleanup registered nexthops (across VRFs) upon client disconnect. */
1166 static int zebra_client_cleanup_rnh(struct zserv
*client
)
1169 struct zebra_vrf
*zvrf
;
1171 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
1174 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP
, client
,
1176 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP6
, client
,
1178 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP
, client
,
1179 RNH_IMPORT_CHECK_TYPE
);
1180 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AFI_IP6
, client
,
1181 RNH_IMPORT_CHECK_TYPE
);
1188 int rnh_resolve_via_default(struct zebra_vrf
*zvrf
, int family
)
1190 if (((family
== AF_INET
) && zvrf
->zebra_rnh_ip_default_route
)
1191 || ((family
== AF_INET6
) && zvrf
->zebra_rnh_ipv6_default_route
))