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 #define lookup_rnh_table(v, f) \
59 struct zebra_vrf *zvrf; \
60 struct route_table *t = NULL; \
61 zvrf = zebra_vrf_lookup_by_id(v); \
63 t = zvrf->rnh_table[family2afi(f)]; \
67 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
);
68 static int send_client(struct rnh
*rnh
, struct zserv
*client
, rnh_type_t type
,
70 static void print_rnh(struct route_node
*rn
, struct vty
*vty
);
71 static int zebra_client_cleanup_rnh(struct zserv
*client
);
73 int zebra_rnh_ip_default_route
= 0;
74 int zebra_rnh_ipv6_default_route
= 0;
76 void zebra_rnh_init(void)
78 hook_register(zserv_client_close
, zebra_client_cleanup_rnh
);
81 static inline struct route_table
*get_rnh_table(vrf_id_t vrfid
, int family
,
84 struct zebra_vrf
*zvrf
;
85 struct route_table
*t
= NULL
;
87 zvrf
= zebra_vrf_lookup_by_id(vrfid
);
90 case RNH_NEXTHOP_TYPE
:
91 t
= zvrf
->rnh_table
[family2afi(family
)];
93 case RNH_IMPORT_CHECK_TYPE
:
94 t
= zvrf
->import_check_table
[family2afi(family
)];
101 char *rnh_str(struct rnh
*rnh
, char *buf
, int size
)
103 prefix2str(&(rnh
->node
->p
), buf
, size
);
107 struct rnh
*zebra_add_rnh(struct prefix
*p
, vrf_id_t vrfid
, rnh_type_t type
,
110 struct route_table
*table
;
111 struct route_node
*rn
;
112 struct rnh
*rnh
= NULL
;
113 char buf
[PREFIX2STR_BUFFER
];
115 if (IS_ZEBRA_DEBUG_NHT
) {
116 prefix2str(p
, buf
, sizeof(buf
));
117 zlog_debug("%u: Add RNH %s type %d", vrfid
, buf
, type
);
119 table
= get_rnh_table(vrfid
, PREFIX_FAMILY(p
), type
);
121 prefix2str(p
, buf
, sizeof(buf
));
122 flog_warn(EC_ZEBRA_RNH_NO_TABLE
,
123 "%u: Add RNH %s type %d - table not found", vrfid
,
129 /* Make it sure prefixlen is applied to the prefix. */
132 /* Lookup (or add) route node.*/
133 rn
= route_node_get(table
, p
);
136 rnh
= XCALLOC(MTYPE_RNH
, sizeof(struct rnh
));
137 rnh
->client_list
= list_new();
139 rnh
->zebra_pseudowire_list
= list_new();
147 route_unlock_node(rn
);
151 struct rnh
*zebra_lookup_rnh(struct prefix
*p
, vrf_id_t vrfid
, rnh_type_t type
)
153 struct route_table
*table
;
154 struct route_node
*rn
;
156 table
= get_rnh_table(vrfid
, PREFIX_FAMILY(p
), type
);
160 /* Make it sure prefixlen is applied to the prefix. */
163 /* Lookup route node.*/
164 rn
= route_node_lookup(table
, p
);
168 route_unlock_node(rn
);
172 void zebra_free_rnh(struct rnh
*rnh
)
174 rnh
->flags
|= ZEBRA_NHT_DELETED
;
175 list_delete(&rnh
->client_list
);
176 list_delete(&rnh
->zebra_pseudowire_list
);
177 free_state(rnh
->vrf_id
, rnh
->state
, rnh
->node
);
178 XFREE(MTYPE_RNH
, rnh
);
181 void zebra_delete_rnh(struct rnh
*rnh
, rnh_type_t type
)
183 struct route_node
*rn
;
185 if (!rnh
|| (rnh
->flags
& ZEBRA_NHT_DELETED
) || !(rn
= rnh
->node
))
188 if (IS_ZEBRA_DEBUG_NHT
) {
189 char buf
[PREFIX2STR_BUFFER
];
190 zlog_debug("%u: Del RNH %s type %d", rnh
->vrf_id
,
191 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
196 route_unlock_node(rn
);
200 * This code will send to the registering client
202 * For a rnh that was created, there is no data
203 * so it will send an empty nexthop group
204 * If rnh exists then we know it has been evaluated
205 * and as such it will have a resolved rnh.
207 void zebra_add_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
208 rnh_type_t type
, vrf_id_t vrf_id
)
210 if (IS_ZEBRA_DEBUG_NHT
) {
211 char buf
[PREFIX2STR_BUFFER
];
212 zlog_debug("%u: Client %s registers for RNH %s type %d", vrf_id
,
213 zebra_route_string(client
->proto
),
214 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
216 if (!listnode_lookup(rnh
->client_list
, client
))
217 listnode_add(rnh
->client_list
, client
);
220 * We always need to respond with known information,
221 * currently multiple daemons expect this behavior
223 send_client(rnh
, client
, type
, vrf_id
);
226 void zebra_remove_rnh_client(struct rnh
*rnh
, struct zserv
*client
,
229 if (IS_ZEBRA_DEBUG_NHT
) {
230 char buf
[PREFIX2STR_BUFFER
];
231 zlog_debug("Client %s unregisters for RNH %s type %d",
232 zebra_route_string(client
->proto
),
233 rnh_str(rnh
, buf
, sizeof(buf
)), type
);
235 listnode_delete(rnh
->client_list
, client
);
236 if (list_isempty(rnh
->client_list
)
237 && list_isempty(rnh
->zebra_pseudowire_list
))
238 zebra_delete_rnh(rnh
, type
);
241 /* XXX move this utility function elsewhere? */
242 static void addr2hostprefix(int af
, const union g_addr
*addr
,
243 struct prefix
*prefix
)
247 prefix
->family
= AF_INET
;
248 prefix
->prefixlen
= IPV4_MAX_BITLEN
;
249 prefix
->u
.prefix4
= addr
->ipv4
;
252 prefix
->family
= AF_INET6
;
253 prefix
->prefixlen
= IPV6_MAX_BITLEN
;
254 prefix
->u
.prefix6
= addr
->ipv6
;
257 memset(prefix
, 0, sizeof(*prefix
));
258 zlog_debug("%s: unknown address family %d", __func__
, af
);
263 void zebra_register_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
268 struct zebra_vrf
*zvrf
;
270 zvrf
= vrf_info_lookup(vrf_id
);
274 addr2hostprefix(pw
->af
, &pw
->nexthop
, &nh
);
275 rnh
= zebra_add_rnh(&nh
, vrf_id
, RNH_NEXTHOP_TYPE
, &exists
);
276 if (rnh
&& !listnode_lookup(rnh
->zebra_pseudowire_list
, pw
)) {
277 listnode_add(rnh
->zebra_pseudowire_list
, pw
);
279 zebra_evaluate_rnh(zvrf
, pw
->af
, 1, RNH_NEXTHOP_TYPE
, &nh
);
283 void zebra_deregister_rnh_pseudowire(vrf_id_t vrf_id
, struct zebra_pw
*pw
)
291 listnode_delete(rnh
->zebra_pseudowire_list
, pw
);
294 if (list_isempty(rnh
->client_list
)
295 && list_isempty(rnh
->zebra_pseudowire_list
))
296 zebra_delete_rnh(rnh
, RNH_NEXTHOP_TYPE
);
299 /* Apply the NHT route-map for a client to the route (and nexthops)
302 static int zebra_rnh_apply_nht_rmap(int family
, struct zebra_vrf
*zvrf
,
303 struct route_node
*prn
,
304 struct route_entry
*re
, int proto
)
306 int at_least_one
= 0;
307 int rmap_family
; /* Route map has diff AF family enum */
308 struct nexthop
*nexthop
;
311 rmap_family
= (family
== AF_INET
) ? AFI_IP
: AFI_IP6
;
314 for (nexthop
= re
->ng
.nexthop
; nexthop
;
315 nexthop
= nexthop
->next
) {
316 ret
= zebra_nht_route_map_check(
317 rmap_family
, proto
, &prn
->p
, zvrf
, re
, nexthop
);
318 if (ret
!= RMAP_DENYMATCH
) {
319 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
320 at_least_one
++; /* at least one valid NH */
322 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
326 return (at_least_one
);
330 * Determine appropriate route (RE entry) resolving a tracked BGP route
331 * for BGP route for import.
333 static struct route_entry
*
334 zebra_rnh_resolve_import_entry(struct zebra_vrf
*zvrf
, int family
,
335 struct route_node
*nrn
, struct rnh
*rnh
,
336 struct route_node
**prn
)
338 struct route_table
*route_table
;
339 struct route_node
*rn
;
340 struct route_entry
*re
;
344 route_table
= zvrf
->table
[family2afi(family
)][SAFI_UNICAST
];
345 if (!route_table
) // unexpected
348 rn
= route_node_match(route_table
, &nrn
->p
);
352 /* Unlock route node - we don't need to lock when walking the tree. */
353 route_unlock_node(rn
);
355 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_EXACT_MATCH
)
356 && !prefix_same(&nrn
->p
, &rn
->p
))
359 /* Identify appropriate route entry. */
360 RNODE_FOREACH_RE (rn
, re
) {
361 if (!CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
)
362 && CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
)
363 && (re
->type
!= ZEBRA_ROUTE_BGP
))
373 * See if a tracked route entry for import (by BGP) has undergone any
374 * change, and if so, notify the client.
376 static void zebra_rnh_eval_import_check_entry(vrf_id_t vrfid
, int family
,
377 int force
, struct route_node
*nrn
,
379 struct route_entry
*re
)
381 int state_changed
= 0;
382 struct zserv
*client
;
383 char bufn
[INET6_ADDRSTRLEN
];
384 struct listnode
*node
;
385 struct nexthop
*nexthop
;
387 if (re
&& (rnh
->state
== NULL
)) {
388 for (ALL_NEXTHOPS(re
->ng
, nexthop
))
389 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
)) {
393 } else if (!re
&& (rnh
->state
!= NULL
))
396 if (compare_state(re
, rnh
->state
))
397 copy_state(rnh
, re
, nrn
);
399 if (state_changed
|| force
) {
400 if (IS_ZEBRA_DEBUG_NHT
) {
401 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
402 zlog_debug("%u:%s: Route import check %s %s\n", vrfid
,
403 bufn
, rnh
->state
? "passed" : "failed",
404 state_changed
? "(state changed)" : "");
406 /* state changed, notify clients */
407 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
408 send_client(rnh
, client
, RNH_IMPORT_CHECK_TYPE
, vrfid
);
414 * Notify clients registered for this nexthop about a change.
416 static void zebra_rnh_notify_protocol_clients(
417 struct zebra_vrf
*zvrf
, int family
, struct route_node
*nrn
,
418 struct rnh
*rnh
, struct route_node
*prn
, struct route_entry
*re
)
420 struct listnode
*node
;
421 struct zserv
*client
;
422 char bufn
[INET6_ADDRSTRLEN
];
423 char bufp
[INET6_ADDRSTRLEN
];
424 int num_resolving_nh
;
426 if (IS_ZEBRA_DEBUG_NHT
) {
427 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
429 prefix2str(&prn
->p
, bufp
, INET6_ADDRSTRLEN
);
430 zlog_debug("%u:%s: NH resolved over route %s",
431 zvrf
->vrf
->vrf_id
, bufn
, bufp
);
433 zlog_debug("%u:%s: NH has become unresolved",
434 zvrf
->vrf
->vrf_id
, bufn
);
437 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
439 /* Apply route-map for this client to route resolving
441 * nexthop to see if it is filtered or not.
443 num_resolving_nh
= zebra_rnh_apply_nht_rmap(
444 family
, zvrf
, prn
, re
, client
->proto
);
445 if (num_resolving_nh
)
446 rnh
->filtered
[client
->proto
] = 0;
448 rnh
->filtered
[client
->proto
] = 1;
450 if (IS_ZEBRA_DEBUG_NHT
)
452 "%u:%s: Notifying client %s about NH %s",
453 zvrf
->vrf
->vrf_id
, bufn
,
454 zebra_route_string(client
->proto
),
457 : "(filtered by route-map)");
459 rnh
->filtered
[client
->proto
] = 0;
460 if (IS_ZEBRA_DEBUG_NHT
)
462 "%u:%s: Notifying client %s about NH (unreachable)",
463 zvrf
->vrf
->vrf_id
, bufn
,
464 zebra_route_string(client
->proto
));
467 send_client(rnh
, client
, RNH_NEXTHOP_TYPE
, zvrf
->vrf
->vrf_id
);
471 static void zebra_rnh_process_pbr_tables(int family
,
472 struct route_node
*nrn
,
474 struct route_node
*prn
,
475 struct route_entry
*re
)
477 struct zebra_router_table
*zrt
;
478 struct route_entry
*o_re
;
479 struct route_node
*o_rn
;
480 struct listnode
*node
;
481 struct zserv
*client
;
484 if (family
== AF_INET6
)
488 * We are only concerned about nexthops that change for
491 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
)) {
492 if (client
->proto
== ZEBRA_ROUTE_PBR
)
499 RB_FOREACH (zrt
, zebra_router_table_head
, &zrouter
.tables
) {
503 for (o_rn
= route_top(zrt
->table
); o_rn
;
504 o_rn
= srcdest_route_next(o_rn
)) {
505 RNODE_FOREACH_RE (o_rn
, o_re
) {
506 if (o_re
->type
== ZEBRA_ROUTE_PBR
)
512 * If we have a PBR route and a nexthop changes
513 * just rethink it. Yes this is a hammer, but
517 SET_FLAG(o_re
->status
, ROUTE_ENTRY_CHANGED
);
525 * Utility to determine whether a candidate nexthop is useable. We make this
526 * check in a couple of places, so this is a single home for the logic we
529 static bool rnh_nexthop_valid(const struct nexthop
*nh
)
531 return ((CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_FIB
)
532 || CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_RECURSIVE
))
533 && CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_ACTIVE
));
537 * Determine appropriate route (route entry) resolving a tracked
540 static struct route_entry
*
541 zebra_rnh_resolve_nexthop_entry(struct zebra_vrf
*zvrf
, int family
,
542 struct route_node
*nrn
, struct rnh
*rnh
,
543 struct route_node
**prn
)
545 struct route_table
*route_table
;
546 struct route_node
*rn
;
547 struct route_entry
*re
;
548 struct nexthop
*nexthop
;
552 route_table
= zvrf
->table
[family2afi(family
)][SAFI_UNICAST
];
556 rn
= route_node_match(route_table
, &nrn
->p
);
560 /* Unlock route node - we don't need to lock when walking the tree. */
561 route_unlock_node(rn
);
563 /* While resolving nexthops, we may need to walk up the tree from the
564 * most-specific match. Do similar logic as in zebra_rib.c
567 /* Do not resolve over default route unless allowed &&
568 * match route to be exact if so specified
570 if (is_default_prefix(&rn
->p
)
571 && !rnh_resolve_via_default(rn
->p
.family
))
574 /* Identify appropriate route entry. */
575 RNODE_FOREACH_RE (rn
, re
) {
576 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
578 if (!CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
))
581 /* Just being SELECTED isn't quite enough - must
582 * have an installed nexthop to be useful.
584 for (nexthop
= re
->ng
.nexthop
; nexthop
;
585 nexthop
= nexthop
->next
) {
586 if (rnh_nexthop_valid(nexthop
))
593 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)) {
594 if ((re
->type
== ZEBRA_ROUTE_CONNECT
)
595 || (re
->type
== ZEBRA_ROUTE_STATIC
))
597 if (re
->type
== ZEBRA_ROUTE_NHRP
) {
599 for (nexthop
= re
->ng
.nexthop
; nexthop
;
600 nexthop
= nexthop
->next
)
602 == NEXTHOP_TYPE_IFINDEX
)
611 /* Route entry found, we're done; else, walk up the tree. */
617 if (CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
))
626 static void zebra_rnh_process_pseudowires(vrf_id_t vrfid
, struct rnh
*rnh
)
629 struct listnode
*node
;
631 for (ALL_LIST_ELEMENTS_RO(rnh
->zebra_pseudowire_list
, node
, pw
))
636 * See if a tracked nexthop entry has undergone any change, and if so,
637 * take appropriate action; this involves notifying any clients and/or
638 * scheduling dependent static routes for processing.
640 static void zebra_rnh_eval_nexthop_entry(struct zebra_vrf
*zvrf
, int family
,
641 int force
, struct route_node
*nrn
,
643 struct route_node
*prn
,
644 struct route_entry
*re
)
646 int state_changed
= 0;
648 /* If we're resolving over a different route, resolution has changed or
649 * the resolving route has some change (e.g., metric), there is a state
652 if (!prefix_same(&rnh
->resolved_route
, &prn
->p
)) {
654 prefix_copy(&rnh
->resolved_route
, &prn
->p
);
656 memset(&rnh
->resolved_route
, 0, sizeof(struct prefix
));
658 copy_state(rnh
, re
, nrn
);
660 } else if (compare_state(re
, rnh
->state
)) {
661 copy_state(rnh
, re
, nrn
);
665 if (state_changed
|| force
) {
666 /* NOTE: Use the "copy" of resolving route stored in 'rnh' i.e.,
669 /* Notify registered protocol clients. */
670 zebra_rnh_notify_protocol_clients(zvrf
, family
, nrn
, rnh
, prn
,
673 zebra_rnh_process_pbr_tables(family
, nrn
, rnh
, prn
, rnh
->state
);
675 /* Process pseudowires attached to this nexthop */
676 zebra_rnh_process_pseudowires(zvrf
->vrf
->vrf_id
, rnh
);
680 /* Evaluate one tracked entry */
681 static void zebra_rnh_evaluate_entry(struct zebra_vrf
*zvrf
, int family
,
682 int force
, rnh_type_t type
,
683 struct route_node
*nrn
)
686 struct route_entry
*re
;
687 struct route_node
*prn
;
688 char bufn
[INET6_ADDRSTRLEN
];
690 if (IS_ZEBRA_DEBUG_NHT
) {
691 prefix2str(&nrn
->p
, bufn
, INET6_ADDRSTRLEN
);
692 zlog_debug("%u:%s: Evaluate RNH, type %d %s", zvrf
->vrf
->vrf_id
,
693 bufn
, type
, force
? "(force)" : "");
698 /* Identify route entry (RE) resolving this tracked entry. */
699 if (type
== RNH_IMPORT_CHECK_TYPE
)
700 re
= zebra_rnh_resolve_import_entry(zvrf
, family
, nrn
, rnh
,
703 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, family
, nrn
, rnh
,
706 /* If the entry cannot be resolved and that is also the existing state,
707 * there is nothing further to do.
709 if (!re
&& rnh
->state
== NULL
&& !force
)
712 /* Process based on type of entry. */
713 if (type
== RNH_IMPORT_CHECK_TYPE
)
714 zebra_rnh_eval_import_check_entry(zvrf
->vrf
->vrf_id
, family
,
715 force
, nrn
, rnh
, re
);
717 zebra_rnh_eval_nexthop_entry(zvrf
, family
, force
, nrn
, rnh
, prn
,
722 * Clear the ROUTE_ENTRY_NEXTHOPS_CHANGED flag
723 * from the re entries.
725 * Please note we are doing this *after* we have
726 * notified the world about each nexthop as that
727 * we can have a situation where one re entry
728 * covers multiple nexthops we are interested in.
730 static void zebra_rnh_clear_nhc_flag(struct zebra_vrf
*zvrf
, int family
,
731 rnh_type_t type
, struct route_node
*nrn
)
734 struct route_entry
*re
;
735 struct route_node
*prn
;
739 /* Identify route entry (RIB) resolving this tracked entry. */
740 if (type
== RNH_IMPORT_CHECK_TYPE
)
741 re
= zebra_rnh_resolve_import_entry(zvrf
, family
, nrn
, rnh
,
744 re
= zebra_rnh_resolve_nexthop_entry(zvrf
, family
, nrn
, rnh
,
748 UNSET_FLAG(re
->status
, ROUTE_ENTRY_NEXTHOPS_CHANGED
);
749 UNSET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
753 /* Evaluate all tracked entries (nexthops or routes for import into BGP)
754 * of a particular VRF and address-family or a specific prefix.
756 void zebra_evaluate_rnh(struct zebra_vrf
*zvrf
, int family
, int force
,
757 rnh_type_t type
, struct prefix
*p
)
759 struct route_table
*rnh_table
;
760 struct route_node
*nrn
;
762 rnh_table
= get_rnh_table(zvrf
->vrf
->vrf_id
, family
, type
);
763 if (!rnh_table
) // unexpected
767 /* Evaluating a specific entry, make sure it exists. */
768 nrn
= route_node_lookup(rnh_table
, p
);
769 if (nrn
&& nrn
->info
)
770 zebra_rnh_evaluate_entry(zvrf
, family
, force
, type
,
774 route_unlock_node(nrn
);
776 /* Evaluate entire table. */
777 nrn
= route_top(rnh_table
);
780 zebra_rnh_evaluate_entry(zvrf
, family
, force
,
782 nrn
= route_next(nrn
); /* this will also unlock nrn */
784 nrn
= route_top(rnh_table
);
787 zebra_rnh_clear_nhc_flag(zvrf
, family
, type
,
789 nrn
= route_next(nrn
); /* this will also unlock nrn */
794 void zebra_print_rnh_table(vrf_id_t vrfid
, int af
, struct vty
*vty
,
797 struct route_table
*table
;
798 struct route_node
*rn
;
800 table
= get_rnh_table(vrfid
, af
, type
);
802 zlog_debug("print_rnhs: rnh table not found\n");
806 for (rn
= route_top(table
); rn
; rn
= route_next(rn
))
812 * free_state - free up the re structure associated with the rnh.
814 static void free_state(vrf_id_t vrf_id
, struct route_entry
*re
,
815 struct route_node
*rn
)
821 /* free RE and nexthops */
822 nexthops_free(re
->ng
.nexthop
);
826 static void copy_state(struct rnh
*rnh
, struct route_entry
*re
,
827 struct route_node
*rn
)
829 struct route_entry
*state
;
832 free_state(rnh
->vrf_id
, rnh
->state
, rn
);
839 state
= XCALLOC(MTYPE_RE
, sizeof(struct route_entry
));
840 state
->type
= re
->type
;
841 state
->distance
= re
->distance
;
842 state
->metric
= re
->metric
;
843 state
->vrf_id
= re
->vrf_id
;
845 route_entry_copy_nexthops(state
, re
->ng
.nexthop
);
849 static int compare_state(struct route_entry
*r1
, struct route_entry
*r2
)
855 if ((!r1
&& r2
) || (r1
&& !r2
))
858 if (r1
->distance
!= r2
->distance
)
861 if (r1
->metric
!= r2
->metric
)
864 if (r1
->nexthop_num
!= r2
->nexthop_num
)
867 if (CHECK_FLAG(r1
->status
, ROUTE_ENTRY_NEXTHOPS_CHANGED
)
868 || CHECK_FLAG(r1
->status
, ROUTE_ENTRY_LABELS_CHANGED
))
874 static int send_client(struct rnh
*rnh
, struct zserv
*client
, rnh_type_t type
,
878 struct route_entry
*re
;
882 struct route_node
*rn
;
883 int cmd
= (type
== RNH_IMPORT_CHECK_TYPE
) ? ZEBRA_IMPORT_CHECK_UPDATE
884 : ZEBRA_NEXTHOP_UPDATE
;
889 /* Get output stream. */
890 s
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
892 zclient_create_header(s
, cmd
, vrf_id
);
894 stream_putw(s
, rn
->p
.family
);
895 switch (rn
->p
.family
) {
897 stream_putc(s
, rn
->p
.prefixlen
);
898 stream_put_in_addr(s
, &rn
->p
.u
.prefix4
);
901 stream_putc(s
, rn
->p
.prefixlen
);
902 stream_put(s
, &rn
->p
.u
.prefix6
, IPV6_MAX_BYTELEN
);
905 flog_err(EC_ZEBRA_RNH_UNKNOWN_FAMILY
,
906 "%s: Unknown family (%d) notification attempted\n",
907 __FUNCTION__
, rn
->p
.family
);
911 stream_putc(s
, re
->type
);
912 stream_putw(s
, re
->instance
);
913 stream_putc(s
, re
->distance
);
914 stream_putl(s
, re
->metric
);
916 nump
= stream_get_endp(s
);
918 for (nh
= re
->ng
.nexthop
; nh
; nh
= nh
->next
)
919 if (rnh_nexthop_valid(nh
)) {
920 stream_putl(s
, nh
->vrf_id
);
921 stream_putc(s
, nh
->type
);
923 case NEXTHOP_TYPE_IPV4
:
924 case NEXTHOP_TYPE_IPV4_IFINDEX
:
925 stream_put_in_addr(s
, &nh
->gate
.ipv4
);
926 stream_putl(s
, nh
->ifindex
);
928 case NEXTHOP_TYPE_IFINDEX
:
929 stream_putl(s
, nh
->ifindex
);
931 case NEXTHOP_TYPE_IPV6
:
932 case NEXTHOP_TYPE_IPV6_IFINDEX
:
933 stream_put(s
, &nh
->gate
.ipv6
, 16);
934 stream_putl(s
, nh
->ifindex
);
942 nh
->nh_label
->num_labels
);
943 if (nh
->nh_label
->num_labels
)
946 &nh
->nh_label
->label
[0],
947 nh
->nh_label
->num_labels
948 * sizeof(mpls_label_t
));
953 stream_putc_at(s
, nump
, num
);
955 stream_putc(s
, 0); // type
956 stream_putw(s
, 0); // instance
957 stream_putc(s
, 0); // distance
958 stream_putl(s
, 0); // metric
959 stream_putc(s
, 0); // nexthops
961 stream_putw_at(s
, 0, stream_get_endp(s
));
963 client
->nh_last_upd_time
= monotime(NULL
);
964 client
->last_write_cmd
= cmd
;
965 return zserv_send_message(client
, s
);
968 static void print_nh(struct nexthop
*nexthop
, struct vty
*vty
)
971 struct zebra_ns
*zns
= zebra_ns_lookup(NS_DEFAULT
);
973 switch (nexthop
->type
) {
974 case NEXTHOP_TYPE_IPV4
:
975 case NEXTHOP_TYPE_IPV4_IFINDEX
:
976 vty_out(vty
, " via %s", inet_ntoa(nexthop
->gate
.ipv4
));
977 if (nexthop
->ifindex
)
979 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
981 case NEXTHOP_TYPE_IPV6
:
982 case NEXTHOP_TYPE_IPV6_IFINDEX
:
984 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, BUFSIZ
));
985 if (nexthop
->ifindex
)
986 vty_out(vty
, ", via %s",
987 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
989 case NEXTHOP_TYPE_IFINDEX
:
990 vty_out(vty
, " is directly connected, %s",
991 ifindex2ifname_per_ns(zns
, nexthop
->ifindex
));
993 case NEXTHOP_TYPE_BLACKHOLE
:
994 vty_out(vty
, " is directly connected, Null0");
1002 static void print_rnh(struct route_node
*rn
, struct vty
*vty
)
1005 struct nexthop
*nexthop
;
1006 struct listnode
*node
;
1007 struct zserv
*client
;
1011 vty_out(vty
, "%s%s\n",
1012 inet_ntop(rn
->p
.family
, &rn
->p
.u
.prefix
, buf
, BUFSIZ
),
1013 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
) ? "(Connected)"
1016 vty_out(vty
, " resolved via %s\n",
1017 zebra_route_string(rnh
->state
->type
));
1018 for (nexthop
= rnh
->state
->ng
.nexthop
; nexthop
;
1019 nexthop
= nexthop
->next
)
1020 print_nh(nexthop
, vty
);
1022 vty_out(vty
, " unresolved%s\n",
1023 CHECK_FLAG(rnh
->flags
, ZEBRA_NHT_CONNECTED
)
1027 vty_out(vty
, " Client list:");
1028 for (ALL_LIST_ELEMENTS_RO(rnh
->client_list
, node
, client
))
1029 vty_out(vty
, " %s(fd %d)%s", zebra_route_string(client
->proto
),
1031 rnh
->filtered
[client
->proto
] ? "(filtered)" : "");
1032 if (!list_isempty(rnh
->zebra_pseudowire_list
))
1033 vty_out(vty
, " zebra[pseudowires]");
1037 static int zebra_cleanup_rnh_client(vrf_id_t vrf_id
, int family
,
1038 struct zserv
*client
, rnh_type_t type
)
1040 struct route_table
*ntable
;
1041 struct route_node
*nrn
;
1044 if (IS_ZEBRA_DEBUG_NHT
)
1045 zlog_debug("%u: Client %s RNH cleanup for family %d type %d",
1046 vrf_id
, zebra_route_string(client
->proto
), family
,
1049 ntable
= get_rnh_table(vrf_id
, family
, type
);
1051 zlog_debug("cleanup_rnh_client: rnh table not found\n");
1055 for (nrn
= route_top(ntable
); nrn
; nrn
= route_next(nrn
)) {
1060 zebra_remove_rnh_client(rnh
, client
, type
);
1065 /* Cleanup registered nexthops (across VRFs) upon client disconnect. */
1066 static int zebra_client_cleanup_rnh(struct zserv
*client
)
1069 struct zebra_vrf
*zvrf
;
1071 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
1074 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AF_INET
, client
,
1076 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AF_INET6
,
1077 client
, RNH_NEXTHOP_TYPE
);
1078 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AF_INET
, client
,
1079 RNH_IMPORT_CHECK_TYPE
);
1080 zebra_cleanup_rnh_client(zvrf_id(zvrf
), AF_INET6
,
1081 client
, RNH_IMPORT_CHECK_TYPE
);
1082 if (client
->proto
== ZEBRA_ROUTE_LDP
) {
1083 hash_iterate(zvrf
->lsp_table
,
1084 mpls_ldp_lsp_uninstall_all
,
1086 mpls_ldp_ftn_uninstall_all(zvrf
, AFI_IP
);
1087 mpls_ldp_ftn_uninstall_all(zvrf
, AFI_IP6
);