1 /* BGP routing information
2 * Copyright (C) 1996, 97, 98, 99 Kunihiro Ishiguro
3 * Copyright (C) 2016 Job Snijders <job@instituut.net>
5 * This file is part of GNU Zebra.
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "sockunion.h"
37 #include "workqueue.h"
41 #include "lib_errors.h"
43 #include "bgpd/bgpd.h"
44 #include "bgpd/bgp_table.h"
45 #include "bgpd/bgp_route.h"
46 #include "bgpd/bgp_attr.h"
47 #include "bgpd/bgp_debug.h"
48 #include "bgpd/bgp_errors.h"
49 #include "bgpd/bgp_aspath.h"
50 #include "bgpd/bgp_regex.h"
51 #include "bgpd/bgp_community.h"
52 #include "bgpd/bgp_ecommunity.h"
53 #include "bgpd/bgp_lcommunity.h"
54 #include "bgpd/bgp_clist.h"
55 #include "bgpd/bgp_packet.h"
56 #include "bgpd/bgp_filter.h"
57 #include "bgpd/bgp_fsm.h"
58 #include "bgpd/bgp_mplsvpn.h"
59 #include "bgpd/bgp_nexthop.h"
60 #include "bgpd/bgp_damp.h"
61 #include "bgpd/bgp_advertise.h"
62 #include "bgpd/bgp_zebra.h"
63 #include "bgpd/bgp_vty.h"
64 #include "bgpd/bgp_mpath.h"
65 #include "bgpd/bgp_nht.h"
66 #include "bgpd/bgp_updgrp.h"
67 #include "bgpd/bgp_label.h"
68 #include "bgpd/bgp_addpath.h"
69 #include "bgpd/bgp_mac.h"
72 #include "bgpd/rfapi/rfapi_backend.h"
73 #include "bgpd/rfapi/vnc_import_bgp.h"
74 #include "bgpd/rfapi/vnc_export_bgp.h"
76 #include "bgpd/bgp_encap_types.h"
77 #include "bgpd/bgp_encap_tlv.h"
78 #include "bgpd/bgp_evpn.h"
79 #include "bgpd/bgp_evpn_vty.h"
80 #include "bgpd/bgp_flowspec.h"
81 #include "bgpd/bgp_flowspec_util.h"
82 #include "bgpd/bgp_pbr.h"
84 #ifndef VTYSH_EXTRACT_PL
85 #include "bgpd/bgp_route_clippy.c"
88 /* Extern from bgp_dump.c */
89 extern const char *bgp_origin_str
[];
90 extern const char *bgp_origin_long_str
[];
93 #define PMSI_TNLTYPE_STR_NO_INFO "No info"
94 #define PMSI_TNLTYPE_STR_DEFAULT PMSI_TNLTYPE_STR_NO_INFO
95 static const struct message bgp_pmsi_tnltype_str
[] = {
96 {PMSI_TNLTYPE_NO_INFO
, PMSI_TNLTYPE_STR_NO_INFO
},
97 {PMSI_TNLTYPE_RSVP_TE_P2MP
, "RSVP-TE P2MP"},
98 {PMSI_TNLTYPE_MLDP_P2MP
, "mLDP P2MP"},
99 {PMSI_TNLTYPE_PIM_SSM
, "PIM-SSM"},
100 {PMSI_TNLTYPE_PIM_SM
, "PIM-SM"},
101 {PMSI_TNLTYPE_PIM_BIDIR
, "PIM-BIDIR"},
102 {PMSI_TNLTYPE_INGR_REPL
, "Ingress Replication"},
103 {PMSI_TNLTYPE_MLDP_MP2MP
, "mLDP MP2MP"},
107 #define VRFID_NONE_STR "-"
109 struct bgp_node
*bgp_afi_node_get(struct bgp_table
*table
, afi_t afi
,
110 safi_t safi
, struct prefix
*p
,
111 struct prefix_rd
*prd
)
114 struct bgp_node
*prn
= NULL
;
120 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
121 || (safi
== SAFI_EVPN
)) {
122 prn
= bgp_node_get(table
, (struct prefix
*)prd
);
124 if (!bgp_node_has_bgp_path_info_data(prn
))
125 bgp_node_set_bgp_table_info(
126 prn
, bgp_table_init(table
->bgp
, afi
, safi
));
128 bgp_unlock_node(prn
);
129 table
= bgp_node_get_bgp_table_info(prn
);
132 rn
= bgp_node_get(table
, p
);
134 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
135 || (safi
== SAFI_EVPN
))
141 struct bgp_node
*bgp_afi_node_lookup(struct bgp_table
*table
, afi_t afi
,
142 safi_t safi
, struct prefix
*p
,
143 struct prefix_rd
*prd
)
146 struct bgp_node
*prn
= NULL
;
151 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
152 || (safi
== SAFI_EVPN
)) {
153 prn
= bgp_node_lookup(table
, (struct prefix
*)prd
);
157 if (!bgp_node_has_bgp_path_info_data(prn
)) {
158 bgp_unlock_node(prn
);
162 table
= bgp_node_get_bgp_table_info(prn
);
165 rn
= bgp_node_lookup(table
, p
);
170 /* Allocate bgp_path_info_extra */
171 static struct bgp_path_info_extra
*bgp_path_info_extra_new(void)
173 struct bgp_path_info_extra
*new;
174 new = XCALLOC(MTYPE_BGP_ROUTE_EXTRA
,
175 sizeof(struct bgp_path_info_extra
));
176 new->label
[0] = MPLS_INVALID_LABEL
;
178 new->bgp_fs_pbr
= NULL
;
179 new->bgp_fs_iprule
= NULL
;
183 void bgp_path_info_extra_free(struct bgp_path_info_extra
**extra
)
185 struct bgp_path_info_extra
*e
;
187 if (!extra
|| !*extra
)
192 bgp_damp_info_free(e
->damp_info
, 0);
196 struct bgp_path_info
*bpi
= (struct bgp_path_info
*)e
->parent
;
199 /* FIXME: since multiple e may have the same e->parent
200 * and e->parent->net is holding a refcount for each
201 * of them, we need to do some fudging here.
203 * WARNING: if bpi->net->lock drops to 0, bpi may be
204 * freed as well (because bpi->net was holding the
205 * last reference to bpi) => write after free!
209 bpi
= bgp_path_info_lock(bpi
);
210 refcount
= bpi
->net
->lock
- 1;
211 bgp_unlock_node((struct bgp_node
*)bpi
->net
);
214 bgp_path_info_unlock(bpi
);
216 bgp_path_info_unlock(e
->parent
);
221 bgp_unlock(e
->bgp_orig
);
223 if ((*extra
)->bgp_fs_iprule
)
224 list_delete(&((*extra
)->bgp_fs_iprule
));
225 if ((*extra
)->bgp_fs_pbr
)
226 list_delete(&((*extra
)->bgp_fs_pbr
));
227 XFREE(MTYPE_BGP_ROUTE_EXTRA
, *extra
);
232 /* Get bgp_path_info extra information for the given bgp_path_info, lazy
233 * allocated if required.
235 struct bgp_path_info_extra
*bgp_path_info_extra_get(struct bgp_path_info
*pi
)
238 pi
->extra
= bgp_path_info_extra_new();
242 /* Free bgp route information. */
243 static void bgp_path_info_free(struct bgp_path_info
*path
)
246 bgp_attr_unintern(&path
->attr
);
248 bgp_unlink_nexthop(path
);
249 bgp_path_info_extra_free(&path
->extra
);
250 bgp_path_info_mpath_free(&path
->mpath
);
252 bgp_addpath_free_info_data(&path
->tx_addpath
,
253 &path
->net
->tx_addpath
);
255 peer_unlock(path
->peer
); /* bgp_path_info peer reference */
257 XFREE(MTYPE_BGP_ROUTE
, path
);
260 struct bgp_path_info
*bgp_path_info_lock(struct bgp_path_info
*path
)
266 struct bgp_path_info
*bgp_path_info_unlock(struct bgp_path_info
*path
)
268 assert(path
&& path
->lock
> 0);
271 if (path
->lock
== 0) {
273 zlog_debug ("%s: unlocked and freeing", __func__
);
274 zlog_backtrace (LOG_DEBUG
);
276 bgp_path_info_free(path
);
283 zlog_debug ("%s: unlocked to 1", __func__
);
284 zlog_backtrace (LOG_DEBUG
);
291 void bgp_path_info_add(struct bgp_node
*rn
, struct bgp_path_info
*pi
)
293 struct bgp_path_info
*top
;
295 top
= bgp_node_get_bgp_path_info(rn
);
301 bgp_node_set_bgp_path_info(rn
, pi
);
303 bgp_path_info_lock(pi
);
305 peer_lock(pi
->peer
); /* bgp_path_info peer reference */
308 /* Do the actual removal of info from RIB, for use by bgp_process
309 completion callback *only* */
310 void bgp_path_info_reap(struct bgp_node
*rn
, struct bgp_path_info
*pi
)
313 pi
->next
->prev
= pi
->prev
;
315 pi
->prev
->next
= pi
->next
;
317 bgp_node_set_bgp_path_info(rn
, pi
->next
);
319 bgp_path_info_mpath_dequeue(pi
);
320 bgp_path_info_unlock(pi
);
324 void bgp_path_info_delete(struct bgp_node
*rn
, struct bgp_path_info
*pi
)
326 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_REMOVED
);
327 /* set of previous already took care of pcount */
328 UNSET_FLAG(pi
->flags
, BGP_PATH_VALID
);
331 /* undo the effects of a previous call to bgp_path_info_delete; typically
332 called when a route is deleted and then quickly re-added before the
333 deletion has been processed */
334 void bgp_path_info_restore(struct bgp_node
*rn
, struct bgp_path_info
*pi
)
336 bgp_path_info_unset_flag(rn
, pi
, BGP_PATH_REMOVED
);
337 /* unset of previous already took care of pcount */
338 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
341 /* Adjust pcount as required */
342 static void bgp_pcount_adjust(struct bgp_node
*rn
, struct bgp_path_info
*pi
)
344 struct bgp_table
*table
;
346 assert(rn
&& bgp_node_table(rn
));
347 assert(pi
&& pi
->peer
&& pi
->peer
->bgp
);
349 table
= bgp_node_table(rn
);
351 if (pi
->peer
== pi
->peer
->bgp
->peer_self
)
354 if (!BGP_PATH_COUNTABLE(pi
)
355 && CHECK_FLAG(pi
->flags
, BGP_PATH_COUNTED
)) {
357 UNSET_FLAG(pi
->flags
, BGP_PATH_COUNTED
);
359 /* slight hack, but more robust against errors. */
360 if (pi
->peer
->pcount
[table
->afi
][table
->safi
])
361 pi
->peer
->pcount
[table
->afi
][table
->safi
]--;
363 flog_err(EC_LIB_DEVELOPMENT
,
364 "Asked to decrement 0 prefix count for peer");
365 } else if (BGP_PATH_COUNTABLE(pi
)
366 && !CHECK_FLAG(pi
->flags
, BGP_PATH_COUNTED
)) {
367 SET_FLAG(pi
->flags
, BGP_PATH_COUNTED
);
368 pi
->peer
->pcount
[table
->afi
][table
->safi
]++;
372 static int bgp_label_index_differs(struct bgp_path_info
*pi1
,
373 struct bgp_path_info
*pi2
)
375 return (!(pi1
->attr
->label_index
== pi2
->attr
->label_index
));
378 /* Set/unset bgp_path_info flags, adjusting any other state as needed.
379 * This is here primarily to keep prefix-count in check.
381 void bgp_path_info_set_flag(struct bgp_node
*rn
, struct bgp_path_info
*pi
,
384 SET_FLAG(pi
->flags
, flag
);
386 /* early bath if we know it's not a flag that changes countability state
388 if (!CHECK_FLAG(flag
,
389 BGP_PATH_VALID
| BGP_PATH_HISTORY
| BGP_PATH_REMOVED
))
392 bgp_pcount_adjust(rn
, pi
);
395 void bgp_path_info_unset_flag(struct bgp_node
*rn
, struct bgp_path_info
*pi
,
398 UNSET_FLAG(pi
->flags
, flag
);
400 /* early bath if we know it's not a flag that changes countability state
402 if (!CHECK_FLAG(flag
,
403 BGP_PATH_VALID
| BGP_PATH_HISTORY
| BGP_PATH_REMOVED
))
406 bgp_pcount_adjust(rn
, pi
);
409 /* Get MED value. If MED value is missing and "bgp bestpath
410 missing-as-worst" is specified, treat it as the worst value. */
411 static uint32_t bgp_med_value(struct attr
*attr
, struct bgp
*bgp
)
413 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
))
416 if (bgp_flag_check(bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
423 void bgp_path_info_path_with_addpath_rx_str(struct bgp_path_info
*pi
, char *buf
)
425 if (pi
->addpath_rx_id
)
426 sprintf(buf
, "path %s (addpath rxid %d)", pi
->peer
->host
,
429 sprintf(buf
, "path %s", pi
->peer
->host
);
432 /* Compare two bgp route entity. If 'new' is preferable over 'exist' return 1.
434 static int bgp_path_info_cmp(struct bgp
*bgp
, struct bgp_path_info
*new,
435 struct bgp_path_info
*exist
, int *paths_eq
,
436 struct bgp_maxpaths_cfg
*mpath_cfg
, int debug
,
437 char *pfx_buf
, afi_t afi
, safi_t safi
)
439 struct attr
*newattr
, *existattr
;
440 bgp_peer_sort_t new_sort
;
441 bgp_peer_sort_t exist_sort
;
447 uint32_t exist_weight
;
448 uint32_t newm
, existm
;
449 struct in_addr new_id
;
450 struct in_addr exist_id
;
453 int internal_as_route
;
456 char new_buf
[PATH_ADDPATH_STR_BUFFER
];
457 char exist_buf
[PATH_ADDPATH_STR_BUFFER
];
459 uint32_t exist_mm_seq
;
467 zlog_debug("%s: new is NULL", pfx_buf
);
472 bgp_path_info_path_with_addpath_rx_str(new, new_buf
);
476 zlog_debug("%s: %s is the initial bestpath", pfx_buf
,
482 bgp_path_info_path_with_addpath_rx_str(exist
, exist_buf
);
483 zlog_debug("%s: Comparing %s flags 0x%x with %s flags 0x%x",
484 pfx_buf
, new_buf
, new->flags
, exist_buf
,
489 existattr
= exist
->attr
;
491 /* For EVPN routes, we cannot just go by local vs remote, we have to
492 * look at the MAC mobility sequence number, if present.
494 if (safi
== SAFI_EVPN
) {
495 /* This is an error condition described in RFC 7432 Section
497 * states that in this scenario "the PE MUST alert the operator"
499 * does not state what other action to take. In order to provide
501 * consistency in this scenario we are going to prefer the path
505 if (newattr
->sticky
!= existattr
->sticky
) {
507 prefix2str(&new->net
->p
, pfx_buf
,
509 * PREFIX2STR_BUFFER
);
510 bgp_path_info_path_with_addpath_rx_str(new,
512 bgp_path_info_path_with_addpath_rx_str(
516 if (newattr
->sticky
&& !existattr
->sticky
) {
519 "%s: %s wins over %s due to sticky MAC flag",
520 pfx_buf
, new_buf
, exist_buf
);
524 if (!newattr
->sticky
&& existattr
->sticky
) {
527 "%s: %s loses to %s due to sticky MAC flag",
528 pfx_buf
, new_buf
, exist_buf
);
533 new_mm_seq
= mac_mobility_seqnum(newattr
);
534 exist_mm_seq
= mac_mobility_seqnum(existattr
);
536 if (new_mm_seq
> exist_mm_seq
) {
539 "%s: %s wins over %s due to MM seq %u > %u",
540 pfx_buf
, new_buf
, exist_buf
, new_mm_seq
,
545 if (new_mm_seq
< exist_mm_seq
) {
548 "%s: %s loses to %s due to MM seq %u < %u",
549 pfx_buf
, new_buf
, exist_buf
, new_mm_seq
,
555 * if sequence numbers are the same path with the lowest IP
558 nh_cmp
= bgp_path_info_nexthop_cmp(new, exist
);
562 "%s: %s wins over %s due to same MM seq %u and lower IP %s",
563 pfx_buf
, new_buf
, exist_buf
, new_mm_seq
,
564 inet_ntoa(new->attr
->nexthop
));
570 "%s: %s loses to %s due to same MM seq %u and higher IP %s",
571 pfx_buf
, new_buf
, exist_buf
, new_mm_seq
,
572 inet_ntoa(new->attr
->nexthop
));
577 /* 1. Weight check. */
578 new_weight
= newattr
->weight
;
579 exist_weight
= existattr
->weight
;
581 if (new_weight
> exist_weight
) {
583 zlog_debug("%s: %s wins over %s due to weight %d > %d",
584 pfx_buf
, new_buf
, exist_buf
, new_weight
,
589 if (new_weight
< exist_weight
) {
591 zlog_debug("%s: %s loses to %s due to weight %d < %d",
592 pfx_buf
, new_buf
, exist_buf
, new_weight
,
597 /* 2. Local preference check. */
598 new_pref
= exist_pref
= bgp
->default_local_pref
;
600 if (newattr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
))
601 new_pref
= newattr
->local_pref
;
602 if (existattr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
))
603 exist_pref
= existattr
->local_pref
;
605 if (new_pref
> exist_pref
) {
608 "%s: %s wins over %s due to localpref %d > %d",
609 pfx_buf
, new_buf
, exist_buf
, new_pref
,
614 if (new_pref
< exist_pref
) {
617 "%s: %s loses to %s due to localpref %d < %d",
618 pfx_buf
, new_buf
, exist_buf
, new_pref
,
623 /* 3. Local route check. We prefer:
625 * - BGP_ROUTE_AGGREGATE
626 * - BGP_ROUTE_REDISTRIBUTE
628 if (!(new->sub_type
== BGP_ROUTE_NORMAL
||
629 new->sub_type
== BGP_ROUTE_IMPORTED
)) {
632 "%s: %s wins over %s due to preferred BGP_ROUTE type",
633 pfx_buf
, new_buf
, exist_buf
);
637 if (!(exist
->sub_type
== BGP_ROUTE_NORMAL
||
638 exist
->sub_type
== BGP_ROUTE_IMPORTED
)) {
641 "%s: %s loses to %s due to preferred BGP_ROUTE type",
642 pfx_buf
, new_buf
, exist_buf
);
646 /* 4. AS path length check. */
647 if (!bgp_flag_check(bgp
, BGP_FLAG_ASPATH_IGNORE
)) {
648 int exist_hops
= aspath_count_hops(existattr
->aspath
);
649 int exist_confeds
= aspath_count_confeds(existattr
->aspath
);
651 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_CONFED
)) {
654 aspath_hops
= aspath_count_hops(newattr
->aspath
);
655 aspath_hops
+= aspath_count_confeds(newattr
->aspath
);
657 if (aspath_hops
< (exist_hops
+ exist_confeds
)) {
660 "%s: %s wins over %s due to aspath (with confeds) hopcount %d < %d",
661 pfx_buf
, new_buf
, exist_buf
,
663 (exist_hops
+ exist_confeds
));
667 if (aspath_hops
> (exist_hops
+ exist_confeds
)) {
670 "%s: %s loses to %s due to aspath (with confeds) hopcount %d > %d",
671 pfx_buf
, new_buf
, exist_buf
,
673 (exist_hops
+ exist_confeds
));
677 int newhops
= aspath_count_hops(newattr
->aspath
);
679 if (newhops
< exist_hops
) {
682 "%s: %s wins over %s due to aspath hopcount %d < %d",
683 pfx_buf
, new_buf
, exist_buf
,
684 newhops
, exist_hops
);
688 if (newhops
> exist_hops
) {
691 "%s: %s loses to %s due to aspath hopcount %d > %d",
692 pfx_buf
, new_buf
, exist_buf
,
693 newhops
, exist_hops
);
699 /* 5. Origin check. */
700 if (newattr
->origin
< existattr
->origin
) {
702 zlog_debug("%s: %s wins over %s due to ORIGIN %s < %s",
703 pfx_buf
, new_buf
, exist_buf
,
704 bgp_origin_long_str
[newattr
->origin
],
705 bgp_origin_long_str
[existattr
->origin
]);
709 if (newattr
->origin
> existattr
->origin
) {
711 zlog_debug("%s: %s loses to %s due to ORIGIN %s > %s",
712 pfx_buf
, new_buf
, exist_buf
,
713 bgp_origin_long_str
[newattr
->origin
],
714 bgp_origin_long_str
[existattr
->origin
]);
719 internal_as_route
= (aspath_count_hops(newattr
->aspath
) == 0
720 && aspath_count_hops(existattr
->aspath
) == 0);
721 confed_as_route
= (aspath_count_confeds(newattr
->aspath
) > 0
722 && aspath_count_confeds(existattr
->aspath
) > 0
723 && aspath_count_hops(newattr
->aspath
) == 0
724 && aspath_count_hops(existattr
->aspath
) == 0);
726 if (bgp_flag_check(bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
)
727 || (bgp_flag_check(bgp
, BGP_FLAG_MED_CONFED
) && confed_as_route
)
728 || aspath_cmp_left(newattr
->aspath
, existattr
->aspath
)
729 || aspath_cmp_left_confed(newattr
->aspath
, existattr
->aspath
)
730 || internal_as_route
) {
731 new_med
= bgp_med_value(new->attr
, bgp
);
732 exist_med
= bgp_med_value(exist
->attr
, bgp
);
734 if (new_med
< exist_med
) {
737 "%s: %s wins over %s due to MED %d < %d",
738 pfx_buf
, new_buf
, exist_buf
, new_med
,
743 if (new_med
> exist_med
) {
746 "%s: %s loses to %s due to MED %d > %d",
747 pfx_buf
, new_buf
, exist_buf
, new_med
,
753 /* 7. Peer type check. */
754 new_sort
= new->peer
->sort
;
755 exist_sort
= exist
->peer
->sort
;
757 if (new_sort
== BGP_PEER_EBGP
758 && (exist_sort
== BGP_PEER_IBGP
|| exist_sort
== BGP_PEER_CONFED
)) {
761 "%s: %s wins over %s due to eBGP peer > iBGP peer",
762 pfx_buf
, new_buf
, exist_buf
);
766 if (exist_sort
== BGP_PEER_EBGP
767 && (new_sort
== BGP_PEER_IBGP
|| new_sort
== BGP_PEER_CONFED
)) {
770 "%s: %s loses to %s due to iBGP peer < eBGP peer",
771 pfx_buf
, new_buf
, exist_buf
);
775 /* 8. IGP metric check. */
779 newm
= new->extra
->igpmetric
;
781 existm
= exist
->extra
->igpmetric
;
786 "%s: %s wins over %s due to IGP metric %d < %d",
787 pfx_buf
, new_buf
, exist_buf
, newm
, existm
);
794 "%s: %s loses to %s due to IGP metric %d > %d",
795 pfx_buf
, new_buf
, exist_buf
, newm
, existm
);
799 /* 9. Same IGP metric. Compare the cluster list length as
800 representative of IGP hops metric. Rewrite the metric value
801 pair (newm, existm) with the cluster list length. Prefer the
802 path with smaller cluster list length. */
803 if (newm
== existm
) {
804 if (peer_sort(new->peer
) == BGP_PEER_IBGP
805 && peer_sort(exist
->peer
) == BGP_PEER_IBGP
806 && (mpath_cfg
== NULL
808 mpath_cfg
->ibgp_flags
,
809 BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN
))) {
810 newm
= BGP_CLUSTER_LIST_LENGTH(new->attr
);
811 existm
= BGP_CLUSTER_LIST_LENGTH(exist
->attr
);
816 "%s: %s wins over %s due to CLUSTER_LIST length %d < %d",
817 pfx_buf
, new_buf
, exist_buf
,
825 "%s: %s loses to %s due to CLUSTER_LIST length %d > %d",
826 pfx_buf
, new_buf
, exist_buf
,
833 /* 10. confed-external vs. confed-internal */
834 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
835 if (new_sort
== BGP_PEER_CONFED
836 && exist_sort
== BGP_PEER_IBGP
) {
839 "%s: %s wins over %s due to confed-external peer > confed-internal peer",
840 pfx_buf
, new_buf
, exist_buf
);
844 if (exist_sort
== BGP_PEER_CONFED
845 && new_sort
== BGP_PEER_IBGP
) {
848 "%s: %s loses to %s due to confed-internal peer < confed-external peer",
849 pfx_buf
, new_buf
, exist_buf
);
854 /* 11. Maximum path check. */
855 if (newm
== existm
) {
856 /* If one path has a label but the other does not, do not treat
857 * them as equals for multipath
859 if ((new->extra
&&bgp_is_valid_label(&new->extra
->label
[0]))
861 && bgp_is_valid_label(&exist
->extra
->label
[0]))) {
864 "%s: %s and %s cannot be multipath, one has a label while the other does not",
865 pfx_buf
, new_buf
, exist_buf
);
866 } else if (bgp_flag_check(bgp
,
867 BGP_FLAG_ASPATH_MULTIPATH_RELAX
)) {
870 * For the two paths, all comparison steps till IGP
872 * have succeeded - including AS_PATH hop count. Since
874 * bestpath as-path multipath-relax' knob is on, we
876 * an exact match of AS_PATH. Thus, mark the paths are
878 * That will trigger both these paths to get into the
886 "%s: %s and %s are equal via multipath-relax",
887 pfx_buf
, new_buf
, exist_buf
);
888 } else if (new->peer
->sort
== BGP_PEER_IBGP
) {
889 if (aspath_cmp(new->attr
->aspath
,
890 exist
->attr
->aspath
)) {
895 "%s: %s and %s are equal via matching aspaths",
896 pfx_buf
, new_buf
, exist_buf
);
898 } else if (new->peer
->as
== exist
->peer
->as
) {
903 "%s: %s and %s are equal via same remote-as",
904 pfx_buf
, new_buf
, exist_buf
);
908 * TODO: If unequal cost ibgp multipath is enabled we can
909 * mark the paths as equal here instead of returning
914 "%s: %s wins over %s after IGP metric comparison",
915 pfx_buf
, new_buf
, exist_buf
);
918 "%s: %s loses to %s after IGP metric comparison",
919 pfx_buf
, new_buf
, exist_buf
);
924 /* 12. If both paths are external, prefer the path that was received
925 first (the oldest one). This step minimizes route-flap, since a
926 newer path won't displace an older one, even if it was the
927 preferred route based on the additional decision criteria below. */
928 if (!bgp_flag_check(bgp
, BGP_FLAG_COMPARE_ROUTER_ID
)
929 && new_sort
== BGP_PEER_EBGP
&& exist_sort
== BGP_PEER_EBGP
) {
930 if (CHECK_FLAG(new->flags
, BGP_PATH_SELECTED
)) {
933 "%s: %s wins over %s due to oldest external",
934 pfx_buf
, new_buf
, exist_buf
);
938 if (CHECK_FLAG(exist
->flags
, BGP_PATH_SELECTED
)) {
941 "%s: %s loses to %s due to oldest external",
942 pfx_buf
, new_buf
, exist_buf
);
947 /* 13. Router-ID comparision. */
948 /* If one of the paths is "stale", the corresponding peer router-id will
949 * be 0 and would always win over the other path. If originator id is
950 * used for the comparision, it will decide which path is better.
952 if (newattr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
953 new_id
.s_addr
= newattr
->originator_id
.s_addr
;
955 new_id
.s_addr
= new->peer
->remote_id
.s_addr
;
956 if (existattr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
957 exist_id
.s_addr
= existattr
->originator_id
.s_addr
;
959 exist_id
.s_addr
= exist
->peer
->remote_id
.s_addr
;
961 if (ntohl(new_id
.s_addr
) < ntohl(exist_id
.s_addr
)) {
964 "%s: %s wins over %s due to Router-ID comparison",
965 pfx_buf
, new_buf
, exist_buf
);
969 if (ntohl(new_id
.s_addr
) > ntohl(exist_id
.s_addr
)) {
972 "%s: %s loses to %s due to Router-ID comparison",
973 pfx_buf
, new_buf
, exist_buf
);
977 /* 14. Cluster length comparision. */
978 new_cluster
= BGP_CLUSTER_LIST_LENGTH(new->attr
);
979 exist_cluster
= BGP_CLUSTER_LIST_LENGTH(exist
->attr
);
981 if (new_cluster
< exist_cluster
) {
984 "%s: %s wins over %s due to CLUSTER_LIST length %d < %d",
985 pfx_buf
, new_buf
, exist_buf
, new_cluster
,
990 if (new_cluster
> exist_cluster
) {
993 "%s: %s loses to %s due to CLUSTER_LIST length %d > %d",
994 pfx_buf
, new_buf
, exist_buf
, new_cluster
,
999 /* 15. Neighbor address comparision. */
1000 /* Do this only if neither path is "stale" as stale paths do not have
1001 * valid peer information (as the connection may or may not be up).
1003 if (CHECK_FLAG(exist
->flags
, BGP_PATH_STALE
)) {
1006 "%s: %s wins over %s due to latter path being STALE",
1007 pfx_buf
, new_buf
, exist_buf
);
1011 if (CHECK_FLAG(new->flags
, BGP_PATH_STALE
)) {
1014 "%s: %s loses to %s due to former path being STALE",
1015 pfx_buf
, new_buf
, exist_buf
);
1019 /* locally configured routes to advertise do not have su_remote */
1020 if (new->peer
->su_remote
== NULL
)
1022 if (exist
->peer
->su_remote
== NULL
)
1025 ret
= sockunion_cmp(new->peer
->su_remote
, exist
->peer
->su_remote
);
1030 "%s: %s loses to %s due to Neighor IP comparison",
1031 pfx_buf
, new_buf
, exist_buf
);
1038 "%s: %s wins over %s due to Neighor IP comparison",
1039 pfx_buf
, new_buf
, exist_buf
);
1044 zlog_debug("%s: %s wins over %s due to nothing left to compare",
1045 pfx_buf
, new_buf
, exist_buf
);
1050 /* Compare two bgp route entity. Return -1 if new is preferred, 1 if exist
1051 * is preferred, or 0 if they are the same (usually will only occur if
1052 * multipath is enabled
1053 * This version is compatible with */
1054 int bgp_path_info_cmp_compatible(struct bgp
*bgp
, struct bgp_path_info
*new,
1055 struct bgp_path_info
*exist
, char *pfx_buf
,
1056 afi_t afi
, safi_t safi
)
1060 ret
= bgp_path_info_cmp(bgp
, new, exist
, &paths_eq
, NULL
, 0, pfx_buf
,
1074 static enum filter_type
bgp_input_filter(struct peer
*peer
, struct prefix
*p
,
1075 struct attr
*attr
, afi_t afi
,
1078 struct bgp_filter
*filter
;
1080 filter
= &peer
->filter
[afi
][safi
];
1082 #define FILTER_EXIST_WARN(F, f, filter) \
1083 if (BGP_DEBUG(update, UPDATE_IN) && !(F##_IN(filter))) \
1084 zlog_debug("%s: Could not find configured input %s-list %s!", \
1085 peer->host, #f, F##_IN_NAME(filter));
1087 if (DISTRIBUTE_IN_NAME(filter
)) {
1088 FILTER_EXIST_WARN(DISTRIBUTE
, distribute
, filter
);
1090 if (access_list_apply(DISTRIBUTE_IN(filter
), p
) == FILTER_DENY
)
1094 if (PREFIX_LIST_IN_NAME(filter
)) {
1095 FILTER_EXIST_WARN(PREFIX_LIST
, prefix
, filter
);
1097 if (prefix_list_apply(PREFIX_LIST_IN(filter
), p
) == PREFIX_DENY
)
1101 if (FILTER_LIST_IN_NAME(filter
)) {
1102 FILTER_EXIST_WARN(FILTER_LIST
, as
, filter
);
1104 if (as_list_apply(FILTER_LIST_IN(filter
), attr
->aspath
)
1109 return FILTER_PERMIT
;
1110 #undef FILTER_EXIST_WARN
1113 static enum filter_type
bgp_output_filter(struct peer
*peer
, struct prefix
*p
,
1114 struct attr
*attr
, afi_t afi
,
1117 struct bgp_filter
*filter
;
1119 filter
= &peer
->filter
[afi
][safi
];
1121 #define FILTER_EXIST_WARN(F, f, filter) \
1122 if (BGP_DEBUG(update, UPDATE_OUT) && !(F##_OUT(filter))) \
1123 zlog_debug("%s: Could not find configured output %s-list %s!", \
1124 peer->host, #f, F##_OUT_NAME(filter));
1126 if (DISTRIBUTE_OUT_NAME(filter
)) {
1127 FILTER_EXIST_WARN(DISTRIBUTE
, distribute
, filter
);
1129 if (access_list_apply(DISTRIBUTE_OUT(filter
), p
) == FILTER_DENY
)
1133 if (PREFIX_LIST_OUT_NAME(filter
)) {
1134 FILTER_EXIST_WARN(PREFIX_LIST
, prefix
, filter
);
1136 if (prefix_list_apply(PREFIX_LIST_OUT(filter
), p
)
1141 if (FILTER_LIST_OUT_NAME(filter
)) {
1142 FILTER_EXIST_WARN(FILTER_LIST
, as
, filter
);
1144 if (as_list_apply(FILTER_LIST_OUT(filter
), attr
->aspath
)
1149 return FILTER_PERMIT
;
1150 #undef FILTER_EXIST_WARN
1153 /* If community attribute includes no_export then return 1. */
1154 static int bgp_community_filter(struct peer
*peer
, struct attr
*attr
)
1156 if (attr
->community
) {
1157 /* NO_ADVERTISE check. */
1158 if (community_include(attr
->community
, COMMUNITY_NO_ADVERTISE
))
1161 /* NO_EXPORT check. */
1162 if (peer
->sort
== BGP_PEER_EBGP
1163 && community_include(attr
->community
, COMMUNITY_NO_EXPORT
))
1166 /* NO_EXPORT_SUBCONFED check. */
1167 if (peer
->sort
== BGP_PEER_EBGP
1168 || peer
->sort
== BGP_PEER_CONFED
)
1169 if (community_include(attr
->community
,
1170 COMMUNITY_NO_EXPORT_SUBCONFED
))
1176 /* Route reflection loop check. */
1177 static int bgp_cluster_filter(struct peer
*peer
, struct attr
*attr
)
1179 struct in_addr cluster_id
;
1181 if (attr
->cluster
) {
1182 if (peer
->bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
1183 cluster_id
= peer
->bgp
->cluster_id
;
1185 cluster_id
= peer
->bgp
->router_id
;
1187 if (cluster_loop_check(attr
->cluster
, cluster_id
))
1193 static int bgp_input_modifier(struct peer
*peer
, struct prefix
*p
,
1194 struct attr
*attr
, afi_t afi
, safi_t safi
,
1195 const char *rmap_name
)
1197 struct bgp_filter
*filter
;
1198 struct bgp_path_info rmap_path
;
1199 route_map_result_t ret
;
1200 struct route_map
*rmap
= NULL
;
1202 filter
= &peer
->filter
[afi
][safi
];
1204 /* Apply default weight value. */
1205 if (peer
->weight
[afi
][safi
])
1206 attr
->weight
= peer
->weight
[afi
][safi
];
1209 rmap
= route_map_lookup_by_name(rmap_name
);
1214 if (ROUTE_MAP_IN_NAME(filter
)) {
1215 rmap
= ROUTE_MAP_IN(filter
);
1222 /* RFC 8212 to prevent route leaks.
1223 * This specification intends to improve this situation by requiring the
1224 * explicit configuration of both BGP Import and Export Policies for any
1225 * External BGP (EBGP) session such as customers, peers, or
1226 * confederation boundaries for all enabled address families. Through
1227 * codification of the aforementioned requirement, operators will
1228 * benefit from consistent behavior across different BGP
1231 if (peer
->bgp
->ebgp_requires_policy
1232 == DEFAULT_EBGP_POLICY_ENABLED
)
1233 if (!bgp_inbound_policy_exists(peer
, filter
))
1236 /* Route map apply. */
1238 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
1239 /* Duplicate current value to new strucutre for modification. */
1240 rmap_path
.peer
= peer
;
1241 rmap_path
.attr
= attr
;
1243 SET_FLAG(peer
->rmap_type
, PEER_RMAP_TYPE_IN
);
1245 /* Apply BGP route map to the attribute. */
1246 ret
= route_map_apply(rmap
, p
, RMAP_BGP
, &rmap_path
);
1248 peer
->rmap_type
= 0;
1250 if (ret
== RMAP_DENYMATCH
)
1256 static int bgp_output_modifier(struct peer
*peer
, struct prefix
*p
,
1257 struct attr
*attr
, afi_t afi
, safi_t safi
,
1258 const char *rmap_name
)
1260 struct bgp_path_info rmap_path
;
1261 route_map_result_t ret
;
1262 struct route_map
*rmap
= NULL
;
1266 * So if we get to this point and have no rmap_name
1267 * we want to just show the output as it currently
1273 /* Apply default weight value. */
1274 if (peer
->weight
[afi
][safi
])
1275 attr
->weight
= peer
->weight
[afi
][safi
];
1277 rmap
= route_map_lookup_by_name(rmap_name
);
1280 * If we have a route map name and we do not find
1281 * the routemap that means we have an implicit
1287 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
1288 /* Route map apply. */
1289 /* Duplicate current value to new strucutre for modification. */
1290 rmap_path
.peer
= peer
;
1291 rmap_path
.attr
= attr
;
1293 rmap_type
= peer
->rmap_type
;
1294 SET_FLAG(peer
->rmap_type
, PEER_RMAP_TYPE_OUT
);
1296 /* Apply BGP route map to the attribute. */
1297 ret
= route_map_apply(rmap
, p
, RMAP_BGP
, &rmap_path
);
1299 peer
->rmap_type
= rmap_type
;
1301 if (ret
== RMAP_DENYMATCH
)
1303 * caller has multiple error paths with bgp_attr_flush()
1310 /* If this is an EBGP peer with remove-private-AS */
1311 static void bgp_peer_remove_private_as(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1312 struct peer
*peer
, struct attr
*attr
)
1314 if (peer
->sort
== BGP_PEER_EBGP
1315 && (peer_af_flag_check(peer
, afi
, safi
,
1316 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)
1317 || peer_af_flag_check(peer
, afi
, safi
,
1318 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)
1319 || peer_af_flag_check(peer
, afi
, safi
,
1320 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)
1321 || peer_af_flag_check(peer
, afi
, safi
,
1322 PEER_FLAG_REMOVE_PRIVATE_AS
))) {
1323 // Take action on the entire aspath
1324 if (peer_af_flag_check(peer
, afi
, safi
,
1325 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)
1326 || peer_af_flag_check(peer
, afi
, safi
,
1327 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)) {
1328 if (peer_af_flag_check(
1330 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
))
1331 attr
->aspath
= aspath_replace_private_asns(
1332 attr
->aspath
, bgp
->as
);
1334 // The entire aspath consists of private ASNs so create
1336 else if (aspath_private_as_check(attr
->aspath
))
1337 attr
->aspath
= aspath_empty_get();
1339 // There are some public and some private ASNs, remove
1342 attr
->aspath
= aspath_remove_private_asns(
1346 // 'all' was not specified so the entire aspath must be private
1348 // for us to do anything
1349 else if (aspath_private_as_check(attr
->aspath
)) {
1350 if (peer_af_flag_check(
1352 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
))
1353 attr
->aspath
= aspath_replace_private_asns(
1354 attr
->aspath
, bgp
->as
);
1356 attr
->aspath
= aspath_empty_get();
1361 /* If this is an EBGP peer with as-override */
1362 static void bgp_peer_as_override(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1363 struct peer
*peer
, struct attr
*attr
)
1365 if (peer
->sort
== BGP_PEER_EBGP
1366 && peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
)) {
1367 if (aspath_single_asn_check(attr
->aspath
, peer
->as
))
1368 attr
->aspath
= aspath_replace_specific_asn(
1369 attr
->aspath
, peer
->as
, bgp
->as
);
1373 void bgp_attr_add_gshut_community(struct attr
*attr
)
1375 struct community
*old
;
1376 struct community
*new;
1377 struct community
*merge
;
1378 struct community
*gshut
;
1380 old
= attr
->community
;
1381 gshut
= community_str2com("graceful-shutdown");
1386 merge
= community_merge(community_dup(old
), gshut
);
1388 if (old
->refcnt
== 0)
1389 community_free(&old
);
1391 new = community_uniq_sort(merge
);
1392 community_free(&merge
);
1394 new = community_dup(gshut
);
1397 community_free(&gshut
);
1398 attr
->community
= new;
1399 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
);
1401 /* When we add the graceful-shutdown community we must also
1402 * lower the local-preference */
1403 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1404 attr
->local_pref
= BGP_GSHUT_LOCAL_PREF
;
1408 static void subgroup_announce_reset_nhop(uint8_t family
, struct attr
*attr
)
1410 if (family
== AF_INET
) {
1411 attr
->nexthop
.s_addr
= 0;
1412 attr
->mp_nexthop_global_in
.s_addr
= 0;
1414 if (family
== AF_INET6
)
1415 memset(&attr
->mp_nexthop_global
, 0, IPV6_MAX_BYTELEN
);
1416 if (family
== AF_EVPN
)
1417 memset(&attr
->mp_nexthop_global_in
, 0, BGP_ATTR_NHLEN_IPV4
);
1420 int subgroup_announce_check(struct bgp_node
*rn
, struct bgp_path_info
*pi
,
1421 struct update_subgroup
*subgrp
, struct prefix
*p
,
1424 struct bgp_filter
*filter
;
1427 struct peer
*onlypeer
;
1429 struct attr
*piattr
;
1430 char buf
[PREFIX_STRLEN
];
1436 int samepeer_safe
= 0; /* for synthetic mplsvpns routes */
1438 if (DISABLE_BGP_ANNOUNCE
)
1441 afi
= SUBGRP_AFI(subgrp
);
1442 safi
= SUBGRP_SAFI(subgrp
);
1443 peer
= SUBGRP_PEER(subgrp
);
1445 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
))
1446 onlypeer
= SUBGRP_PFIRST(subgrp
)->peer
;
1449 filter
= &peer
->filter
[afi
][safi
];
1450 bgp
= SUBGRP_INST(subgrp
);
1451 piattr
= bgp_path_info_mpath_count(pi
) ? bgp_path_info_mpath_attr(pi
)
1455 if (((afi
== AFI_IP
) || (afi
== AFI_IP6
)) && (safi
== SAFI_MPLS_VPN
)
1456 && ((pi
->type
== ZEBRA_ROUTE_BGP_DIRECT
)
1457 || (pi
->type
== ZEBRA_ROUTE_BGP_DIRECT_EXT
))) {
1460 * direct and direct_ext type routes originate internally even
1461 * though they can have peer pointers that reference other
1464 prefix2str(p
, buf
, PREFIX_STRLEN
);
1465 zlog_debug("%s: pfx %s bgp_direct->vpn route peer safe",
1471 if (((afi
== AFI_IP
) || (afi
== AFI_IP6
))
1472 && ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_UNICAST
))
1473 && (pi
->type
== ZEBRA_ROUTE_BGP
)
1474 && (pi
->sub_type
== BGP_ROUTE_IMPORTED
)) {
1476 /* Applies to routes leaked vpn->vrf and vrf->vpn */
1481 /* With addpath we may be asked to TX all kinds of paths so make sure
1483 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
1484 || CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
)
1485 || CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
1489 /* If this is not the bestpath then check to see if there is an enabled
1491 * feature that requires us to advertise it */
1492 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
1493 if (!bgp_addpath_tx_path(peer
->addpath_type
[afi
][safi
], pi
)) {
1498 /* Aggregate-address suppress check. */
1499 if (pi
->extra
&& pi
->extra
->suppress
)
1500 if (!UNSUPPRESS_MAP_NAME(filter
)) {
1505 * If we are doing VRF 2 VRF leaking via the import
1506 * statement, we want to prevent the route going
1507 * off box as that the RT and RD created are localy
1508 * significant and globaly useless.
1510 if (safi
== SAFI_MPLS_VPN
&& pi
->extra
&& pi
->extra
->num_labels
1511 && pi
->extra
->label
[0] == BGP_PREVENT_VRF_2_VRF_LEAK
)
1514 /* If it's labeled safi, make sure the route has a valid label. */
1515 if (safi
== SAFI_LABELED_UNICAST
) {
1516 mpls_label_t label
= bgp_adv_label(rn
, pi
, peer
, afi
, safi
);
1517 if (!bgp_is_valid_label(&label
)) {
1518 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1519 zlog_debug("u%" PRIu64
":s%" PRIu64
1520 " %s/%d is filtered - no label (%p)",
1521 subgrp
->update_group
->id
, subgrp
->id
,
1522 inet_ntop(p
->family
, &p
->u
.prefix
,
1523 buf
, SU_ADDRSTRLEN
),
1524 p
->prefixlen
, &label
);
1529 /* Do not send back route to sender. */
1530 if (onlypeer
&& from
== onlypeer
) {
1534 /* Do not send the default route in the BGP table if the neighbor is
1535 * configured for default-originate */
1536 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1537 PEER_FLAG_DEFAULT_ORIGINATE
)) {
1538 if (p
->family
== AF_INET
&& p
->u
.prefix4
.s_addr
== INADDR_ANY
)
1540 else if (p
->family
== AF_INET6
&& p
->prefixlen
== 0)
1544 /* Transparency check. */
1545 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_RSERVER_CLIENT
)
1546 && CHECK_FLAG(from
->af_flags
[afi
][safi
], PEER_FLAG_RSERVER_CLIENT
))
1551 /* If community is not disabled check the no-export and local. */
1552 if (!transparent
&& bgp_community_filter(peer
, piattr
)) {
1553 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1555 "subgrpannouncecheck: community filter check fail");
1559 /* If the attribute has originator-id and it is same as remote
1561 if (onlypeer
&& piattr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
)
1562 && (IPV4_ADDR_SAME(&onlypeer
->remote_id
, &piattr
->originator_id
))) {
1563 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1565 "%s [Update:SEND] %s originator-id is same as "
1568 prefix2str(p
, buf
, sizeof(buf
)));
1572 /* ORF prefix-list filter check */
1573 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_ADV
)
1574 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_RCV
)
1575 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1576 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
)))
1577 if (peer
->orf_plist
[afi
][safi
]) {
1578 if (prefix_list_apply(peer
->orf_plist
[afi
][safi
], p
)
1580 if (bgp_debug_update(NULL
, p
,
1581 subgrp
->update_group
, 0))
1583 "%s [Update:SEND] %s is filtered via ORF",
1591 /* Output filter check. */
1592 if (bgp_output_filter(peer
, p
, piattr
, afi
, safi
) == FILTER_DENY
) {
1593 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1594 zlog_debug("%s [Update:SEND] %s is filtered",
1595 peer
->host
, prefix2str(p
, buf
, sizeof(buf
)));
1599 #ifdef BGP_SEND_ASPATH_CHECK
1600 /* AS path loop check. */
1601 if (onlypeer
&& aspath_loop_check(piattr
->aspath
, onlypeer
->as
)) {
1602 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1604 "%s [Update:SEND] suppress announcement to peer AS %u "
1605 "that is part of AS path.",
1606 onlypeer
->host
, onlypeer
->as
);
1609 #endif /* BGP_SEND_ASPATH_CHECK */
1611 /* If we're a CONFED we need to loop check the CONFED ID too */
1612 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
1613 if (aspath_loop_check(piattr
->aspath
, bgp
->confed_id
)) {
1614 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1616 "%s [Update:SEND] suppress announcement to peer AS %u"
1618 peer
->host
, bgp
->confed_id
);
1623 /* Route-Reflect check. */
1624 if (from
->sort
== BGP_PEER_IBGP
&& peer
->sort
== BGP_PEER_IBGP
)
1629 /* IBGP reflection check. */
1630 if (reflect
&& !samepeer_safe
) {
1631 /* A route from a Client peer. */
1632 if (CHECK_FLAG(from
->af_flags
[afi
][safi
],
1633 PEER_FLAG_REFLECTOR_CLIENT
)) {
1634 /* Reflect to all the Non-Client peers and also to the
1635 Client peers other than the originator. Originator
1637 is already done. So there is noting to do. */
1638 /* no bgp client-to-client reflection check. */
1639 if (bgp_flag_check(bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
1640 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1641 PEER_FLAG_REFLECTOR_CLIENT
))
1644 /* A route from a Non-client peer. Reflect to all other
1646 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1647 PEER_FLAG_REFLECTOR_CLIENT
))
1652 /* For modify attribute, copy it to temporary structure. */
1653 bgp_attr_dup(attr
, piattr
);
1655 /* If local-preference is not set. */
1656 if ((peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
)
1657 && (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)))) {
1658 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1659 attr
->local_pref
= bgp
->default_local_pref
;
1662 /* If originator-id is not set and the route is to be reflected,
1663 set the originator id */
1665 && (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
)))) {
1666 IPV4_ADDR_COPY(&(attr
->originator_id
), &(from
->remote_id
));
1667 SET_FLAG(attr
->flag
, BGP_ATTR_ORIGINATOR_ID
);
1670 /* Remove MED if its an EBGP peer - will get overwritten by route-maps
1672 if (peer
->sort
== BGP_PEER_EBGP
1673 && attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)) {
1674 if (from
!= bgp
->peer_self
&& !transparent
1675 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1676 PEER_FLAG_MED_UNCHANGED
))
1678 ~(ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
));
1681 /* Since the nexthop attribute can vary per peer, it is not explicitly
1683 * in announce check, only certain flags and length (or number of
1685 * -- for IPv6/MP_REACH) are set here in order to guide the update
1687 * code in setting the nexthop(s) on a per peer basis in
1689 * Typically, the source nexthop in the attribute is preserved but in
1691 * scenarios where we know it will always be overwritten, we reset the
1692 * nexthop to "0" in an attempt to achieve better Update packing. An
1693 * example of this is when a prefix from each of 2 IBGP peers needs to
1695 * announced to an EBGP peer (and they have the same attributes barring
1699 SET_FLAG(attr
->rmap_change_flags
, BATTR_REFLECTED
);
1701 #define NEXTHOP_IS_V6 \
1702 ((safi != SAFI_ENCAP && safi != SAFI_MPLS_VPN \
1703 && (p->family == AF_INET6 || peer_cap_enhe(peer, afi, safi))) \
1704 || ((safi == SAFI_ENCAP || safi == SAFI_MPLS_VPN) \
1705 && attr->mp_nexthop_len >= IPV6_MAX_BYTELEN))
1707 /* IPv6/MP starts with 1 nexthop. The link-local address is passed only
1709 * the peer (group) is configured to receive link-local nexthop
1711 * and it is available in the prefix OR we're not reflecting the route
1713 * the peer (group) to whom we're going to announce is on a shared
1715 * and this is either a self-originated route or the peer is EBGP.
1717 if (NEXTHOP_IS_V6
) {
1718 attr
->mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
1719 if ((CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1720 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
)
1721 && IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_local
))
1722 || (!reflect
&& peer
->shared_network
1723 && (from
== bgp
->peer_self
1724 || peer
->sort
== BGP_PEER_EBGP
))) {
1725 attr
->mp_nexthop_len
=
1726 BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
;
1729 /* Clear off link-local nexthop in source, whenever it is not
1731 * ensure more prefixes share the same attribute for
1734 if (!(CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1735 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
)))
1736 memset(&attr
->mp_nexthop_local
, 0, IPV6_MAX_BYTELEN
);
1739 bgp_peer_remove_private_as(bgp
, afi
, safi
, peer
, attr
);
1740 bgp_peer_as_override(bgp
, afi
, safi
, peer
, attr
);
1742 /* Route map & unsuppress-map apply. */
1743 if (ROUTE_MAP_OUT_NAME(filter
) || (pi
->extra
&& pi
->extra
->suppress
)) {
1744 struct bgp_path_info rmap_path
;
1745 struct bgp_path_info_extra dummy_rmap_path_extra
;
1746 struct attr dummy_attr
;
1748 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
1749 rmap_path
.peer
= peer
;
1750 rmap_path
.attr
= attr
;
1753 memcpy(&dummy_rmap_path_extra
, pi
->extra
,
1754 sizeof(struct bgp_path_info_extra
));
1755 rmap_path
.extra
= &dummy_rmap_path_extra
;
1758 /* don't confuse inbound and outbound setting */
1759 RESET_FLAG(attr
->rmap_change_flags
);
1762 * The route reflector is not allowed to modify the attributes
1763 * of the reflected IBGP routes unless explicitly allowed.
1765 if ((from
->sort
== BGP_PEER_IBGP
&& peer
->sort
== BGP_PEER_IBGP
)
1766 && !bgp_flag_check(bgp
,
1767 BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
1768 bgp_attr_dup(&dummy_attr
, attr
);
1769 rmap_path
.attr
= &dummy_attr
;
1772 SET_FLAG(peer
->rmap_type
, PEER_RMAP_TYPE_OUT
);
1774 if (pi
->extra
&& pi
->extra
->suppress
)
1775 ret
= route_map_apply(UNSUPPRESS_MAP(filter
), p
,
1776 RMAP_BGP
, &rmap_path
);
1778 ret
= route_map_apply(ROUTE_MAP_OUT(filter
), p
,
1779 RMAP_BGP
, &rmap_path
);
1781 peer
->rmap_type
= 0;
1783 if (ret
== RMAP_DENYMATCH
) {
1784 bgp_attr_flush(attr
);
1789 /* RFC 8212 to prevent route leaks.
1790 * This specification intends to improve this situation by requiring the
1791 * explicit configuration of both BGP Import and Export Policies for any
1792 * External BGP (EBGP) session such as customers, peers, or
1793 * confederation boundaries for all enabled address families. Through
1794 * codification of the aforementioned requirement, operators will
1795 * benefit from consistent behavior across different BGP
1798 if (peer
->bgp
->ebgp_requires_policy
1799 == DEFAULT_EBGP_POLICY_ENABLED
)
1800 if (!bgp_outbound_policy_exists(peer
, filter
))
1803 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
)) {
1804 if (peer
->sort
== BGP_PEER_IBGP
1805 || peer
->sort
== BGP_PEER_CONFED
) {
1806 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1807 attr
->local_pref
= BGP_GSHUT_LOCAL_PREF
;
1809 bgp_attr_add_gshut_community(attr
);
1813 /* After route-map has been applied, we check to see if the nexthop to
1814 * be carried in the attribute (that is used for the announcement) can
1815 * be cleared off or not. We do this in all cases where we would be
1816 * setting the nexthop to "ourselves". For IPv6, we only need to
1818 * the global nexthop here; the link-local nexthop would have been
1820 * already, and if not, it is required by the update formation code.
1821 * Also see earlier comments in this function.
1824 * If route-map has performed some operation on the nexthop or the peer
1825 * configuration says to pass it unchanged, we cannot reset the nexthop
1826 * here, so only attempt to do it if these aren't true. Note that the
1827 * route-map handler itself might have cleared the nexthop, if for
1829 * it is configured as 'peer-address'.
1831 if (!bgp_rmap_nhop_changed(attr
->rmap_change_flags
,
1832 piattr
->rmap_change_flags
)
1834 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1835 PEER_FLAG_NEXTHOP_UNCHANGED
)) {
1836 /* We can reset the nexthop, if setting (or forcing) it to
1838 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1839 PEER_FLAG_NEXTHOP_SELF
)
1840 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1841 PEER_FLAG_FORCE_NEXTHOP_SELF
)) {
1843 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1844 PEER_FLAG_FORCE_NEXTHOP_SELF
))
1845 subgroup_announce_reset_nhop(
1846 (peer_cap_enhe(peer
, afi
, safi
)
1850 } else if (peer
->sort
== BGP_PEER_EBGP
) {
1851 /* Can also reset the nexthop if announcing to EBGP, but
1853 * no peer in the subgroup is on a shared subnet.
1854 * Note: 3rd party nexthop currently implemented for
1857 if (!bgp_subgrp_multiaccess_check_v4(piattr
->nexthop
,
1859 subgroup_announce_reset_nhop(
1860 (peer_cap_enhe(peer
, afi
, safi
)
1864 } else if (CHECK_FLAG(pi
->flags
, BGP_PATH_ANNC_NH_SELF
)) {
1866 * This flag is used for leaked vpn-vrf routes
1868 int family
= p
->family
;
1870 if (peer_cap_enhe(peer
, afi
, safi
))
1873 if (bgp_debug_update(NULL
, p
, subgrp
->update_group
, 0))
1875 "%s: BGP_PATH_ANNC_NH_SELF, family=%s",
1876 __func__
, family2str(family
));
1877 subgroup_announce_reset_nhop(family
, attr
);
1880 /* If IPv6/MP and nexthop does not have any override and happens
1882 * be a link-local address, reset it so that we don't pass along
1884 * source's link-local IPv6 address to recipients who may not be
1886 * the same interface.
1888 if (p
->family
== AF_INET6
|| peer_cap_enhe(peer
, afi
, safi
)) {
1889 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
))
1890 subgroup_announce_reset_nhop(AF_INET6
, attr
);
1897 void bgp_best_selection(struct bgp
*bgp
, struct bgp_node
*rn
,
1898 struct bgp_maxpaths_cfg
*mpath_cfg
,
1899 struct bgp_path_info_pair
*result
, afi_t afi
,
1902 struct bgp_path_info
*new_select
;
1903 struct bgp_path_info
*old_select
;
1904 struct bgp_path_info
*pi
;
1905 struct bgp_path_info
*pi1
;
1906 struct bgp_path_info
*pi2
;
1907 struct bgp_path_info
*nextpi
= NULL
;
1908 int paths_eq
, do_mpath
, debug
;
1909 struct list mp_list
;
1910 char pfx_buf
[PREFIX2STR_BUFFER
];
1911 char path_buf
[PATH_ADDPATH_STR_BUFFER
];
1913 bgp_mp_list_init(&mp_list
);
1915 (mpath_cfg
->maxpaths_ebgp
> 1 || mpath_cfg
->maxpaths_ibgp
> 1);
1917 debug
= bgp_debug_bestpath(&rn
->p
);
1920 prefix2str(&rn
->p
, pfx_buf
, sizeof(pfx_buf
));
1922 /* bgp deterministic-med */
1924 if (bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)) {
1926 /* Clear BGP_PATH_DMED_SELECTED for all paths */
1927 for (pi1
= bgp_node_get_bgp_path_info(rn
); pi1
;
1929 bgp_path_info_unset_flag(rn
, pi1
,
1930 BGP_PATH_DMED_SELECTED
);
1932 for (pi1
= bgp_node_get_bgp_path_info(rn
); pi1
;
1934 if (CHECK_FLAG(pi1
->flags
, BGP_PATH_DMED_CHECK
))
1936 if (BGP_PATH_HOLDDOWN(pi1
))
1938 if (pi1
->peer
!= bgp
->peer_self
)
1939 if (pi1
->peer
->status
!= Established
)
1944 for (pi2
= pi1
->next
; pi2
; pi2
= pi2
->next
) {
1945 if (CHECK_FLAG(pi2
->flags
,
1946 BGP_PATH_DMED_CHECK
))
1948 if (BGP_PATH_HOLDDOWN(pi2
))
1950 if (pi2
->peer
!= bgp
->peer_self
1953 PEER_STATUS_NSF_WAIT
))
1954 if (pi2
->peer
->status
1958 if (!aspath_cmp_left(pi1
->attr
->aspath
,
1960 && !aspath_cmp_left_confed(
1965 if (bgp_path_info_cmp(
1966 bgp
, pi2
, new_select
,
1967 &paths_eq
, mpath_cfg
, debug
,
1968 pfx_buf
, afi
, safi
)) {
1969 bgp_path_info_unset_flag(
1971 BGP_PATH_DMED_SELECTED
);
1975 bgp_path_info_set_flag(
1976 rn
, pi2
, BGP_PATH_DMED_CHECK
);
1979 bgp_path_info_set_flag(rn
, new_select
,
1980 BGP_PATH_DMED_CHECK
);
1981 bgp_path_info_set_flag(rn
, new_select
,
1982 BGP_PATH_DMED_SELECTED
);
1985 bgp_path_info_path_with_addpath_rx_str(
1986 new_select
, path_buf
);
1987 zlog_debug("%s: %s is the bestpath from AS %u",
1989 aspath_get_first_as(
1990 new_select
->attr
->aspath
));
1995 /* Check old selected route and new selected route. */
1998 for (pi
= bgp_node_get_bgp_path_info(rn
);
1999 (pi
!= NULL
) && (nextpi
= pi
->next
, 1); pi
= nextpi
) {
2000 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
))
2003 if (BGP_PATH_HOLDDOWN(pi
)) {
2004 /* reap REMOVED routes, if needs be
2005 * selected route must stay for a while longer though
2007 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)
2008 && (pi
!= old_select
))
2009 bgp_path_info_reap(rn
, pi
);
2012 zlog_debug("%s: pi %p in holddown", __func__
,
2018 if (pi
->peer
&& pi
->peer
!= bgp
->peer_self
2019 && !CHECK_FLAG(pi
->peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2020 if (pi
->peer
->status
!= Established
) {
2024 "%s: pi %p non self peer %s not estab state",
2025 __func__
, pi
, pi
->peer
->host
);
2030 if (bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)
2031 && (!CHECK_FLAG(pi
->flags
, BGP_PATH_DMED_SELECTED
))) {
2032 bgp_path_info_unset_flag(rn
, pi
, BGP_PATH_DMED_CHECK
);
2034 zlog_debug("%s: pi %p dmed", __func__
, pi
);
2038 bgp_path_info_unset_flag(rn
, pi
, BGP_PATH_DMED_CHECK
);
2040 if (bgp_path_info_cmp(bgp
, pi
, new_select
, &paths_eq
, mpath_cfg
,
2041 debug
, pfx_buf
, afi
, safi
)) {
2046 /* Now that we know which path is the bestpath see if any of the other
2048 * qualify as multipaths
2052 bgp_path_info_path_with_addpath_rx_str(new_select
,
2055 sprintf(path_buf
, "NONE");
2057 "%s: After path selection, newbest is %s oldbest was %s",
2059 old_select
? old_select
->peer
->host
: "NONE");
2062 if (do_mpath
&& new_select
) {
2063 for (pi
= bgp_node_get_bgp_path_info(rn
);
2064 (pi
!= NULL
) && (nextpi
= pi
->next
, 1); pi
= nextpi
) {
2067 bgp_path_info_path_with_addpath_rx_str(
2070 if (pi
== new_select
) {
2073 "%s: %s is the bestpath, add to the multipath list",
2075 bgp_mp_list_add(&mp_list
, pi
);
2079 if (BGP_PATH_HOLDDOWN(pi
))
2082 if (pi
->peer
&& pi
->peer
!= bgp
->peer_self
2083 && !CHECK_FLAG(pi
->peer
->sflags
,
2084 PEER_STATUS_NSF_WAIT
))
2085 if (pi
->peer
->status
!= Established
)
2088 if (!bgp_path_info_nexthop_cmp(pi
, new_select
)) {
2091 "%s: %s has the same nexthop as the bestpath, skip it",
2096 bgp_path_info_cmp(bgp
, pi
, new_select
, &paths_eq
,
2097 mpath_cfg
, debug
, pfx_buf
, afi
, safi
);
2102 "%s: %s is equivalent to the bestpath, add to the multipath list",
2104 bgp_mp_list_add(&mp_list
, pi
);
2109 bgp_path_info_mpath_update(rn
, new_select
, old_select
, &mp_list
,
2111 bgp_path_info_mpath_aggregate_update(new_select
, old_select
);
2112 bgp_mp_list_clear(&mp_list
);
2114 bgp_addpath_update_ids(bgp
, rn
, afi
, safi
);
2116 result
->old
= old_select
;
2117 result
->new = new_select
;
2123 * A new route/change in bestpath of an existing route. Evaluate the path
2124 * for advertisement to the subgroup.
2126 int subgroup_process_announce_selected(struct update_subgroup
*subgrp
,
2127 struct bgp_path_info
*selected
,
2128 struct bgp_node
*rn
,
2129 uint32_t addpath_tx_id
)
2132 struct peer
*onlypeer
;
2138 afi
= SUBGRP_AFI(subgrp
);
2139 safi
= SUBGRP_SAFI(subgrp
);
2140 onlypeer
= ((SUBGRP_PCOUNT(subgrp
) == 1) ? (SUBGRP_PFIRST(subgrp
))->peer
2143 if (BGP_DEBUG(update
, UPDATE_OUT
)) {
2144 char buf_prefix
[PREFIX_STRLEN
];
2145 prefix2str(p
, buf_prefix
, sizeof(buf_prefix
));
2146 zlog_debug("%s: p=%s, selected=%p", __func__
, buf_prefix
,
2150 /* First update is deferred until ORF or ROUTE-REFRESH is received */
2151 if (onlypeer
&& CHECK_FLAG(onlypeer
->af_sflags
[afi
][safi
],
2152 PEER_STATUS_ORF_WAIT_REFRESH
))
2155 memset(&attr
, 0, sizeof(struct attr
));
2156 /* It's initialized in bgp_announce_check() */
2158 /* Announcement to the subgroup. If the route is filtered withdraw it.
2161 if (subgroup_announce_check(rn
, selected
, subgrp
, p
, &attr
))
2162 bgp_adj_out_set_subgroup(rn
, subgrp
, &attr
, selected
);
2164 bgp_adj_out_unset_subgroup(rn
, subgrp
, 1,
2168 /* If selected is NULL we must withdraw the path using addpath_tx_id */
2170 bgp_adj_out_unset_subgroup(rn
, subgrp
, 1, addpath_tx_id
);
2177 * Clear IGP changed flag and attribute changed flag for a route (all paths).
2178 * This is called at the end of route processing.
2180 void bgp_zebra_clear_route_change_flags(struct bgp_node
*rn
)
2182 struct bgp_path_info
*pi
;
2184 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
2185 if (BGP_PATH_HOLDDOWN(pi
))
2187 UNSET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2188 UNSET_FLAG(pi
->flags
, BGP_PATH_ATTR_CHANGED
);
2193 * Has the route changed from the RIB's perspective? This is invoked only
2194 * if the route selection returns the same best route as earlier - to
2195 * determine if we need to update zebra or not.
2197 int bgp_zebra_has_route_changed(struct bgp_node
*rn
,
2198 struct bgp_path_info
*selected
)
2200 struct bgp_path_info
*mpinfo
;
2202 /* If this is multipath, check all selected paths for any nexthop
2203 * change or attribute change. Some attribute changes (e.g., community)
2204 * aren't of relevance to the RIB, but we'll update zebra to ensure
2205 * we handle the case of BGP nexthop change. This is the behavior
2206 * when the best path has an attribute change anyway.
2208 if (CHECK_FLAG(selected
->flags
, BGP_PATH_IGP_CHANGED
)
2209 || CHECK_FLAG(selected
->flags
, BGP_PATH_MULTIPATH_CHG
))
2213 * If this is multipath, check all selected paths for any nexthop change
2215 for (mpinfo
= bgp_path_info_mpath_first(selected
); mpinfo
;
2216 mpinfo
= bgp_path_info_mpath_next(mpinfo
)) {
2217 if (CHECK_FLAG(mpinfo
->flags
, BGP_PATH_IGP_CHANGED
)
2218 || CHECK_FLAG(mpinfo
->flags
, BGP_PATH_ATTR_CHANGED
))
2222 /* Nothing has changed from the RIB's perspective. */
2226 struct bgp_process_queue
{
2228 STAILQ_HEAD(, bgp_node
) pqueue
;
2229 #define BGP_PROCESS_QUEUE_EOIU_MARKER (1 << 0)
2231 unsigned int queued
;
2235 * old_select = The old best path
2236 * new_select = the new best path
2238 * if (!old_select && new_select)
2239 * We are sending new information on.
2241 * if (old_select && new_select) {
2242 * if (new_select != old_select)
2243 * We have a new best path send a change
2245 * We've received a update with new attributes that needs
2249 * if (old_select && !new_select)
2250 * We have no eligible route that we can announce or the rn
2253 static void bgp_process_main_one(struct bgp
*bgp
, struct bgp_node
*rn
,
2254 afi_t afi
, safi_t safi
)
2256 struct bgp_path_info
*new_select
;
2257 struct bgp_path_info
*old_select
;
2258 struct bgp_path_info_pair old_and_new
;
2259 char pfx_buf
[PREFIX2STR_BUFFER
];
2262 /* Is it end of initial update? (after startup) */
2264 quagga_timestamp(3, bgp
->update_delay_zebra_resume_time
,
2265 sizeof(bgp
->update_delay_zebra_resume_time
));
2267 bgp
->main_zebra_update_hold
= 0;
2268 FOREACH_AFI_SAFI (afi
, safi
) {
2269 if (bgp_fibupd_safi(safi
))
2270 bgp_zebra_announce_table(bgp
, afi
, safi
);
2272 bgp
->main_peers_update_hold
= 0;
2274 bgp_start_routeadv(bgp
);
2278 struct prefix
*p
= &rn
->p
;
2280 debug
= bgp_debug_bestpath(&rn
->p
);
2282 prefix2str(&rn
->p
, pfx_buf
, sizeof(pfx_buf
));
2283 zlog_debug("%s: p=%s afi=%s, safi=%s start", __func__
, pfx_buf
,
2284 afi2str(afi
), safi2str(safi
));
2287 /* Best path selection. */
2288 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
2290 old_select
= old_and_new
.old
;
2291 new_select
= old_and_new
.new;
2293 /* Do we need to allocate or free labels?
2294 * Right now, since we only deal with per-prefix labels, it is not
2295 * necessary to do this upon changes to best path. Exceptions:
2296 * - label index has changed -> recalculate resulting label
2297 * - path_info sub_type changed -> switch to/from implicit-null
2298 * - no valid label (due to removed static label binding) -> get new one
2300 if (bgp
->allocate_mpls_labels
[afi
][safi
]) {
2303 || bgp_label_index_differs(new_select
, old_select
)
2304 || new_select
->sub_type
!= old_select
->sub_type
2305 || !bgp_is_valid_label(&rn
->local_label
)) {
2306 /* Enforced penultimate hop popping:
2307 * implicit-null for local routes, aggregate
2308 * and redistributed routes
2310 if (new_select
->sub_type
== BGP_ROUTE_STATIC
2311 || new_select
->sub_type
2312 == BGP_ROUTE_AGGREGATE
2313 || new_select
->sub_type
2314 == BGP_ROUTE_REDISTRIBUTE
) {
2317 BGP_NODE_REGISTERED_FOR_LABEL
))
2318 bgp_unregister_for_label(rn
);
2319 label_ntop(MPLS_LABEL_IMPLICIT_NULL
, 1,
2321 bgp_set_valid_label(&rn
->local_label
);
2323 bgp_register_for_label(rn
, new_select
);
2325 } else if (CHECK_FLAG(rn
->flags
,
2326 BGP_NODE_REGISTERED_FOR_LABEL
)) {
2327 bgp_unregister_for_label(rn
);
2329 } else if (CHECK_FLAG(rn
->flags
, BGP_NODE_REGISTERED_FOR_LABEL
)) {
2330 bgp_unregister_for_label(rn
);
2334 prefix2str(&rn
->p
, pfx_buf
, sizeof(pfx_buf
));
2336 "%s: p=%s afi=%s, safi=%s, old_select=%p, new_select=%p",
2337 __func__
, pfx_buf
, afi2str(afi
), safi2str(safi
),
2338 old_select
, new_select
);
2341 /* If best route remains the same and this is not due to user-initiated
2342 * clear, see exactly what needs to be done.
2344 if (old_select
&& old_select
== new_select
2345 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
2346 && !CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
2347 && !bgp_addpath_is_addpath_used(&bgp
->tx_addpath
, afi
, safi
)) {
2348 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
2350 vnc_import_bgp_add_route(bgp
, p
, old_select
);
2351 vnc_import_bgp_exterior_add_route(bgp
, p
, old_select
);
2353 if (bgp_fibupd_safi(safi
)
2354 && !bgp_option_check(BGP_OPT_NO_FIB
)) {
2356 if (new_select
->type
== ZEBRA_ROUTE_BGP
2357 && (new_select
->sub_type
== BGP_ROUTE_NORMAL
2358 || new_select
->sub_type
2359 == BGP_ROUTE_IMPORTED
))
2361 bgp_zebra_announce(rn
, p
, old_select
,
2365 UNSET_FLAG(old_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
2366 bgp_zebra_clear_route_change_flags(rn
);
2368 /* If there is a change of interest to peers, reannounce the
2370 if (CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
2371 || CHECK_FLAG(rn
->flags
, BGP_NODE_LABEL_CHANGED
)) {
2372 group_announce_route(bgp
, afi
, safi
, rn
, new_select
);
2374 /* unicast routes must also be annouced to
2375 * labeled-unicast update-groups */
2376 if (safi
== SAFI_UNICAST
)
2377 group_announce_route(bgp
, afi
,
2378 SAFI_LABELED_UNICAST
, rn
,
2381 UNSET_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
);
2382 UNSET_FLAG(rn
->flags
, BGP_NODE_LABEL_CHANGED
);
2385 UNSET_FLAG(rn
->flags
, BGP_NODE_PROCESS_SCHEDULED
);
2389 /* If the user did "clear ip bgp prefix x.x.x.x" this flag will be set
2391 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
2393 /* bestpath has changed; bump version */
2394 if (old_select
|| new_select
) {
2395 bgp_bump_version(rn
);
2397 if (!bgp
->t_rmap_def_originate_eval
) {
2401 update_group_refresh_default_originate_route_map
,
2402 bgp
, RMAP_DEFAULT_ORIGINATE_EVAL_TIMER
,
2403 &bgp
->t_rmap_def_originate_eval
);
2408 bgp_path_info_unset_flag(rn
, old_select
, BGP_PATH_SELECTED
);
2411 zlog_debug("%s: setting SELECTED flag", __func__
);
2412 bgp_path_info_set_flag(rn
, new_select
, BGP_PATH_SELECTED
);
2413 bgp_path_info_unset_flag(rn
, new_select
, BGP_PATH_ATTR_CHANGED
);
2414 UNSET_FLAG(new_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
2418 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && (safi
== SAFI_UNICAST
)) {
2419 if (old_select
!= new_select
) {
2421 vnc_import_bgp_exterior_del_route(bgp
, p
,
2423 vnc_import_bgp_del_route(bgp
, p
, old_select
);
2426 vnc_import_bgp_exterior_add_route(bgp
, p
,
2428 vnc_import_bgp_add_route(bgp
, p
, new_select
);
2434 group_announce_route(bgp
, afi
, safi
, rn
, new_select
);
2436 /* unicast routes must also be annouced to labeled-unicast update-groups
2438 if (safi
== SAFI_UNICAST
)
2439 group_announce_route(bgp
, afi
, SAFI_LABELED_UNICAST
, rn
,
2443 if (bgp_fibupd_safi(safi
) && (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
2444 && !bgp_option_check(BGP_OPT_NO_FIB
)) {
2445 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
2446 && (new_select
->sub_type
== BGP_ROUTE_NORMAL
2447 || new_select
->sub_type
== BGP_ROUTE_AGGREGATE
2448 || new_select
->sub_type
== BGP_ROUTE_IMPORTED
)) {
2450 /* if this is an evpn imported type-5 prefix,
2451 * we need to withdraw the route first to clear
2452 * the nh neigh and the RMAC entry.
2455 is_route_parent_evpn(old_select
))
2456 bgp_zebra_withdraw(p
, old_select
, bgp
, safi
);
2458 bgp_zebra_announce(rn
, p
, new_select
, bgp
, afi
, safi
);
2460 /* Withdraw the route from the kernel. */
2461 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
2462 && (old_select
->sub_type
== BGP_ROUTE_NORMAL
2463 || old_select
->sub_type
== BGP_ROUTE_AGGREGATE
2464 || old_select
->sub_type
== BGP_ROUTE_IMPORTED
))
2466 bgp_zebra_withdraw(p
, old_select
, bgp
, safi
);
2470 /* advertise/withdraw type-5 routes */
2471 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && (safi
== SAFI_UNICAST
)) {
2472 if (advertise_type5_routes(bgp
, afi
) &&
2474 is_route_injectable_into_evpn(new_select
)) {
2476 /* apply the route-map */
2477 if (bgp
->adv_cmd_rmap
[afi
][safi
].map
) {
2480 ret
= route_map_apply(
2481 bgp
->adv_cmd_rmap
[afi
][safi
].map
,
2482 &rn
->p
, RMAP_BGP
, new_select
);
2483 if (ret
== RMAP_MATCH
)
2484 bgp_evpn_advertise_type5_route(
2485 bgp
, &rn
->p
, new_select
->attr
,
2488 bgp_evpn_withdraw_type5_route(
2489 bgp
, &rn
->p
, afi
, safi
);
2491 bgp_evpn_advertise_type5_route(bgp
,
2497 } else if (advertise_type5_routes(bgp
, afi
) &&
2499 is_route_injectable_into_evpn(old_select
))
2500 bgp_evpn_withdraw_type5_route(bgp
, &rn
->p
, afi
, safi
);
2503 /* Clear any route change flags. */
2504 bgp_zebra_clear_route_change_flags(rn
);
2506 /* Reap old select bgp_path_info, if it has been removed */
2507 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_PATH_REMOVED
))
2508 bgp_path_info_reap(rn
, old_select
);
2510 UNSET_FLAG(rn
->flags
, BGP_NODE_PROCESS_SCHEDULED
);
2514 static wq_item_status
bgp_process_wq(struct work_queue
*wq
, void *data
)
2516 struct bgp_process_queue
*pqnode
= data
;
2517 struct bgp
*bgp
= pqnode
->bgp
;
2518 struct bgp_table
*table
;
2519 struct bgp_node
*rn
;
2522 if (CHECK_FLAG(pqnode
->flags
, BGP_PROCESS_QUEUE_EOIU_MARKER
)) {
2523 bgp_process_main_one(bgp
, NULL
, 0, 0);
2524 /* should always have dedicated wq call */
2525 assert(STAILQ_FIRST(&pqnode
->pqueue
) == NULL
);
2529 while (!STAILQ_EMPTY(&pqnode
->pqueue
)) {
2530 rn
= STAILQ_FIRST(&pqnode
->pqueue
);
2531 STAILQ_REMOVE_HEAD(&pqnode
->pqueue
, pq
);
2532 STAILQ_NEXT(rn
, pq
) = NULL
; /* complete unlink */
2533 table
= bgp_node_table(rn
);
2534 /* note, new RNs may be added as part of processing */
2535 bgp_process_main_one(bgp
, rn
, table
->afi
, table
->safi
);
2537 bgp_unlock_node(rn
);
2538 bgp_table_unlock(table
);
2544 static void bgp_processq_del(struct work_queue
*wq
, void *data
)
2546 struct bgp_process_queue
*pqnode
= data
;
2548 bgp_unlock(pqnode
->bgp
);
2550 XFREE(MTYPE_BGP_PROCESS_QUEUE
, pqnode
);
2553 void bgp_process_queue_init(void)
2555 if (!bm
->process_main_queue
)
2556 bm
->process_main_queue
=
2557 work_queue_new(bm
->master
, "process_main_queue");
2559 bm
->process_main_queue
->spec
.workfunc
= &bgp_process_wq
;
2560 bm
->process_main_queue
->spec
.del_item_data
= &bgp_processq_del
;
2561 bm
->process_main_queue
->spec
.max_retries
= 0;
2562 bm
->process_main_queue
->spec
.hold
= 50;
2563 /* Use a higher yield value of 50ms for main queue processing */
2564 bm
->process_main_queue
->spec
.yield
= 50 * 1000L;
2567 static struct bgp_process_queue
*bgp_processq_alloc(struct bgp
*bgp
)
2569 struct bgp_process_queue
*pqnode
;
2571 pqnode
= XCALLOC(MTYPE_BGP_PROCESS_QUEUE
,
2572 sizeof(struct bgp_process_queue
));
2574 /* unlocked in bgp_processq_del */
2575 pqnode
->bgp
= bgp_lock(bgp
);
2576 STAILQ_INIT(&pqnode
->pqueue
);
2581 void bgp_process(struct bgp
*bgp
, struct bgp_node
*rn
, afi_t afi
, safi_t safi
)
2583 #define ARBITRARY_PROCESS_QLEN 10000
2584 struct work_queue
*wq
= bm
->process_main_queue
;
2585 struct bgp_process_queue
*pqnode
;
2586 int pqnode_reuse
= 0;
2588 /* already scheduled for processing? */
2589 if (CHECK_FLAG(rn
->flags
, BGP_NODE_PROCESS_SCHEDULED
))
2595 /* Add route nodes to an existing work queue item until reaching the
2596 limit only if is from the same BGP view and it's not an EOIU marker
2598 if (work_queue_item_count(wq
)) {
2599 struct work_queue_item
*item
= work_queue_last_item(wq
);
2600 pqnode
= item
->data
;
2602 if (CHECK_FLAG(pqnode
->flags
, BGP_PROCESS_QUEUE_EOIU_MARKER
)
2603 || pqnode
->bgp
!= bgp
2604 || pqnode
->queued
>= ARBITRARY_PROCESS_QLEN
)
2605 pqnode
= bgp_processq_alloc(bgp
);
2609 pqnode
= bgp_processq_alloc(bgp
);
2610 /* all unlocked in bgp_process_wq */
2611 bgp_table_lock(bgp_node_table(rn
));
2613 SET_FLAG(rn
->flags
, BGP_NODE_PROCESS_SCHEDULED
);
2616 /* can't be enqueued twice */
2617 assert(STAILQ_NEXT(rn
, pq
) == NULL
);
2618 STAILQ_INSERT_TAIL(&pqnode
->pqueue
, rn
, pq
);
2622 work_queue_add(wq
, pqnode
);
2627 void bgp_add_eoiu_mark(struct bgp
*bgp
)
2629 struct bgp_process_queue
*pqnode
;
2631 if (bm
->process_main_queue
== NULL
)
2634 pqnode
= bgp_processq_alloc(bgp
);
2636 SET_FLAG(pqnode
->flags
, BGP_PROCESS_QUEUE_EOIU_MARKER
);
2637 work_queue_add(bm
->process_main_queue
, pqnode
);
2640 static int bgp_maximum_prefix_restart_timer(struct thread
*thread
)
2644 peer
= THREAD_ARG(thread
);
2645 peer
->t_pmax_restart
= NULL
;
2647 if (bgp_debug_neighbor_events(peer
))
2649 "%s Maximum-prefix restart timer expired, restore peering",
2652 if ((peer_clear(peer
, NULL
) < 0) && bgp_debug_neighbor_events(peer
))
2653 zlog_debug("%s: %s peer_clear failed",
2654 __PRETTY_FUNCTION__
, peer
->host
);
2659 int bgp_maximum_prefix_overflow(struct peer
*peer
, afi_t afi
, safi_t safi
,
2663 iana_safi_t pkt_safi
;
2665 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
2668 if (peer
->pcount
[afi
][safi
] > peer
->pmax
[afi
][safi
]) {
2669 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
2670 PEER_STATUS_PREFIX_LIMIT
)
2675 "%%MAXPFXEXCEED: No. of %s prefix received from %s %ld exceed, "
2677 afi_safi_print(afi
, safi
), peer
->host
,
2678 peer
->pcount
[afi
][safi
], peer
->pmax
[afi
][safi
]);
2679 SET_FLAG(peer
->af_sflags
[afi
][safi
], PEER_STATUS_PREFIX_LIMIT
);
2681 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
2682 PEER_FLAG_MAX_PREFIX_WARNING
))
2685 /* Convert AFI, SAFI to values for packet. */
2686 pkt_afi
= afi_int2iana(afi
);
2687 pkt_safi
= safi_int2iana(safi
);
2691 ndata
[0] = (pkt_afi
>> 8);
2693 ndata
[2] = pkt_safi
;
2694 ndata
[3] = (peer
->pmax
[afi
][safi
] >> 24);
2695 ndata
[4] = (peer
->pmax
[afi
][safi
] >> 16);
2696 ndata
[5] = (peer
->pmax
[afi
][safi
] >> 8);
2697 ndata
[6] = (peer
->pmax
[afi
][safi
]);
2699 SET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
2700 bgp_notify_send_with_data(peer
, BGP_NOTIFY_CEASE
,
2701 BGP_NOTIFY_CEASE_MAX_PREFIX
,
2705 /* Dynamic peers will just close their connection. */
2706 if (peer_dynamic_neighbor(peer
))
2709 /* restart timer start */
2710 if (peer
->pmax_restart
[afi
][safi
]) {
2711 peer
->v_pmax_restart
=
2712 peer
->pmax_restart
[afi
][safi
] * 60;
2714 if (bgp_debug_neighbor_events(peer
))
2716 "%s Maximum-prefix restart timer started for %d secs",
2717 peer
->host
, peer
->v_pmax_restart
);
2719 BGP_TIMER_ON(peer
->t_pmax_restart
,
2720 bgp_maximum_prefix_restart_timer
,
2721 peer
->v_pmax_restart
);
2726 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
2727 PEER_STATUS_PREFIX_LIMIT
);
2729 if (peer
->pcount
[afi
][safi
]
2730 > (peer
->pmax
[afi
][safi
] * peer
->pmax_threshold
[afi
][safi
] / 100)) {
2731 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
2732 PEER_STATUS_PREFIX_THRESHOLD
)
2737 "%%MAXPFX: No. of %s prefix received from %s reaches %ld, max %ld",
2738 afi_safi_print(afi
, safi
), peer
->host
,
2739 peer
->pcount
[afi
][safi
], peer
->pmax
[afi
][safi
]);
2740 SET_FLAG(peer
->af_sflags
[afi
][safi
],
2741 PEER_STATUS_PREFIX_THRESHOLD
);
2743 UNSET_FLAG(peer
->af_sflags
[afi
][safi
],
2744 PEER_STATUS_PREFIX_THRESHOLD
);
2748 /* Unconditionally remove the route from the RIB, without taking
2749 * damping into consideration (eg, because the session went down)
2751 void bgp_rib_remove(struct bgp_node
*rn
, struct bgp_path_info
*pi
,
2752 struct peer
*peer
, afi_t afi
, safi_t safi
)
2754 bgp_aggregate_decrement(peer
->bgp
, &rn
->p
, pi
, afi
, safi
);
2756 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
))
2757 bgp_path_info_delete(rn
, pi
); /* keep historical info */
2759 bgp_process(peer
->bgp
, rn
, afi
, safi
);
2762 static void bgp_rib_withdraw(struct bgp_node
*rn
, struct bgp_path_info
*pi
,
2763 struct peer
*peer
, afi_t afi
, safi_t safi
,
2764 struct prefix_rd
*prd
)
2766 /* apply dampening, if result is suppressed, we'll be retaining
2767 * the bgp_path_info in the RIB for historical reference.
2769 if (CHECK_FLAG(peer
->bgp
->af_flags
[afi
][safi
], BGP_CONFIG_DAMPENING
)
2770 && peer
->sort
== BGP_PEER_EBGP
)
2771 if ((bgp_damp_withdraw(pi
, rn
, afi
, safi
, 0))
2772 == BGP_DAMP_SUPPRESSED
) {
2773 bgp_aggregate_decrement(peer
->bgp
, &rn
->p
, pi
, afi
,
2779 if (safi
== SAFI_MPLS_VPN
) {
2780 struct bgp_node
*prn
= NULL
;
2781 struct bgp_table
*table
= NULL
;
2783 prn
= bgp_node_get(peer
->bgp
->rib
[afi
][safi
],
2784 (struct prefix
*)prd
);
2785 if (bgp_node_has_bgp_path_info_data(prn
)) {
2786 table
= bgp_node_get_bgp_table_info(prn
);
2788 vnc_import_bgp_del_vnc_host_route_mode_resolve_nve(
2789 peer
->bgp
, prd
, table
, &rn
->p
, pi
);
2791 bgp_unlock_node(prn
);
2793 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && (safi
== SAFI_UNICAST
)) {
2794 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
2796 vnc_import_bgp_del_route(peer
->bgp
, &rn
->p
, pi
);
2797 vnc_import_bgp_exterior_del_route(peer
->bgp
, &rn
->p
,
2803 /* If this is an EVPN route, process for un-import. */
2804 if (safi
== SAFI_EVPN
)
2805 bgp_evpn_unimport_route(peer
->bgp
, afi
, safi
, &rn
->p
, pi
);
2807 bgp_rib_remove(rn
, pi
, peer
, afi
, safi
);
2810 struct bgp_path_info
*info_make(int type
, int sub_type
, unsigned short instance
,
2811 struct peer
*peer
, struct attr
*attr
,
2812 struct bgp_node
*rn
)
2814 struct bgp_path_info
*new;
2816 /* Make new BGP info. */
2817 new = XCALLOC(MTYPE_BGP_ROUTE
, sizeof(struct bgp_path_info
));
2819 new->instance
= instance
;
2820 new->sub_type
= sub_type
;
2823 new->uptime
= bgp_clock();
2828 static void overlay_index_update(struct attr
*attr
,
2829 struct eth_segment_id
*eth_s_id
,
2830 union gw_addr
*gw_ip
)
2835 if (eth_s_id
== NULL
) {
2836 memset(&(attr
->evpn_overlay
.eth_s_id
), 0,
2837 sizeof(struct eth_segment_id
));
2839 memcpy(&(attr
->evpn_overlay
.eth_s_id
), eth_s_id
,
2840 sizeof(struct eth_segment_id
));
2842 if (gw_ip
== NULL
) {
2843 memset(&(attr
->evpn_overlay
.gw_ip
), 0, sizeof(union gw_addr
));
2845 memcpy(&(attr
->evpn_overlay
.gw_ip
), gw_ip
,
2846 sizeof(union gw_addr
));
2850 static bool overlay_index_equal(afi_t afi
, struct bgp_path_info
*path
,
2851 struct eth_segment_id
*eth_s_id
,
2852 union gw_addr
*gw_ip
)
2854 struct eth_segment_id
*path_eth_s_id
, *path_eth_s_id_remote
;
2855 union gw_addr
*path_gw_ip
, *path_gw_ip_remote
;
2857 struct eth_segment_id esi
;
2861 if (afi
!= AFI_L2VPN
)
2864 memset(&temp
, 0, sizeof(temp
));
2865 path_eth_s_id
= &temp
.esi
;
2866 path_gw_ip
= &temp
.ip
;
2868 if (eth_s_id
== NULL
&& gw_ip
== NULL
)
2871 path_eth_s_id
= &(path
->attr
->evpn_overlay
.eth_s_id
);
2872 path_gw_ip
= &(path
->attr
->evpn_overlay
.gw_ip
);
2875 if (gw_ip
== NULL
) {
2876 memset(&temp
, 0, sizeof(temp
));
2877 path_gw_ip_remote
= &temp
.ip
;
2879 path_gw_ip_remote
= gw_ip
;
2881 if (eth_s_id
== NULL
) {
2882 memset(&temp
, 0, sizeof(temp
));
2883 path_eth_s_id_remote
= &temp
.esi
;
2885 path_eth_s_id_remote
= eth_s_id
;
2887 if (!memcmp(path_gw_ip
, path_gw_ip_remote
, sizeof(union gw_addr
)))
2890 return !memcmp(path_eth_s_id
, path_eth_s_id_remote
,
2891 sizeof(struct eth_segment_id
));
2894 /* Check if received nexthop is valid or not. */
2895 static int bgp_update_martian_nexthop(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
2900 /* Only validated for unicast and multicast currently. */
2901 /* Also valid for EVPN where the nexthop is an IP address. */
2902 if (safi
!= SAFI_UNICAST
&& safi
!= SAFI_MULTICAST
&& safi
!= SAFI_EVPN
)
2905 /* If NEXT_HOP is present, validate it. */
2906 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
)) {
2907 if (attr
->nexthop
.s_addr
== 0
2908 || IPV4_CLASS_DE(ntohl(attr
->nexthop
.s_addr
))
2909 || bgp_nexthop_self(bgp
, attr
->nexthop
))
2913 /* If MP_NEXTHOP is present, validate it. */
2914 /* Note: For IPv6 nexthops, we only validate the global (1st) nexthop;
2915 * there is code in bgp_attr.c to ignore the link-local (2nd) nexthop if
2916 * it is not an IPv6 link-local address.
2918 if (attr
->mp_nexthop_len
) {
2919 switch (attr
->mp_nexthop_len
) {
2920 case BGP_ATTR_NHLEN_IPV4
:
2921 case BGP_ATTR_NHLEN_VPNV4
:
2922 ret
= (attr
->mp_nexthop_global_in
.s_addr
== 0
2923 || IPV4_CLASS_DE(ntohl(
2924 attr
->mp_nexthop_global_in
.s_addr
))
2925 || bgp_nexthop_self(bgp
,
2926 attr
->mp_nexthop_global_in
));
2929 case BGP_ATTR_NHLEN_IPV6_GLOBAL
:
2930 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
:
2931 case BGP_ATTR_NHLEN_VPNV6_GLOBAL
:
2932 ret
= (IN6_IS_ADDR_UNSPECIFIED(&attr
->mp_nexthop_global
)
2933 || IN6_IS_ADDR_LOOPBACK(&attr
->mp_nexthop_global
)
2934 || IN6_IS_ADDR_MULTICAST(
2935 &attr
->mp_nexthop_global
)
2936 || bgp_nexthop_self_ipv6(bgp
,
2937 &attr
->mp_nexthop_global
));
2949 int bgp_update(struct peer
*peer
, struct prefix
*p
, uint32_t addpath_id
,
2950 struct attr
*attr
, afi_t afi
, safi_t safi
, int type
,
2951 int sub_type
, struct prefix_rd
*prd
, mpls_label_t
*label
,
2952 uint32_t num_labels
, int soft_reconfig
,
2953 struct bgp_route_evpn
*evpn
)
2956 int aspath_loop_count
= 0;
2957 struct bgp_node
*rn
;
2959 struct attr new_attr
;
2960 struct attr
*attr_new
;
2961 struct bgp_path_info
*pi
;
2962 struct bgp_path_info
*new;
2963 struct bgp_path_info_extra
*extra
;
2965 char pfx_buf
[BGP_PRD_PATH_STRLEN
];
2967 int do_loop_check
= 1;
2968 int has_valid_label
= 0;
2970 int vnc_implicit_withdraw
= 0;
2974 memset(&new_attr
, 0, sizeof(struct attr
));
2975 new_attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
2976 new_attr
.label
= MPLS_INVALID_LABEL
;
2979 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
, prd
);
2980 /* TODO: Check to see if we can get rid of "is_valid_label" */
2981 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)
2982 has_valid_label
= (num_labels
> 0) ? 1 : 0;
2984 has_valid_label
= bgp_is_valid_label(label
);
2986 /* When peer's soft reconfiguration enabled. Record input packet in
2989 && CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
)
2990 && peer
!= bgp
->peer_self
)
2991 bgp_adj_in_set(rn
, peer
, attr
, addpath_id
);
2993 /* Check previously received route. */
2994 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
2995 if (pi
->peer
== peer
&& pi
->type
== type
2996 && pi
->sub_type
== sub_type
2997 && pi
->addpath_rx_id
== addpath_id
)
3000 /* AS path local-as loop check. */
3001 if (peer
->change_local_as
) {
3002 if (peer
->allowas_in
[afi
][safi
])
3003 aspath_loop_count
= peer
->allowas_in
[afi
][safi
];
3004 else if (!CHECK_FLAG(peer
->flags
,
3005 PEER_FLAG_LOCAL_AS_NO_PREPEND
))
3006 aspath_loop_count
= 1;
3008 if (aspath_loop_check(attr
->aspath
, peer
->change_local_as
)
3009 > aspath_loop_count
) {
3010 reason
= "as-path contains our own AS;";
3015 /* If the peer is configured for "allowas-in origin" and the last ASN in
3017 * as-path is our ASN then we do not need to call aspath_loop_check
3019 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
3020 if (aspath_get_last_as(attr
->aspath
) == bgp
->as
)
3023 /* AS path loop check. */
3024 if (do_loop_check
) {
3025 if (aspath_loop_check(attr
->aspath
, bgp
->as
)
3026 > peer
->allowas_in
[afi
][safi
]
3027 || (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)
3028 && aspath_loop_check(attr
->aspath
, bgp
->confed_id
)
3029 > peer
->allowas_in
[afi
][safi
])) {
3030 reason
= "as-path contains our own AS;";
3035 /* Route reflector originator ID check. */
3036 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
)
3037 && IPV4_ADDR_SAME(&bgp
->router_id
, &attr
->originator_id
)) {
3038 reason
= "originator is us;";
3042 /* Route reflector cluster ID check. */
3043 if (bgp_cluster_filter(peer
, attr
)) {
3044 reason
= "reflected from the same cluster;";
3048 /* Apply incoming filter. */
3049 if (bgp_input_filter(peer
, p
, attr
, afi
, safi
) == FILTER_DENY
) {
3054 bgp_attr_dup(&new_attr
, attr
);
3056 /* Apply incoming route-map.
3057 * NB: new_attr may now contain newly allocated values from route-map
3059 * commands, so we need bgp_attr_flush in the error paths, until we
3061 * the attr (which takes over the memory references) */
3062 if (bgp_input_modifier(peer
, p
, &new_attr
, afi
, safi
, NULL
)
3064 reason
= "route-map;";
3065 bgp_attr_flush(&new_attr
);
3069 if (peer
->sort
== BGP_PEER_EBGP
) {
3071 /* If we receive the graceful-shutdown community from an eBGP
3072 * peer we must lower local-preference */
3073 if (new_attr
.community
3074 && community_include(new_attr
.community
, COMMUNITY_GSHUT
)) {
3075 new_attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
3076 new_attr
.local_pref
= BGP_GSHUT_LOCAL_PREF
;
3078 /* If graceful-shutdown is configured then add the GSHUT
3079 * community to all paths received from eBGP peers */
3080 } else if (bgp_flag_check(peer
->bgp
,
3081 BGP_FLAG_GRACEFUL_SHUTDOWN
)) {
3082 bgp_attr_add_gshut_community(&new_attr
);
3086 /* next hop check. */
3087 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IS_RFAPI_HD
)
3088 && bgp_update_martian_nexthop(bgp
, afi
, safi
, &new_attr
)) {
3089 reason
= "martian or self next-hop;";
3090 bgp_attr_flush(&new_attr
);
3094 if (bgp_mac_entry_exists(p
) || bgp_mac_exist(&attr
->rmac
)) {
3095 reason
= "self mac;";
3099 attr_new
= bgp_attr_intern(&new_attr
);
3101 /* If the update is implicit withdraw. */
3103 pi
->uptime
= bgp_clock();
3104 same_attr
= attrhash_cmp(pi
->attr
, attr_new
);
3106 /* Same attribute comes in. */
3107 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)
3108 && attrhash_cmp(pi
->attr
, attr_new
)
3109 && (!has_valid_label
3110 || memcmp(&(bgp_path_info_extra_get(pi
))->label
, label
,
3111 num_labels
* sizeof(mpls_label_t
))
3113 && (overlay_index_equal(
3114 afi
, pi
, evpn
== NULL
? NULL
: &evpn
->eth_s_id
,
3115 evpn
== NULL
? NULL
: &evpn
->gw_ip
))) {
3116 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
3117 BGP_CONFIG_DAMPENING
)
3118 && peer
->sort
== BGP_PEER_EBGP
3119 && CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
)) {
3120 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3121 bgp_debug_rdpfxpath2str(
3122 afi
, safi
, prd
, p
, label
,
3123 num_labels
, addpath_id
? 1 : 0,
3124 addpath_id
, pfx_buf
,
3126 zlog_debug("%s rcvd %s", peer
->host
,
3130 if (bgp_damp_update(pi
, rn
, afi
, safi
)
3131 != BGP_DAMP_SUPPRESSED
) {
3132 bgp_aggregate_increment(bgp
, p
, pi
, afi
,
3134 bgp_process(bgp
, rn
, afi
, safi
);
3136 } else /* Duplicate - odd */
3138 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3139 if (!peer
->rcvd_attr_printed
) {
3141 "%s rcvd UPDATE w/ attr: %s",
3143 peer
->rcvd_attr_str
);
3144 peer
->rcvd_attr_printed
= 1;
3147 bgp_debug_rdpfxpath2str(
3148 afi
, safi
, prd
, p
, label
,
3149 num_labels
, addpath_id
? 1 : 0,
3150 addpath_id
, pfx_buf
,
3153 "%s rcvd %s...duplicate ignored",
3154 peer
->host
, pfx_buf
);
3157 /* graceful restart STALE flag unset. */
3158 if (CHECK_FLAG(pi
->flags
, BGP_PATH_STALE
)) {
3159 bgp_path_info_unset_flag(
3160 rn
, pi
, BGP_PATH_STALE
);
3161 bgp_process(bgp
, rn
, afi
, safi
);
3165 bgp_unlock_node(rn
);
3166 bgp_attr_unintern(&attr_new
);
3171 /* Withdraw/Announce before we fully processed the withdraw */
3172 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
3173 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3174 bgp_debug_rdpfxpath2str(
3175 afi
, safi
, prd
, p
, label
, num_labels
,
3176 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3179 "%s rcvd %s, flapped quicker than processing",
3180 peer
->host
, pfx_buf
);
3183 bgp_path_info_restore(rn
, pi
);
3186 /* Received Logging. */
3187 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3188 bgp_debug_rdpfxpath2str(afi
, safi
, prd
, p
, label
,
3189 num_labels
, addpath_id
? 1 : 0,
3190 addpath_id
, pfx_buf
,
3192 zlog_debug("%s rcvd %s", peer
->host
, pfx_buf
);
3195 /* graceful restart STALE flag unset. */
3196 if (CHECK_FLAG(pi
->flags
, BGP_PATH_STALE
))
3197 bgp_path_info_unset_flag(rn
, pi
, BGP_PATH_STALE
);
3199 /* The attribute is changed. */
3200 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_ATTR_CHANGED
);
3202 /* implicit withdraw, decrement aggregate and pcount here.
3203 * only if update is accepted, they'll increment below.
3205 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, safi
);
3207 /* Update bgp route dampening information. */
3208 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
], BGP_CONFIG_DAMPENING
)
3209 && peer
->sort
== BGP_PEER_EBGP
) {
3210 /* This is implicit withdraw so we should update
3213 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
))
3214 bgp_damp_withdraw(pi
, rn
, afi
, safi
, 1);
3217 if (safi
== SAFI_MPLS_VPN
) {
3218 struct bgp_node
*prn
= NULL
;
3219 struct bgp_table
*table
= NULL
;
3221 prn
= bgp_node_get(bgp
->rib
[afi
][safi
],
3222 (struct prefix
*)prd
);
3223 if (bgp_node_has_bgp_path_info_data(prn
)) {
3224 table
= bgp_node_get_bgp_table_info(prn
);
3226 vnc_import_bgp_del_vnc_host_route_mode_resolve_nve(
3227 bgp
, prd
, table
, p
, pi
);
3229 bgp_unlock_node(prn
);
3231 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
3232 && (safi
== SAFI_UNICAST
)) {
3233 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
3235 * Implicit withdraw case.
3237 ++vnc_implicit_withdraw
;
3238 vnc_import_bgp_del_route(bgp
, p
, pi
);
3239 vnc_import_bgp_exterior_del_route(bgp
, p
, pi
);
3244 /* Special handling for EVPN update of an existing route. If the
3245 * extended community attribute has changed, we need to
3247 * the route using its existing extended community. It will be
3248 * subsequently processed for import with the new extended
3251 if (safi
== SAFI_EVPN
&& !same_attr
) {
3253 & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
))
3255 & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
))) {
3258 cmp
= ecommunity_cmp(pi
->attr
->ecommunity
,
3259 attr_new
->ecommunity
);
3261 if (bgp_debug_update(peer
, p
, NULL
, 1))
3263 "Change in EXT-COMM, existing %s new %s",
3265 pi
->attr
->ecommunity
),
3267 attr_new
->ecommunity
));
3268 bgp_evpn_unimport_route(bgp
, afi
, safi
,
3274 /* Update to new attribute. */
3275 bgp_attr_unintern(&pi
->attr
);
3276 pi
->attr
= attr_new
;
3278 /* Update MPLS label */
3279 if (has_valid_label
) {
3280 extra
= bgp_path_info_extra_get(pi
);
3281 if (extra
->label
!= label
) {
3282 memcpy(&extra
->label
, label
,
3283 num_labels
* sizeof(mpls_label_t
));
3284 extra
->num_labels
= num_labels
;
3286 if (!(afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
))
3287 bgp_set_valid_label(&extra
->label
[0]);
3291 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
3292 && (safi
== SAFI_UNICAST
)) {
3293 if (vnc_implicit_withdraw
) {
3295 * Add back the route with its new attributes
3297 * The route is still selected, until the route
3299 * queued by bgp_process actually runs. We have
3301 * update to the VNC side immediately to avoid
3303 * configuration changes (e.g., route-map
3305 * trigger re-importation of the entire RIB.
3307 vnc_import_bgp_add_route(bgp
, p
, pi
);
3308 vnc_import_bgp_exterior_add_route(bgp
, p
, pi
);
3312 /* Update Overlay Index */
3313 if (afi
== AFI_L2VPN
) {
3314 overlay_index_update(
3315 pi
->attr
, evpn
== NULL
? NULL
: &evpn
->eth_s_id
,
3316 evpn
== NULL
? NULL
: &evpn
->gw_ip
);
3319 /* Update bgp route dampening information. */
3320 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
], BGP_CONFIG_DAMPENING
)
3321 && peer
->sort
== BGP_PEER_EBGP
) {
3322 /* Now we do normal update dampening. */
3323 ret
= bgp_damp_update(pi
, rn
, afi
, safi
);
3324 if (ret
== BGP_DAMP_SUPPRESSED
) {
3325 bgp_unlock_node(rn
);
3330 /* Nexthop reachability check - for unicast and
3331 * labeled-unicast.. */
3332 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
3333 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
)) {
3334 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== 1
3335 && !CHECK_FLAG(peer
->flags
,
3336 PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3338 bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
3343 struct bgp
*bgp_nexthop
= bgp
;
3345 if (pi
->extra
&& pi
->extra
->bgp_orig
)
3346 bgp_nexthop
= pi
->extra
->bgp_orig
;
3348 if (bgp_find_or_add_nexthop(bgp
, bgp_nexthop
, afi
, pi
,
3350 || CHECK_FLAG(peer
->flags
, PEER_FLAG_IS_RFAPI_HD
))
3351 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_VALID
);
3353 if (BGP_DEBUG(nht
, NHT
)) {
3354 char buf1
[INET6_ADDRSTRLEN
];
3356 (const void *)&attr_new
3358 buf1
, INET6_ADDRSTRLEN
);
3359 zlog_debug("%s(%s): NH unresolved",
3360 __FUNCTION__
, buf1
);
3362 bgp_path_info_unset_flag(rn
, pi
,
3366 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_VALID
);
3369 if (safi
== SAFI_MPLS_VPN
) {
3370 struct bgp_node
*prn
= NULL
;
3371 struct bgp_table
*table
= NULL
;
3373 prn
= bgp_node_get(bgp
->rib
[afi
][safi
],
3374 (struct prefix
*)prd
);
3375 if (bgp_node_has_bgp_path_info_data(prn
)) {
3376 table
= bgp_node_get_bgp_table_info(prn
);
3378 vnc_import_bgp_add_vnc_host_route_mode_resolve_nve(
3379 bgp
, prd
, table
, p
, pi
);
3381 bgp_unlock_node(prn
);
3385 /* If this is an EVPN route and some attribute has changed,
3387 * route for import. If the extended community has changed, we
3389 * have done the un-import earlier and the import would result
3391 * route getting injected into appropriate L2 VNIs. If it is
3393 * some other attribute change, the import will result in
3395 * the attributes for the route in the VNI(s).
3397 if (safi
== SAFI_EVPN
&& !same_attr
)
3398 bgp_evpn_import_route(bgp
, afi
, safi
, p
, pi
);
3400 /* Process change. */
3401 bgp_aggregate_increment(bgp
, p
, pi
, afi
, safi
);
3403 bgp_process(bgp
, rn
, afi
, safi
);
3404 bgp_unlock_node(rn
);
3406 if (SAFI_UNICAST
== safi
3407 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
3408 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3410 vpn_leak_from_vrf_update(bgp_get_default(), bgp
, pi
);
3412 if ((SAFI_MPLS_VPN
== safi
)
3413 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3415 vpn_leak_to_vrf_update(bgp
, pi
);
3419 if (SAFI_MPLS_VPN
== safi
) {
3420 mpls_label_t label_decoded
= decode_label(label
);
3422 rfapiProcessUpdate(peer
, NULL
, p
, prd
, attr
, afi
, safi
,
3423 type
, sub_type
, &label_decoded
);
3425 if (SAFI_ENCAP
== safi
) {
3426 rfapiProcessUpdate(peer
, NULL
, p
, prd
, attr
, afi
, safi
,
3427 type
, sub_type
, NULL
);
3432 } // End of implicit withdraw
3434 /* Received Logging. */
3435 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3436 if (!peer
->rcvd_attr_printed
) {
3437 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
3438 peer
->rcvd_attr_str
);
3439 peer
->rcvd_attr_printed
= 1;
3442 bgp_debug_rdpfxpath2str(afi
, safi
, prd
, p
, label
, num_labels
,
3443 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3445 zlog_debug("%s rcvd %s", peer
->host
, pfx_buf
);
3448 /* Make new BGP info. */
3449 new = info_make(type
, sub_type
, 0, peer
, attr_new
, rn
);
3451 /* Update MPLS label */
3452 if (has_valid_label
) {
3453 extra
= bgp_path_info_extra_get(new);
3454 if (extra
->label
!= label
) {
3455 memcpy(&extra
->label
, label
,
3456 num_labels
* sizeof(mpls_label_t
));
3457 extra
->num_labels
= num_labels
;
3459 if (!(afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
))
3460 bgp_set_valid_label(&extra
->label
[0]);
3463 /* Update Overlay Index */
3464 if (afi
== AFI_L2VPN
) {
3465 overlay_index_update(new->attr
,
3466 evpn
== NULL
? NULL
: &evpn
->eth_s_id
,
3467 evpn
== NULL
? NULL
: &evpn
->gw_ip
);
3469 /* Nexthop reachability check. */
3470 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
3471 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
)) {
3472 if (peer
->sort
== BGP_PEER_EBGP
&& peer
->ttl
== 1
3473 && !CHECK_FLAG(peer
->flags
,
3474 PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3475 && !bgp_flag_check(bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
3480 if (bgp_find_or_add_nexthop(bgp
, bgp
, afi
, new, NULL
, connected
)
3481 || CHECK_FLAG(peer
->flags
, PEER_FLAG_IS_RFAPI_HD
))
3482 bgp_path_info_set_flag(rn
, new, BGP_PATH_VALID
);
3484 if (BGP_DEBUG(nht
, NHT
)) {
3485 char buf1
[INET6_ADDRSTRLEN
];
3487 (const void *)&attr_new
->nexthop
,
3488 buf1
, INET6_ADDRSTRLEN
);
3489 zlog_debug("%s(%s): NH unresolved",
3490 __FUNCTION__
, buf1
);
3492 bgp_path_info_unset_flag(rn
, new, BGP_PATH_VALID
);
3495 bgp_path_info_set_flag(rn
, new, BGP_PATH_VALID
);
3498 new->addpath_rx_id
= addpath_id
;
3500 /* Increment prefix */
3501 bgp_aggregate_increment(bgp
, p
, new, afi
, safi
);
3503 /* Register new BGP information. */
3504 bgp_path_info_add(rn
, new);
3506 /* route_node_get lock */
3507 bgp_unlock_node(rn
);
3510 if (safi
== SAFI_MPLS_VPN
) {
3511 struct bgp_node
*prn
= NULL
;
3512 struct bgp_table
*table
= NULL
;
3514 prn
= bgp_node_get(bgp
->rib
[afi
][safi
], (struct prefix
*)prd
);
3515 if (bgp_node_has_bgp_path_info_data(prn
)) {
3516 table
= bgp_node_get_bgp_table_info(prn
);
3518 vnc_import_bgp_add_vnc_host_route_mode_resolve_nve(
3519 bgp
, prd
, table
, p
, new);
3521 bgp_unlock_node(prn
);
3525 /* If maximum prefix count is configured and current prefix
3527 if (bgp_maximum_prefix_overflow(peer
, afi
, safi
, 0))
3530 /* If this is an EVPN route, process for import. */
3531 if (safi
== SAFI_EVPN
)
3532 bgp_evpn_import_route(bgp
, afi
, safi
, p
, new);
3534 /* Process change. */
3535 bgp_process(bgp
, rn
, afi
, safi
);
3537 if (SAFI_UNICAST
== safi
3538 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
3539 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3540 vpn_leak_from_vrf_update(bgp_get_default(), bgp
, new);
3542 if ((SAFI_MPLS_VPN
== safi
)
3543 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3545 vpn_leak_to_vrf_update(bgp
, new);
3548 if (SAFI_MPLS_VPN
== safi
) {
3549 mpls_label_t label_decoded
= decode_label(label
);
3551 rfapiProcessUpdate(peer
, NULL
, p
, prd
, attr
, afi
, safi
, type
,
3552 sub_type
, &label_decoded
);
3554 if (SAFI_ENCAP
== safi
) {
3555 rfapiProcessUpdate(peer
, NULL
, p
, prd
, attr
, afi
, safi
, type
,
3562 /* This BGP update is filtered. Log the reason then update BGP
3565 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3566 if (!peer
->rcvd_attr_printed
) {
3567 zlog_debug("%s rcvd UPDATE w/ attr: %s", peer
->host
,
3568 peer
->rcvd_attr_str
);
3569 peer
->rcvd_attr_printed
= 1;
3572 bgp_debug_rdpfxpath2str(afi
, safi
, prd
, p
, label
, num_labels
,
3573 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3575 zlog_debug("%s rcvd UPDATE about %s -- DENIED due to: %s",
3576 peer
->host
, pfx_buf
, reason
);
3580 /* If this is an EVPN route, un-import it as it is now filtered.
3582 if (safi
== SAFI_EVPN
)
3583 bgp_evpn_unimport_route(bgp
, afi
, safi
, p
, pi
);
3585 if (SAFI_UNICAST
== safi
3586 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
3587 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3589 vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp
, pi
);
3591 if ((SAFI_MPLS_VPN
== safi
)
3592 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3594 vpn_leak_to_vrf_withdraw(bgp
, pi
);
3597 bgp_rib_remove(rn
, pi
, peer
, afi
, safi
);
3600 bgp_unlock_node(rn
);
3604 * Filtered update is treated as an implicit withdrawal (see
3606 * a few lines above)
3608 if ((SAFI_MPLS_VPN
== safi
) || (SAFI_ENCAP
== safi
)) {
3609 rfapiProcessWithdraw(peer
, NULL
, p
, prd
, NULL
, afi
, safi
, type
,
3617 int bgp_withdraw(struct peer
*peer
, struct prefix
*p
, uint32_t addpath_id
,
3618 struct attr
*attr
, afi_t afi
, safi_t safi
, int type
,
3619 int sub_type
, struct prefix_rd
*prd
, mpls_label_t
*label
,
3620 uint32_t num_labels
, struct bgp_route_evpn
*evpn
)
3623 char pfx_buf
[BGP_PRD_PATH_STRLEN
];
3624 struct bgp_node
*rn
;
3625 struct bgp_path_info
*pi
;
3628 if ((SAFI_MPLS_VPN
== safi
) || (SAFI_ENCAP
== safi
)) {
3629 rfapiProcessWithdraw(peer
, NULL
, p
, prd
, NULL
, afi
, safi
, type
,
3637 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
, prd
);
3639 /* If peer is soft reconfiguration enabled. Record input packet for
3640 * further calculation.
3642 * Cisco IOS 12.4(24)T4 on session establishment sends withdraws for all
3643 * routes that are filtered. This tanks out Quagga RS pretty badly due
3645 * the iteration over all RS clients.
3646 * Since we need to remove the entry from adj_in anyway, do that first
3648 * if there was no entry, we don't need to do anything more.
3650 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
)
3651 && peer
!= bgp
->peer_self
)
3652 if (!bgp_adj_in_unset(rn
, peer
, addpath_id
)) {
3653 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3654 bgp_debug_rdpfxpath2str(
3655 afi
, safi
, prd
, p
, label
, num_labels
,
3656 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3659 "%s withdrawing route %s not in adj-in",
3660 peer
->host
, pfx_buf
);
3662 bgp_unlock_node(rn
);
3666 /* Lookup withdrawn route. */
3667 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
3668 if (pi
->peer
== peer
&& pi
->type
== type
3669 && pi
->sub_type
== sub_type
3670 && pi
->addpath_rx_id
== addpath_id
)
3674 if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3675 bgp_debug_rdpfxpath2str(afi
, safi
, prd
, p
, label
, num_labels
,
3676 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3678 zlog_debug("%s rcvd UPDATE about %s -- withdrawn", peer
->host
,
3682 /* Withdraw specified route from routing table. */
3683 if (pi
&& !CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
)) {
3684 bgp_rib_withdraw(rn
, pi
, peer
, afi
, safi
, prd
);
3685 if (SAFI_UNICAST
== safi
3686 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
3687 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3688 vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp
, pi
);
3690 if ((SAFI_MPLS_VPN
== safi
)
3691 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3693 vpn_leak_to_vrf_withdraw(bgp
, pi
);
3695 } else if (bgp_debug_update(peer
, p
, NULL
, 1)) {
3696 bgp_debug_rdpfxpath2str(afi
, safi
, prd
, p
, label
, num_labels
,
3697 addpath_id
? 1 : 0, addpath_id
, pfx_buf
,
3699 zlog_debug("%s Can't find the route %s", peer
->host
, pfx_buf
);
3702 /* Unlock bgp_node_get() lock. */
3703 bgp_unlock_node(rn
);
3708 void bgp_default_originate(struct peer
*peer
, afi_t afi
, safi_t safi
,
3711 struct update_subgroup
*subgrp
;
3712 subgrp
= peer_subgroup(peer
, afi
, safi
);
3713 subgroup_default_originate(subgrp
, withdraw
);
3718 * bgp_stop_announce_route_timer
3720 void bgp_stop_announce_route_timer(struct peer_af
*paf
)
3722 if (!paf
->t_announce_route
)
3725 THREAD_TIMER_OFF(paf
->t_announce_route
);
3729 * bgp_announce_route_timer_expired
3731 * Callback that is invoked when the route announcement timer for a
3734 static int bgp_announce_route_timer_expired(struct thread
*t
)
3736 struct peer_af
*paf
;
3739 paf
= THREAD_ARG(t
);
3742 if (peer
->status
!= Established
)
3745 if (!peer
->afc_nego
[paf
->afi
][paf
->safi
])
3748 peer_af_announce_route(paf
, 1);
3753 * bgp_announce_route
3755 * *Triggers* announcement of routes of a given AFI/SAFI to a peer.
3757 void bgp_announce_route(struct peer
*peer
, afi_t afi
, safi_t safi
)
3759 struct peer_af
*paf
;
3760 struct update_subgroup
*subgrp
;
3762 paf
= peer_af_find(peer
, afi
, safi
);
3765 subgrp
= PAF_SUBGRP(paf
);
3768 * Ignore if subgroup doesn't exist (implies AF is not negotiated)
3769 * or a refresh has already been triggered.
3771 if (!subgrp
|| paf
->t_announce_route
)
3775 * Start a timer to stagger/delay the announce. This serves
3776 * two purposes - announcement can potentially be combined for
3777 * multiple peers and the announcement doesn't happen in the
3780 thread_add_timer_msec(bm
->master
, bgp_announce_route_timer_expired
, paf
,
3781 (subgrp
->peer_count
== 1)
3782 ? BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS
3783 : BGP_ANNOUNCE_ROUTE_DELAY_MS
,
3784 &paf
->t_announce_route
);
3788 * Announce routes from all AF tables to a peer.
3790 * This should ONLY be called when there is a need to refresh the
3791 * routes to the peer based on a policy change for this peer alone
3792 * or a route refresh request received from the peer.
3793 * The operation will result in splitting the peer from its existing
3794 * subgroups and putting it in new subgroups.
3796 void bgp_announce_route_all(struct peer
*peer
)
3801 FOREACH_AFI_SAFI (afi
, safi
)
3802 bgp_announce_route(peer
, afi
, safi
);
3805 static void bgp_soft_reconfig_table(struct peer
*peer
, afi_t afi
, safi_t safi
,
3806 struct bgp_table
*table
,
3807 struct prefix_rd
*prd
)
3810 struct bgp_node
*rn
;
3811 struct bgp_adj_in
*ain
;
3814 table
= peer
->bgp
->rib
[afi
][safi
];
3816 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
3817 for (ain
= rn
->adj_in
; ain
; ain
= ain
->next
) {
3818 if (ain
->peer
!= peer
)
3821 struct bgp_path_info
*pi
=
3822 bgp_node_get_bgp_path_info(rn
);
3823 uint32_t num_labels
= 0;
3824 mpls_label_t
*label_pnt
= NULL
;
3825 struct bgp_route_evpn evpn
;
3827 if (pi
&& pi
->extra
)
3828 num_labels
= pi
->extra
->num_labels
;
3830 label_pnt
= &pi
->extra
->label
[0];
3832 memcpy(&evpn
, &pi
->attr
->evpn_overlay
,
3835 memset(&evpn
, 0, sizeof(evpn
));
3837 ret
= bgp_update(peer
, &rn
->p
, ain
->addpath_rx_id
,
3838 ain
->attr
, afi
, safi
, ZEBRA_ROUTE_BGP
,
3839 BGP_ROUTE_NORMAL
, prd
, label_pnt
,
3840 num_labels
, 1, &evpn
);
3843 bgp_unlock_node(rn
);
3849 void bgp_soft_reconfig_in(struct peer
*peer
, afi_t afi
, safi_t safi
)
3851 struct bgp_node
*rn
;
3852 struct bgp_table
*table
;
3854 if (peer
->status
!= Established
)
3857 if ((safi
!= SAFI_MPLS_VPN
) && (safi
!= SAFI_ENCAP
)
3858 && (safi
!= SAFI_EVPN
))
3859 bgp_soft_reconfig_table(peer
, afi
, safi
, NULL
, NULL
);
3861 for (rn
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); rn
;
3862 rn
= bgp_route_next(rn
)) {
3863 table
= bgp_node_get_bgp_table_info(rn
);
3864 if (table
!= NULL
) {
3865 struct prefix_rd prd
;
3867 prd
.family
= AF_UNSPEC
;
3869 memcpy(&prd
.val
, rn
->p
.u
.val
, 8);
3871 bgp_soft_reconfig_table(peer
, afi
, safi
, table
,
3878 struct bgp_clear_node_queue
{
3879 struct bgp_node
*rn
;
3882 static wq_item_status
bgp_clear_route_node(struct work_queue
*wq
, void *data
)
3884 struct bgp_clear_node_queue
*cnq
= data
;
3885 struct bgp_node
*rn
= cnq
->rn
;
3886 struct peer
*peer
= wq
->spec
.data
;
3887 struct bgp_path_info
*pi
;
3889 afi_t afi
= bgp_node_table(rn
)->afi
;
3890 safi_t safi
= bgp_node_table(rn
)->safi
;
3895 /* It is possible that we have multiple paths for a prefix from a peer
3896 * if that peer is using AddPath.
3898 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
3899 if (pi
->peer
!= peer
)
3902 /* graceful restart STALE flag set. */
3903 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
)
3904 && peer
->nsf
[afi
][safi
]
3905 && !CHECK_FLAG(pi
->flags
, BGP_PATH_STALE
)
3906 && !CHECK_FLAG(pi
->flags
, BGP_PATH_UNUSEABLE
))
3907 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_STALE
);
3909 /* If this is an EVPN route, process for
3911 if (safi
== SAFI_EVPN
)
3912 bgp_evpn_unimport_route(bgp
, afi
, safi
, &rn
->p
,
3914 /* Handle withdraw for VRF route-leaking and L3VPN */
3915 if (SAFI_UNICAST
== safi
3916 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
||
3917 bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
3918 vpn_leak_from_vrf_withdraw(bgp_get_default(),
3921 if (SAFI_MPLS_VPN
== safi
&&
3922 bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3923 vpn_leak_to_vrf_withdraw(bgp
, pi
);
3926 bgp_rib_remove(rn
, pi
, peer
, afi
, safi
);
3932 static void bgp_clear_node_queue_del(struct work_queue
*wq
, void *data
)
3934 struct bgp_clear_node_queue
*cnq
= data
;
3935 struct bgp_node
*rn
= cnq
->rn
;
3936 struct bgp_table
*table
= bgp_node_table(rn
);
3938 bgp_unlock_node(rn
);
3939 bgp_table_unlock(table
);
3940 XFREE(MTYPE_BGP_CLEAR_NODE_QUEUE
, cnq
);
3943 static void bgp_clear_node_complete(struct work_queue
*wq
)
3945 struct peer
*peer
= wq
->spec
.data
;
3947 /* Tickle FSM to start moving again */
3948 BGP_EVENT_ADD(peer
, Clearing_Completed
);
3950 peer_unlock(peer
); /* bgp_clear_route */
3953 static void bgp_clear_node_queue_init(struct peer
*peer
)
3955 char wname
[sizeof("clear xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx")];
3957 snprintf(wname
, sizeof(wname
), "clear %s", peer
->host
);
3958 #undef CLEAR_QUEUE_NAME_LEN
3960 peer
->clear_node_queue
= work_queue_new(bm
->master
, wname
);
3961 peer
->clear_node_queue
->spec
.hold
= 10;
3962 peer
->clear_node_queue
->spec
.workfunc
= &bgp_clear_route_node
;
3963 peer
->clear_node_queue
->spec
.del_item_data
= &bgp_clear_node_queue_del
;
3964 peer
->clear_node_queue
->spec
.completion_func
= &bgp_clear_node_complete
;
3965 peer
->clear_node_queue
->spec
.max_retries
= 0;
3967 /* we only 'lock' this peer reference when the queue is actually active
3969 peer
->clear_node_queue
->spec
.data
= peer
;
3972 static void bgp_clear_route_table(struct peer
*peer
, afi_t afi
, safi_t safi
,
3973 struct bgp_table
*table
)
3975 struct bgp_node
*rn
;
3976 int force
= bm
->process_main_queue
? 0 : 1;
3979 table
= peer
->bgp
->rib
[afi
][safi
];
3981 /* If still no table => afi/safi isn't configured at all or smth. */
3985 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
3986 struct bgp_path_info
*pi
, *next
;
3987 struct bgp_adj_in
*ain
;
3988 struct bgp_adj_in
*ain_next
;
3990 /* XXX:TODO: This is suboptimal, every non-empty route_node is
3991 * queued for every clearing peer, regardless of whether it is
3992 * relevant to the peer at hand.
3994 * Overview: There are 3 different indices which need to be
3995 * scrubbed, potentially, when a peer is removed:
3997 * 1 peer's routes visible via the RIB (ie accepted routes)
3998 * 2 peer's routes visible by the (optional) peer's adj-in index
3999 * 3 other routes visible by the peer's adj-out index
4001 * 3 there is no hurry in scrubbing, once the struct peer is
4002 * removed from bgp->peer, we could just GC such deleted peer's
4003 * adj-outs at our leisure.
4005 * 1 and 2 must be 'scrubbed' in some way, at least made
4006 * invisible via RIB index before peer session is allowed to be
4007 * brought back up. So one needs to know when such a 'search' is
4012 * - there'd be a single global queue or a single RIB walker
4013 * - rather than tracking which route_nodes still need to be
4014 * examined on a peer basis, we'd track which peers still
4017 * Given that our per-peer prefix-counts now should be reliable,
4018 * this may actually be achievable. It doesn't seem to be a huge
4019 * problem at this time,
4021 * It is possible that we have multiple paths for a prefix from
4023 * if that peer is using AddPath.
4027 ain_next
= ain
->next
;
4029 if (ain
->peer
== peer
) {
4030 bgp_adj_in_remove(rn
, ain
);
4031 bgp_unlock_node(rn
);
4037 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= next
) {
4039 if (pi
->peer
!= peer
)
4043 bgp_path_info_reap(rn
, pi
);
4045 struct bgp_clear_node_queue
*cnq
;
4047 /* both unlocked in bgp_clear_node_queue_del */
4048 bgp_table_lock(bgp_node_table(rn
));
4051 MTYPE_BGP_CLEAR_NODE_QUEUE
,
4052 sizeof(struct bgp_clear_node_queue
));
4054 work_queue_add(peer
->clear_node_queue
, cnq
);
4062 void bgp_clear_route(struct peer
*peer
, afi_t afi
, safi_t safi
)
4064 struct bgp_node
*rn
;
4065 struct bgp_table
*table
;
4067 if (peer
->clear_node_queue
== NULL
)
4068 bgp_clear_node_queue_init(peer
);
4070 /* bgp_fsm.c keeps sessions in state Clearing, not transitioning to
4071 * Idle until it receives a Clearing_Completed event. This protects
4072 * against peers which flap faster than we can we clear, which could
4075 * a) race with routes from the new session being installed before
4076 * clear_route_node visits the node (to delete the route of that
4078 * b) resource exhaustion, clear_route_node likely leads to an entry
4079 * on the process_main queue. Fast-flapping could cause that queue
4083 /* lock peer in assumption that clear-node-queue will get nodes; if so,
4084 * the unlock will happen upon work-queue completion; other wise, the
4085 * unlock happens at the end of this function.
4087 if (!peer
->clear_node_queue
->thread
)
4090 if (safi
!= SAFI_MPLS_VPN
&& safi
!= SAFI_ENCAP
&& safi
!= SAFI_EVPN
)
4091 bgp_clear_route_table(peer
, afi
, safi
, NULL
);
4093 for (rn
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); rn
;
4094 rn
= bgp_route_next(rn
)) {
4095 table
= bgp_node_get_bgp_table_info(rn
);
4099 bgp_clear_route_table(peer
, afi
, safi
, table
);
4102 /* unlock if no nodes got added to the clear-node-queue. */
4103 if (!peer
->clear_node_queue
->thread
)
4107 void bgp_clear_route_all(struct peer
*peer
)
4112 FOREACH_AFI_SAFI (afi
, safi
)
4113 bgp_clear_route(peer
, afi
, safi
);
4116 rfapiProcessPeerDown(peer
);
4120 void bgp_clear_adj_in(struct peer
*peer
, afi_t afi
, safi_t safi
)
4122 struct bgp_table
*table
;
4123 struct bgp_node
*rn
;
4124 struct bgp_adj_in
*ain
;
4125 struct bgp_adj_in
*ain_next
;
4127 table
= peer
->bgp
->rib
[afi
][safi
];
4129 /* It is possible that we have multiple paths for a prefix from a peer
4130 * if that peer is using AddPath.
4132 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4136 ain_next
= ain
->next
;
4138 if (ain
->peer
== peer
) {
4139 bgp_adj_in_remove(rn
, ain
);
4140 bgp_unlock_node(rn
);
4148 void bgp_clear_stale_route(struct peer
*peer
, afi_t afi
, safi_t safi
)
4150 struct bgp_node
*rn
;
4151 struct bgp_path_info
*pi
;
4152 struct bgp_table
*table
;
4154 if (safi
== SAFI_MPLS_VPN
) {
4155 for (rn
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); rn
;
4156 rn
= bgp_route_next(rn
)) {
4157 struct bgp_node
*rm
;
4159 /* look for neighbor in tables */
4160 table
= bgp_node_get_bgp_table_info(rn
);
4164 for (rm
= bgp_table_top(table
); rm
;
4165 rm
= bgp_route_next(rm
))
4166 for (pi
= bgp_node_get_bgp_path_info(rm
); pi
;
4168 if (pi
->peer
!= peer
)
4170 if (!CHECK_FLAG(pi
->flags
,
4174 bgp_rib_remove(rm
, pi
, peer
, afi
, safi
);
4179 for (rn
= bgp_table_top(peer
->bgp
->rib
[afi
][safi
]); rn
;
4180 rn
= bgp_route_next(rn
))
4181 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
;
4183 if (pi
->peer
!= peer
)
4185 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_STALE
))
4187 bgp_rib_remove(rn
, pi
, peer
, afi
, safi
);
4193 int bgp_outbound_policy_exists(struct peer
*peer
, struct bgp_filter
*filter
)
4195 if (peer
->sort
== BGP_PEER_EBGP
4196 && (ROUTE_MAP_OUT_NAME(filter
) || PREFIX_LIST_OUT_NAME(filter
)
4197 || FILTER_LIST_OUT_NAME(filter
)
4198 || DISTRIBUTE_OUT_NAME(filter
)))
4203 int bgp_inbound_policy_exists(struct peer
*peer
, struct bgp_filter
*filter
)
4205 if (peer
->sort
== BGP_PEER_EBGP
4206 && (ROUTE_MAP_IN_NAME(filter
) || PREFIX_LIST_IN_NAME(filter
)
4207 || FILTER_LIST_IN_NAME(filter
)
4208 || DISTRIBUTE_IN_NAME(filter
)))
4213 static void bgp_cleanup_table(struct bgp
*bgp
, struct bgp_table
*table
,
4216 struct bgp_node
*rn
;
4217 struct bgp_path_info
*pi
;
4218 struct bgp_path_info
*next
;
4220 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
4221 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= next
) {
4224 /* Unimport EVPN routes from VRFs */
4225 if (safi
== SAFI_EVPN
)
4226 bgp_evpn_unimport_route(bgp
, AFI_L2VPN
,
4230 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)
4231 && pi
->type
== ZEBRA_ROUTE_BGP
4232 && (pi
->sub_type
== BGP_ROUTE_NORMAL
4233 || pi
->sub_type
== BGP_ROUTE_AGGREGATE
4234 || pi
->sub_type
== BGP_ROUTE_IMPORTED
)) {
4236 if (bgp_fibupd_safi(safi
))
4237 bgp_zebra_withdraw(&rn
->p
, pi
, bgp
,
4239 bgp_path_info_reap(rn
, pi
);
4244 /* Delete all kernel routes. */
4245 void bgp_cleanup_routes(struct bgp
*bgp
)
4248 struct bgp_node
*rn
;
4249 struct bgp_table
*table
;
4251 for (afi
= AFI_IP
; afi
< AFI_MAX
; ++afi
) {
4252 if (afi
== AFI_L2VPN
)
4254 bgp_cleanup_table(bgp
, bgp
->rib
[afi
][SAFI_UNICAST
],
4257 * VPN and ENCAP and EVPN tables are two-level (RD is top level)
4259 if (afi
!= AFI_L2VPN
) {
4261 safi
= SAFI_MPLS_VPN
;
4262 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
4263 rn
= bgp_route_next(rn
)) {
4264 table
= bgp_node_get_bgp_table_info(rn
);
4265 if (table
!= NULL
) {
4266 bgp_cleanup_table(bgp
, table
, safi
);
4267 bgp_table_finish(&table
);
4268 bgp_node_set_bgp_table_info(rn
, NULL
);
4269 bgp_unlock_node(rn
);
4273 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
4274 rn
= bgp_route_next(rn
)) {
4275 table
= bgp_node_get_bgp_table_info(rn
);
4276 if (table
!= NULL
) {
4277 bgp_cleanup_table(bgp
, table
, safi
);
4278 bgp_table_finish(&table
);
4279 bgp_node_set_bgp_table_info(rn
, NULL
);
4280 bgp_unlock_node(rn
);
4285 for (rn
= bgp_table_top(bgp
->rib
[AFI_L2VPN
][SAFI_EVPN
]); rn
;
4286 rn
= bgp_route_next(rn
)) {
4287 table
= bgp_node_get_bgp_table_info(rn
);
4288 if (table
!= NULL
) {
4289 bgp_cleanup_table(bgp
, table
, SAFI_EVPN
);
4290 bgp_table_finish(&table
);
4291 bgp_node_set_bgp_table_info(rn
, NULL
);
4292 bgp_unlock_node(rn
);
4297 void bgp_reset(void)
4300 bgp_zclient_reset();
4301 access_list_reset();
4302 prefix_list_reset();
4305 static int bgp_addpath_encode_rx(struct peer
*peer
, afi_t afi
, safi_t safi
)
4307 return (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
4308 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
4309 PEER_CAP_ADDPATH_AF_TX_RCV
));
4312 /* Parse NLRI stream. Withdraw NLRI is recognized by NULL attr
4314 int bgp_nlri_parse_ip(struct peer
*peer
, struct attr
*attr
,
4315 struct bgp_nlri
*packet
)
4324 int addpath_encoded
;
4325 uint32_t addpath_id
;
4328 lim
= pnt
+ packet
->length
;
4330 safi
= packet
->safi
;
4332 addpath_encoded
= bgp_addpath_encode_rx(peer
, afi
, safi
);
4334 /* RFC4771 6.3 The NLRI field in the UPDATE message is checked for
4335 syntactic validity. If the field is syntactically incorrect,
4336 then the Error Subcode is set to Invalid Network Field. */
4337 for (; pnt
< lim
; pnt
+= psize
) {
4338 /* Clear prefix structure. */
4339 memset(&p
, 0, sizeof(struct prefix
));
4341 if (addpath_encoded
) {
4343 /* When packet overflow occurs return immediately. */
4344 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
4345 return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW
;
4347 addpath_id
= ntohl(*((uint32_t *)pnt
));
4348 pnt
+= BGP_ADDPATH_ID_LEN
;
4351 /* Fetch prefix length. */
4352 p
.prefixlen
= *pnt
++;
4353 /* afi/safi validity already verified by caller,
4354 * bgp_update_receive */
4355 p
.family
= afi2family(afi
);
4357 /* Prefix length check. */
4358 if (p
.prefixlen
> prefix_blen(&p
) * 8) {
4361 "%s [Error] Update packet error (wrong prefix length %d for afi %u)",
4362 peer
->host
, p
.prefixlen
, packet
->afi
);
4363 return BGP_NLRI_PARSE_ERROR_PREFIX_LENGTH
;
4366 /* Packet size overflow check. */
4367 psize
= PSIZE(p
.prefixlen
);
4369 /* When packet overflow occur return immediately. */
4370 if (pnt
+ psize
> lim
) {
4373 "%s [Error] Update packet error (prefix length %d overflows packet)",
4374 peer
->host
, p
.prefixlen
);
4375 return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW
;
4378 /* Defensive coding, double-check the psize fits in a struct
4380 if (psize
> (ssize_t
)sizeof(p
.u
)) {
4383 "%s [Error] Update packet error (prefix length %d too large for prefix storage %zu)",
4384 peer
->host
, p
.prefixlen
, sizeof(p
.u
));
4385 return BGP_NLRI_PARSE_ERROR_PACKET_LENGTH
;
4388 /* Fetch prefix from NLRI packet. */
4389 memcpy(p
.u
.val
, pnt
, psize
);
4391 /* Check address. */
4392 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
) {
4393 if (IN_CLASSD(ntohl(p
.u
.prefix4
.s_addr
))) {
4394 /* From RFC4271 Section 6.3:
4396 * If a prefix in the NLRI field is semantically
4398 * (e.g., an unexpected multicast IP address),
4400 * be logged locally, and the prefix SHOULD be
4405 "%s: IPv4 unicast NLRI is multicast address %s, ignoring",
4406 peer
->host
, inet_ntoa(p
.u
.prefix4
));
4411 /* Check address. */
4412 if (afi
== AFI_IP6
&& safi
== SAFI_UNICAST
) {
4413 if (IN6_IS_ADDR_LINKLOCAL(&p
.u
.prefix6
)) {
4418 "%s: IPv6 unicast NLRI is link-local address %s, ignoring",
4420 inet_ntop(AF_INET6
, &p
.u
.prefix6
, buf
,
4425 if (IN6_IS_ADDR_MULTICAST(&p
.u
.prefix6
)) {
4430 "%s: IPv6 unicast NLRI is multicast address %s, ignoring",
4432 inet_ntop(AF_INET6
, &p
.u
.prefix6
, buf
,
4439 /* Normal process. */
4441 ret
= bgp_update(peer
, &p
, addpath_id
, attr
, afi
, safi
,
4442 ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
4443 NULL
, NULL
, 0, 0, NULL
);
4445 ret
= bgp_withdraw(peer
, &p
, addpath_id
, attr
, afi
,
4446 safi
, ZEBRA_ROUTE_BGP
,
4447 BGP_ROUTE_NORMAL
, NULL
, NULL
, 0,
4450 /* Do not send BGP notification twice when maximum-prefix count
4452 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
4453 return BGP_NLRI_PARSE_ERROR_PREFIX_OVERFLOW
;
4455 /* Address family configuration mismatch. */
4457 return BGP_NLRI_PARSE_ERROR_ADDRESS_FAMILY
;
4460 /* Packet length consistency check. */
4464 "%s [Error] Update packet error (prefix length mismatch with total length)",
4466 return BGP_NLRI_PARSE_ERROR_PACKET_LENGTH
;
4469 return BGP_NLRI_PARSE_OK
;
4472 static struct bgp_static
*bgp_static_new(void)
4474 return XCALLOC(MTYPE_BGP_STATIC
, sizeof(struct bgp_static
));
4477 static void bgp_static_free(struct bgp_static
*bgp_static
)
4479 XFREE(MTYPE_ROUTE_MAP_NAME
, bgp_static
->rmap
.name
);
4480 route_map_counter_decrement(bgp_static
->rmap
.map
);
4482 XFREE(MTYPE_ATTR
, bgp_static
->eth_s_id
);
4483 XFREE(MTYPE_BGP_STATIC
, bgp_static
);
4486 void bgp_static_update(struct bgp
*bgp
, struct prefix
*p
,
4487 struct bgp_static
*bgp_static
, afi_t afi
, safi_t safi
)
4489 struct bgp_node
*rn
;
4490 struct bgp_path_info
*pi
;
4491 struct bgp_path_info
*new;
4492 struct bgp_path_info rmap_path
;
4494 struct attr
*attr_new
;
4497 int vnc_implicit_withdraw
= 0;
4504 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
, NULL
);
4506 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
4508 attr
.nexthop
= bgp_static
->igpnexthop
;
4509 attr
.med
= bgp_static
->igpmetric
;
4510 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
4512 if (bgp_static
->atomic
)
4513 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
4515 /* Store label index, if required. */
4516 if (bgp_static
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
4517 attr
.label_index
= bgp_static
->label_index
;
4518 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
);
4521 /* Apply route-map. */
4522 if (bgp_static
->rmap
.name
) {
4523 struct attr attr_tmp
= attr
;
4525 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
4526 rmap_path
.peer
= bgp
->peer_self
;
4527 rmap_path
.attr
= &attr_tmp
;
4529 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_NETWORK
);
4531 ret
= route_map_apply(bgp_static
->rmap
.map
, p
, RMAP_BGP
,
4534 bgp
->peer_self
->rmap_type
= 0;
4536 if (ret
== RMAP_DENYMATCH
) {
4537 /* Free uninterned attribute. */
4538 bgp_attr_flush(&attr_tmp
);
4540 /* Unintern original. */
4541 aspath_unintern(&attr
.aspath
);
4542 bgp_static_withdraw(bgp
, p
, afi
, safi
);
4546 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
))
4547 bgp_attr_add_gshut_community(&attr_tmp
);
4549 attr_new
= bgp_attr_intern(&attr_tmp
);
4552 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
))
4553 bgp_attr_add_gshut_community(&attr
);
4555 attr_new
= bgp_attr_intern(&attr
);
4558 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
4559 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
4560 && pi
->sub_type
== BGP_ROUTE_STATIC
)
4564 if (attrhash_cmp(pi
->attr
, attr_new
)
4565 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)
4566 && !bgp_flag_check(bgp
, BGP_FLAG_FORCE_STATIC_PROCESS
)) {
4567 bgp_unlock_node(rn
);
4568 bgp_attr_unintern(&attr_new
);
4569 aspath_unintern(&attr
.aspath
);
4572 /* The attribute is changed. */
4573 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_ATTR_CHANGED
);
4575 /* Rewrite BGP route information. */
4576 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
4577 bgp_path_info_restore(rn
, pi
);
4579 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, safi
);
4581 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
4582 && (safi
== SAFI_UNICAST
)) {
4583 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
4585 * Implicit withdraw case.
4586 * We have to do this before pi is
4589 ++vnc_implicit_withdraw
;
4590 vnc_import_bgp_del_route(bgp
, p
, pi
);
4591 vnc_import_bgp_exterior_del_route(
4596 bgp_attr_unintern(&pi
->attr
);
4597 pi
->attr
= attr_new
;
4598 pi
->uptime
= bgp_clock();
4600 if ((afi
== AFI_IP
|| afi
== AFI_IP6
)
4601 && (safi
== SAFI_UNICAST
)) {
4602 if (vnc_implicit_withdraw
) {
4603 vnc_import_bgp_add_route(bgp
, p
, pi
);
4604 vnc_import_bgp_exterior_add_route(
4610 /* Nexthop reachability check. */
4611 if (bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
4612 && (safi
== SAFI_UNICAST
4613 || safi
== SAFI_LABELED_UNICAST
)) {
4615 struct bgp
*bgp_nexthop
= bgp
;
4617 if (pi
->extra
&& pi
->extra
->bgp_orig
)
4618 bgp_nexthop
= pi
->extra
->bgp_orig
;
4620 if (bgp_find_or_add_nexthop(bgp
, bgp_nexthop
,
4622 bgp_path_info_set_flag(rn
, pi
,
4625 if (BGP_DEBUG(nht
, NHT
)) {
4626 char buf1
[INET6_ADDRSTRLEN
];
4627 inet_ntop(p
->family
,
4631 "%s(%s): Route not in table, not advertising",
4632 __FUNCTION__
, buf1
);
4634 bgp_path_info_unset_flag(
4635 rn
, pi
, BGP_PATH_VALID
);
4638 /* Delete the NHT structure if any, if we're
4640 * enabling/disabling import check. We
4641 * deregister the route
4642 * from NHT to avoid overloading NHT and the
4643 * process interaction
4645 bgp_unlink_nexthop(pi
);
4646 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_VALID
);
4648 /* Process change. */
4649 bgp_aggregate_increment(bgp
, p
, pi
, afi
, safi
);
4650 bgp_process(bgp
, rn
, afi
, safi
);
4652 if (SAFI_UNICAST
== safi
4653 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
4655 == BGP_INSTANCE_TYPE_DEFAULT
)) {
4656 vpn_leak_from_vrf_update(bgp_get_default(), bgp
,
4660 bgp_unlock_node(rn
);
4661 aspath_unintern(&attr
.aspath
);
4666 /* Make new BGP info. */
4667 new = info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0, bgp
->peer_self
,
4669 /* Nexthop reachability check. */
4670 if (bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
4671 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
)) {
4672 if (bgp_find_or_add_nexthop(bgp
, bgp
, afi
, new, NULL
, 0))
4673 bgp_path_info_set_flag(rn
, new, BGP_PATH_VALID
);
4675 if (BGP_DEBUG(nht
, NHT
)) {
4676 char buf1
[INET6_ADDRSTRLEN
];
4677 inet_ntop(p
->family
, &p
->u
.prefix
, buf1
,
4680 "%s(%s): Route not in table, not advertising",
4681 __FUNCTION__
, buf1
);
4683 bgp_path_info_unset_flag(rn
, new, BGP_PATH_VALID
);
4686 /* Delete the NHT structure if any, if we're toggling between
4687 * enabling/disabling import check. We deregister the route
4688 * from NHT to avoid overloading NHT and the process interaction
4690 bgp_unlink_nexthop(new);
4692 bgp_path_info_set_flag(rn
, new, BGP_PATH_VALID
);
4695 /* Aggregate address increment. */
4696 bgp_aggregate_increment(bgp
, p
, new, afi
, safi
);
4698 /* Register new BGP information. */
4699 bgp_path_info_add(rn
, new);
4701 /* route_node_get lock */
4702 bgp_unlock_node(rn
);
4704 /* Process change. */
4705 bgp_process(bgp
, rn
, afi
, safi
);
4707 if (SAFI_UNICAST
== safi
4708 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
4709 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
4710 vpn_leak_from_vrf_update(bgp_get_default(), bgp
, new);
4713 /* Unintern original. */
4714 aspath_unintern(&attr
.aspath
);
4717 void bgp_static_withdraw(struct bgp
*bgp
, struct prefix
*p
, afi_t afi
,
4720 struct bgp_node
*rn
;
4721 struct bgp_path_info
*pi
;
4723 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
, NULL
);
4725 /* Check selected route and self inserted route. */
4726 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
4727 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
4728 && pi
->sub_type
== BGP_ROUTE_STATIC
)
4731 /* Withdraw static BGP route from routing table. */
4733 if (SAFI_UNICAST
== safi
4734 && (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
4735 || bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
4736 vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp
, pi
);
4738 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, safi
);
4739 bgp_unlink_nexthop(pi
);
4740 bgp_path_info_delete(rn
, pi
);
4741 bgp_process(bgp
, rn
, afi
, safi
);
4744 /* Unlock bgp_node_lookup. */
4745 bgp_unlock_node(rn
);
4749 * Used for SAFI_MPLS_VPN and SAFI_ENCAP
4751 static void bgp_static_withdraw_safi(struct bgp
*bgp
, struct prefix
*p
,
4752 afi_t afi
, safi_t safi
,
4753 struct prefix_rd
*prd
)
4755 struct bgp_node
*rn
;
4756 struct bgp_path_info
*pi
;
4758 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
, prd
);
4760 /* Check selected route and self inserted route. */
4761 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
4762 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
4763 && pi
->sub_type
== BGP_ROUTE_STATIC
)
4766 /* Withdraw static BGP route from routing table. */
4769 rfapiProcessWithdraw(
4770 pi
->peer
, NULL
, p
, prd
, pi
->attr
, afi
, safi
, pi
->type
,
4771 1); /* Kill, since it is an administrative change */
4773 if (SAFI_MPLS_VPN
== safi
4774 && bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
4775 vpn_leak_to_vrf_withdraw(bgp
, pi
);
4777 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, safi
);
4778 bgp_path_info_delete(rn
, pi
);
4779 bgp_process(bgp
, rn
, afi
, safi
);
4782 /* Unlock bgp_node_lookup. */
4783 bgp_unlock_node(rn
);
4786 static void bgp_static_update_safi(struct bgp
*bgp
, struct prefix
*p
,
4787 struct bgp_static
*bgp_static
, afi_t afi
,
4790 struct bgp_node
*rn
;
4791 struct bgp_path_info
*new;
4792 struct attr
*attr_new
;
4793 struct attr attr
= {0};
4794 struct bgp_path_info
*pi
;
4796 mpls_label_t label
= 0;
4798 uint32_t num_labels
= 0;
4803 if (bgp_static
->label
!= MPLS_INVALID_LABEL
)
4805 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
, p
,
4808 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
4810 attr
.nexthop
= bgp_static
->igpnexthop
;
4811 attr
.med
= bgp_static
->igpmetric
;
4812 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
4814 if ((safi
== SAFI_EVPN
) || (safi
== SAFI_MPLS_VPN
)
4815 || (safi
== SAFI_ENCAP
)) {
4816 if (afi
== AFI_IP
) {
4817 attr
.mp_nexthop_global_in
= bgp_static
->igpnexthop
;
4818 attr
.mp_nexthop_len
= IPV4_MAX_BYTELEN
;
4821 if (afi
== AFI_L2VPN
) {
4822 if (bgp_static
->gatewayIp
.family
== AF_INET
)
4824 bgp_static
->gatewayIp
.u
.prefix4
.s_addr
;
4825 else if (bgp_static
->gatewayIp
.family
== AF_INET6
)
4826 memcpy(&(add
.ipv6
), &(bgp_static
->gatewayIp
.u
.prefix6
),
4827 sizeof(struct in6_addr
));
4828 overlay_index_update(&attr
, bgp_static
->eth_s_id
, &add
);
4829 if (bgp_static
->encap_tunneltype
== BGP_ENCAP_TYPE_VXLAN
) {
4830 struct bgp_encap_type_vxlan bet
;
4831 memset(&bet
, 0, sizeof(struct bgp_encap_type_vxlan
));
4832 bet
.vnid
= p
->u
.prefix_evpn
.prefix_addr
.eth_tag
;
4833 bgp_encap_type_vxlan_to_tlv(&bet
, &attr
);
4835 if (bgp_static
->router_mac
) {
4836 bgp_add_routermac_ecom(&attr
, bgp_static
->router_mac
);
4839 /* Apply route-map. */
4840 if (bgp_static
->rmap
.name
) {
4841 struct attr attr_tmp
= attr
;
4842 struct bgp_path_info rmap_path
;
4845 rmap_path
.peer
= bgp
->peer_self
;
4846 rmap_path
.attr
= &attr_tmp
;
4848 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_NETWORK
);
4850 ret
= route_map_apply(bgp_static
->rmap
.map
, p
, RMAP_BGP
,
4853 bgp
->peer_self
->rmap_type
= 0;
4855 if (ret
== RMAP_DENYMATCH
) {
4856 /* Free uninterned attribute. */
4857 bgp_attr_flush(&attr_tmp
);
4859 /* Unintern original. */
4860 aspath_unintern(&attr
.aspath
);
4861 bgp_static_withdraw_safi(bgp
, p
, afi
, safi
,
4866 attr_new
= bgp_attr_intern(&attr_tmp
);
4868 attr_new
= bgp_attr_intern(&attr
);
4871 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
4872 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
4873 && pi
->sub_type
== BGP_ROUTE_STATIC
)
4877 memset(&add
, 0, sizeof(union gw_addr
));
4878 if (attrhash_cmp(pi
->attr
, attr_new
)
4879 && overlay_index_equal(afi
, pi
, bgp_static
->eth_s_id
, &add
)
4880 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
4881 bgp_unlock_node(rn
);
4882 bgp_attr_unintern(&attr_new
);
4883 aspath_unintern(&attr
.aspath
);
4886 /* The attribute is changed. */
4887 bgp_path_info_set_flag(rn
, pi
, BGP_PATH_ATTR_CHANGED
);
4889 /* Rewrite BGP route information. */
4890 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
4891 bgp_path_info_restore(rn
, pi
);
4893 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, safi
);
4894 bgp_attr_unintern(&pi
->attr
);
4895 pi
->attr
= attr_new
;
4896 pi
->uptime
= bgp_clock();
4899 label
= decode_label(&pi
->extra
->label
[0]);
4902 /* Process change. */
4903 bgp_aggregate_increment(bgp
, p
, pi
, afi
, safi
);
4904 bgp_process(bgp
, rn
, afi
, safi
);
4906 if (SAFI_MPLS_VPN
== safi
4907 && bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
4908 vpn_leak_to_vrf_update(bgp
, pi
);
4911 rfapiProcessUpdate(pi
->peer
, NULL
, p
, &bgp_static
->prd
,
4912 pi
->attr
, afi
, safi
, pi
->type
,
4913 pi
->sub_type
, &label
);
4915 bgp_unlock_node(rn
);
4916 aspath_unintern(&attr
.aspath
);
4922 /* Make new BGP info. */
4923 new = info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0, bgp
->peer_self
,
4925 SET_FLAG(new->flags
, BGP_PATH_VALID
);
4926 new->extra
= bgp_path_info_extra_new();
4928 new->extra
->label
[0] = bgp_static
->label
;
4929 new->extra
->num_labels
= num_labels
;
4932 label
= decode_label(&bgp_static
->label
);
4935 /* Aggregate address increment. */
4936 bgp_aggregate_increment(bgp
, p
, new, afi
, safi
);
4938 /* Register new BGP information. */
4939 bgp_path_info_add(rn
, new);
4940 /* route_node_get lock */
4941 bgp_unlock_node(rn
);
4943 /* Process change. */
4944 bgp_process(bgp
, rn
, afi
, safi
);
4946 if (SAFI_MPLS_VPN
== safi
4947 && bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
4948 vpn_leak_to_vrf_update(bgp
, new);
4951 rfapiProcessUpdate(new->peer
, NULL
, p
, &bgp_static
->prd
, new->attr
, afi
,
4952 safi
, new->type
, new->sub_type
, &label
);
4955 /* Unintern original. */
4956 aspath_unintern(&attr
.aspath
);
4959 /* Configure static BGP network. When user don't run zebra, static
4960 route should be installed as valid. */
4961 static int bgp_static_set(struct vty
*vty
, const char *negate
,
4962 const char *ip_str
, afi_t afi
, safi_t safi
,
4963 const char *rmap
, int backdoor
, uint32_t label_index
)
4965 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
4968 struct bgp_static
*bgp_static
;
4969 struct bgp_node
*rn
;
4970 uint8_t need_update
= 0;
4972 /* Convert IP prefix string to struct prefix. */
4973 ret
= str2prefix(ip_str
, &p
);
4975 vty_out(vty
, "%% Malformed prefix\n");
4976 return CMD_WARNING_CONFIG_FAILED
;
4978 if (afi
== AFI_IP6
&& IN6_IS_ADDR_LINKLOCAL(&p
.u
.prefix6
)) {
4979 vty_out(vty
, "%% Malformed prefix (link-local address)\n");
4980 return CMD_WARNING_CONFIG_FAILED
;
4987 /* Set BGP static route configuration. */
4988 rn
= bgp_node_lookup(bgp
->route
[afi
][safi
], &p
);
4991 vty_out(vty
, "%% Can't find static route specified\n");
4992 return CMD_WARNING_CONFIG_FAILED
;
4995 bgp_static
= bgp_node_get_bgp_static_info(rn
);
4997 if ((label_index
!= BGP_INVALID_LABEL_INDEX
)
4998 && (label_index
!= bgp_static
->label_index
)) {
5000 "%% label-index doesn't match static route\n");
5001 return CMD_WARNING_CONFIG_FAILED
;
5004 if ((rmap
&& bgp_static
->rmap
.name
)
5005 && strcmp(rmap
, bgp_static
->rmap
.name
)) {
5007 "%% route-map name doesn't match static route\n");
5008 return CMD_WARNING_CONFIG_FAILED
;
5011 /* Update BGP RIB. */
5012 if (!bgp_static
->backdoor
)
5013 bgp_static_withdraw(bgp
, &p
, afi
, safi
);
5015 /* Clear configuration. */
5016 bgp_static_free(bgp_static
);
5017 bgp_node_set_bgp_static_info(rn
, NULL
);
5018 bgp_unlock_node(rn
);
5019 bgp_unlock_node(rn
);
5022 /* Set BGP static route configuration. */
5023 rn
= bgp_node_get(bgp
->route
[afi
][safi
], &p
);
5025 bgp_static
= bgp_node_get_bgp_static_info(rn
);
5027 /* Configuration change. */
5028 /* Label index cannot be changed. */
5029 if (bgp_static
->label_index
!= label_index
) {
5030 vty_out(vty
, "%% cannot change label-index\n");
5031 return CMD_WARNING_CONFIG_FAILED
;
5034 /* Check previous routes are installed into BGP. */
5035 if (bgp_static
->valid
5036 && bgp_static
->backdoor
!= backdoor
)
5039 bgp_static
->backdoor
= backdoor
;
5042 XFREE(MTYPE_ROUTE_MAP_NAME
,
5043 bgp_static
->rmap
.name
);
5044 route_map_counter_decrement(
5045 bgp_static
->rmap
.map
);
5046 bgp_static
->rmap
.name
=
5047 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5048 bgp_static
->rmap
.map
=
5049 route_map_lookup_by_name(rmap
);
5050 route_map_counter_increment(
5051 bgp_static
->rmap
.map
);
5053 XFREE(MTYPE_ROUTE_MAP_NAME
,
5054 bgp_static
->rmap
.name
);
5055 route_map_counter_decrement(
5056 bgp_static
->rmap
.map
);
5057 bgp_static
->rmap
.name
= NULL
;
5058 bgp_static
->rmap
.map
= NULL
;
5059 bgp_static
->valid
= 0;
5061 bgp_unlock_node(rn
);
5063 /* New configuration. */
5064 bgp_static
= bgp_static_new();
5065 bgp_static
->backdoor
= backdoor
;
5066 bgp_static
->valid
= 0;
5067 bgp_static
->igpmetric
= 0;
5068 bgp_static
->igpnexthop
.s_addr
= 0;
5069 bgp_static
->label_index
= label_index
;
5072 XFREE(MTYPE_ROUTE_MAP_NAME
,
5073 bgp_static
->rmap
.name
);
5074 route_map_counter_decrement(
5075 bgp_static
->rmap
.map
);
5076 bgp_static
->rmap
.name
=
5077 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5078 bgp_static
->rmap
.map
=
5079 route_map_lookup_by_name(rmap
);
5080 route_map_counter_increment(
5081 bgp_static
->rmap
.map
);
5083 bgp_node_set_bgp_static_info(rn
, bgp_static
);
5086 bgp_static
->valid
= 1;
5088 bgp_static_withdraw(bgp
, &p
, afi
, safi
);
5090 if (!bgp_static
->backdoor
)
5091 bgp_static_update(bgp
, &p
, bgp_static
, afi
, safi
);
5097 void bgp_static_add(struct bgp
*bgp
)
5101 struct bgp_node
*rn
;
5102 struct bgp_node
*rm
;
5103 struct bgp_table
*table
;
5104 struct bgp_static
*bgp_static
;
5106 FOREACH_AFI_SAFI (afi
, safi
)
5107 for (rn
= bgp_table_top(bgp
->route
[afi
][safi
]); rn
;
5108 rn
= bgp_route_next(rn
)) {
5109 if (!bgp_node_has_bgp_path_info_data(rn
))
5112 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
5113 || (safi
== SAFI_EVPN
)) {
5114 table
= bgp_node_get_bgp_table_info(rn
);
5116 for (rm
= bgp_table_top(table
); rm
;
5117 rm
= bgp_route_next(rm
)) {
5119 bgp_node_get_bgp_static_info(
5121 bgp_static_update_safi(bgp
, &rm
->p
,
5128 bgp_node_get_bgp_static_info(rn
), afi
,
5134 /* Called from bgp_delete(). Delete all static routes from the BGP
5136 void bgp_static_delete(struct bgp
*bgp
)
5140 struct bgp_node
*rn
;
5141 struct bgp_node
*rm
;
5142 struct bgp_table
*table
;
5143 struct bgp_static
*bgp_static
;
5145 FOREACH_AFI_SAFI (afi
, safi
)
5146 for (rn
= bgp_table_top(bgp
->route
[afi
][safi
]); rn
;
5147 rn
= bgp_route_next(rn
)) {
5148 if (!bgp_node_has_bgp_path_info_data(rn
))
5151 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
5152 || (safi
== SAFI_EVPN
)) {
5153 table
= bgp_node_get_bgp_table_info(rn
);
5155 for (rm
= bgp_table_top(table
); rm
;
5156 rm
= bgp_route_next(rm
)) {
5158 bgp_node_get_bgp_static_info(
5163 bgp_static_withdraw_safi(
5164 bgp
, &rm
->p
, AFI_IP
, safi
,
5165 (struct prefix_rd
*)&rn
->p
);
5166 bgp_static_free(bgp_static
);
5167 bgp_node_set_bgp_static_info(rn
, NULL
);
5168 bgp_unlock_node(rn
);
5171 bgp_static
= bgp_node_get_bgp_static_info(rn
);
5172 bgp_static_withdraw(bgp
, &rn
->p
, afi
, safi
);
5173 bgp_static_free(bgp_static
);
5174 bgp_node_set_bgp_static_info(rn
, NULL
);
5175 bgp_unlock_node(rn
);
5180 void bgp_static_redo_import_check(struct bgp
*bgp
)
5184 struct bgp_node
*rn
;
5185 struct bgp_node
*rm
;
5186 struct bgp_table
*table
;
5187 struct bgp_static
*bgp_static
;
5189 /* Use this flag to force reprocessing of the route */
5190 bgp_flag_set(bgp
, BGP_FLAG_FORCE_STATIC_PROCESS
);
5191 FOREACH_AFI_SAFI (afi
, safi
) {
5192 for (rn
= bgp_table_top(bgp
->route
[afi
][safi
]); rn
;
5193 rn
= bgp_route_next(rn
)) {
5194 if (!bgp_node_has_bgp_path_info_data(rn
))
5197 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
5198 || (safi
== SAFI_EVPN
)) {
5199 table
= bgp_node_get_bgp_table_info(rn
);
5201 for (rm
= bgp_table_top(table
); rm
;
5202 rm
= bgp_route_next(rm
)) {
5204 bgp_node_get_bgp_static_info(
5206 bgp_static_update_safi(bgp
, &rm
->p
,
5211 bgp_static
= bgp_node_get_bgp_static_info(rn
);
5212 bgp_static_update(bgp
, &rn
->p
, bgp_static
, afi
,
5217 bgp_flag_unset(bgp
, BGP_FLAG_FORCE_STATIC_PROCESS
);
5220 static void bgp_purge_af_static_redist_routes(struct bgp
*bgp
, afi_t afi
,
5223 struct bgp_table
*table
;
5224 struct bgp_node
*rn
;
5225 struct bgp_path_info
*pi
;
5227 table
= bgp
->rib
[afi
][safi
];
5228 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
5229 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
5230 if (pi
->peer
== bgp
->peer_self
5231 && ((pi
->type
== ZEBRA_ROUTE_BGP
5232 && pi
->sub_type
== BGP_ROUTE_STATIC
)
5233 || (pi
->type
!= ZEBRA_ROUTE_BGP
5235 == BGP_ROUTE_REDISTRIBUTE
))) {
5236 bgp_aggregate_decrement(bgp
, &rn
->p
, pi
, afi
,
5238 bgp_unlink_nexthop(pi
);
5239 bgp_path_info_delete(rn
, pi
);
5240 bgp_process(bgp
, rn
, afi
, safi
);
5247 * Purge all networks and redistributed routes from routing table.
5248 * Invoked upon the instance going down.
5250 void bgp_purge_static_redist_routes(struct bgp
*bgp
)
5255 FOREACH_AFI_SAFI (afi
, safi
)
5256 bgp_purge_af_static_redist_routes(bgp
, afi
, safi
);
5261 * Currently this is used to set static routes for VPN and ENCAP.
5262 * I think it can probably be factored with bgp_static_set.
5264 int bgp_static_set_safi(afi_t afi
, safi_t safi
, struct vty
*vty
,
5265 const char *ip_str
, const char *rd_str
,
5266 const char *label_str
, const char *rmap_str
,
5267 int evpn_type
, const char *esi
, const char *gwip
,
5268 const char *ethtag
, const char *routermac
)
5270 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
5273 struct prefix_rd prd
;
5274 struct bgp_node
*prn
;
5275 struct bgp_node
*rn
;
5276 struct bgp_table
*table
;
5277 struct bgp_static
*bgp_static
;
5278 mpls_label_t label
= MPLS_INVALID_LABEL
;
5279 struct prefix gw_ip
;
5281 /* validate ip prefix */
5282 ret
= str2prefix(ip_str
, &p
);
5284 vty_out(vty
, "%% Malformed prefix\n");
5285 return CMD_WARNING_CONFIG_FAILED
;
5288 if ((afi
== AFI_L2VPN
)
5289 && (bgp_build_evpn_prefix(evpn_type
,
5290 ethtag
!= NULL
? atol(ethtag
) : 0, &p
))) {
5291 vty_out(vty
, "%% L2VPN prefix could not be forged\n");
5292 return CMD_WARNING_CONFIG_FAILED
;
5295 ret
= str2prefix_rd(rd_str
, &prd
);
5297 vty_out(vty
, "%% Malformed rd\n");
5298 return CMD_WARNING_CONFIG_FAILED
;
5302 unsigned long label_val
;
5303 label_val
= strtoul(label_str
, NULL
, 10);
5304 encode_label(label_val
, &label
);
5307 if (safi
== SAFI_EVPN
) {
5308 if (esi
&& str2esi(esi
, NULL
) == 0) {
5309 vty_out(vty
, "%% Malformed ESI\n");
5310 return CMD_WARNING_CONFIG_FAILED
;
5312 if (routermac
&& prefix_str2mac(routermac
, NULL
) == 0) {
5313 vty_out(vty
, "%% Malformed Router MAC\n");
5314 return CMD_WARNING_CONFIG_FAILED
;
5317 memset(&gw_ip
, 0, sizeof(struct prefix
));
5318 ret
= str2prefix(gwip
, &gw_ip
);
5320 vty_out(vty
, "%% Malformed GatewayIp\n");
5321 return CMD_WARNING_CONFIG_FAILED
;
5323 if ((gw_ip
.family
== AF_INET
5324 && is_evpn_prefix_ipaddr_v6(
5325 (struct prefix_evpn
*)&p
))
5326 || (gw_ip
.family
== AF_INET6
5327 && is_evpn_prefix_ipaddr_v4(
5328 (struct prefix_evpn
*)&p
))) {
5330 "%% GatewayIp family differs with IP prefix\n");
5331 return CMD_WARNING_CONFIG_FAILED
;
5335 prn
= bgp_node_get(bgp
->route
[afi
][safi
], (struct prefix
*)&prd
);
5336 if (!bgp_node_has_bgp_path_info_data(prn
))
5337 bgp_node_set_bgp_table_info(prn
,
5338 bgp_table_init(bgp
, afi
, safi
));
5339 table
= bgp_node_get_bgp_table_info(prn
);
5341 rn
= bgp_node_get(table
, &p
);
5343 if (bgp_node_has_bgp_path_info_data(rn
)) {
5344 vty_out(vty
, "%% Same network configuration exists\n");
5345 bgp_unlock_node(rn
);
5347 /* New configuration. */
5348 bgp_static
= bgp_static_new();
5349 bgp_static
->backdoor
= 0;
5350 bgp_static
->valid
= 0;
5351 bgp_static
->igpmetric
= 0;
5352 bgp_static
->igpnexthop
.s_addr
= 0;
5353 bgp_static
->label
= label
;
5354 bgp_static
->prd
= prd
;
5357 XFREE(MTYPE_ROUTE_MAP_NAME
, bgp_static
->rmap
.name
);
5358 route_map_counter_decrement(bgp_static
->rmap
.map
);
5359 bgp_static
->rmap
.name
=
5360 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_str
);
5361 bgp_static
->rmap
.map
=
5362 route_map_lookup_by_name(rmap_str
);
5363 route_map_counter_increment(bgp_static
->rmap
.map
);
5366 if (safi
== SAFI_EVPN
) {
5368 bgp_static
->eth_s_id
=
5370 sizeof(struct eth_segment_id
));
5371 str2esi(esi
, bgp_static
->eth_s_id
);
5374 bgp_static
->router_mac
=
5375 XCALLOC(MTYPE_ATTR
, ETH_ALEN
+ 1);
5376 (void)prefix_str2mac(routermac
,
5377 bgp_static
->router_mac
);
5380 prefix_copy(&bgp_static
->gatewayIp
, &gw_ip
);
5382 bgp_node_set_bgp_static_info(rn
, bgp_static
);
5384 bgp_static
->valid
= 1;
5385 bgp_static_update_safi(bgp
, &p
, bgp_static
, afi
, safi
);
5391 /* Configure static BGP network. */
5392 int bgp_static_unset_safi(afi_t afi
, safi_t safi
, struct vty
*vty
,
5393 const char *ip_str
, const char *rd_str
,
5394 const char *label_str
, int evpn_type
, const char *esi
,
5395 const char *gwip
, const char *ethtag
)
5397 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
5400 struct prefix_rd prd
;
5401 struct bgp_node
*prn
;
5402 struct bgp_node
*rn
;
5403 struct bgp_table
*table
;
5404 struct bgp_static
*bgp_static
;
5405 mpls_label_t label
= MPLS_INVALID_LABEL
;
5407 /* Convert IP prefix string to struct prefix. */
5408 ret
= str2prefix(ip_str
, &p
);
5410 vty_out(vty
, "%% Malformed prefix\n");
5411 return CMD_WARNING_CONFIG_FAILED
;
5414 if ((afi
== AFI_L2VPN
)
5415 && (bgp_build_evpn_prefix(evpn_type
,
5416 ethtag
!= NULL
? atol(ethtag
) : 0, &p
))) {
5417 vty_out(vty
, "%% L2VPN prefix could not be forged\n");
5418 return CMD_WARNING_CONFIG_FAILED
;
5420 ret
= str2prefix_rd(rd_str
, &prd
);
5422 vty_out(vty
, "%% Malformed rd\n");
5423 return CMD_WARNING_CONFIG_FAILED
;
5427 unsigned long label_val
;
5428 label_val
= strtoul(label_str
, NULL
, 10);
5429 encode_label(label_val
, &label
);
5432 prn
= bgp_node_get(bgp
->route
[afi
][safi
], (struct prefix
*)&prd
);
5433 if (!bgp_node_has_bgp_path_info_data(prn
))
5434 bgp_node_set_bgp_table_info(prn
,
5435 bgp_table_init(bgp
, afi
, safi
));
5437 bgp_unlock_node(prn
);
5438 table
= bgp_node_get_bgp_table_info(prn
);
5440 rn
= bgp_node_lookup(table
, &p
);
5443 bgp_static_withdraw_safi(bgp
, &p
, afi
, safi
, &prd
);
5445 bgp_static
= bgp_node_get_bgp_static_info(rn
);
5446 bgp_static_free(bgp_static
);
5447 bgp_node_set_bgp_static_info(rn
, NULL
);
5448 bgp_unlock_node(rn
);
5449 bgp_unlock_node(rn
);
5451 vty_out(vty
, "%% Can't find the route\n");
5456 static int bgp_table_map_set(struct vty
*vty
, afi_t afi
, safi_t safi
,
5457 const char *rmap_name
)
5459 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
5460 struct bgp_rmap
*rmap
;
5462 rmap
= &bgp
->table_map
[afi
][safi
];
5464 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
5465 route_map_counter_decrement(rmap
->map
);
5466 rmap
->name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
5467 rmap
->map
= route_map_lookup_by_name(rmap_name
);
5468 route_map_counter_increment(rmap
->map
);
5470 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
5471 route_map_counter_decrement(rmap
->map
);
5476 if (bgp_fibupd_safi(safi
))
5477 bgp_zebra_announce_table(bgp
, afi
, safi
);
5482 static int bgp_table_map_unset(struct vty
*vty
, afi_t afi
, safi_t safi
,
5483 const char *rmap_name
)
5485 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
5486 struct bgp_rmap
*rmap
;
5488 rmap
= &bgp
->table_map
[afi
][safi
];
5489 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
5490 route_map_counter_decrement(rmap
->map
);
5494 if (bgp_fibupd_safi(safi
))
5495 bgp_zebra_announce_table(bgp
, afi
, safi
);
5500 void bgp_config_write_table_map(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
5503 if (bgp
->table_map
[afi
][safi
].name
) {
5504 vty_out(vty
, " table-map %s\n",
5505 bgp
->table_map
[afi
][safi
].name
);
5509 DEFUN (bgp_table_map
,
5512 "BGP table to RIB route download filter\n"
5513 "Name of the route map\n")
5516 return bgp_table_map_set(vty
, bgp_node_afi(vty
), bgp_node_safi(vty
),
5517 argv
[idx_word
]->arg
);
5519 DEFUN (no_bgp_table_map
,
5520 no_bgp_table_map_cmd
,
5521 "no table-map WORD",
5523 "BGP table to RIB route download filter\n"
5524 "Name of the route map\n")
5527 return bgp_table_map_unset(vty
, bgp_node_afi(vty
), bgp_node_safi(vty
),
5528 argv
[idx_word
]->arg
);
5534 <A.B.C.D/M$prefix|A.B.C.D$address [mask A.B.C.D$netmask]> \
5535 [{route-map WORD$map_name|label-index (0-1048560)$label_index| \
5536 backdoor$backdoor}]",
5538 "Specify a network to announce via BGP\n"
5543 "Route-map to modify the attributes\n"
5544 "Name of the route map\n"
5545 "Label index to associate with the prefix\n"
5546 "Label index value\n"
5547 "Specify a BGP backdoor route\n")
5549 char addr_prefix_str
[BUFSIZ
];
5554 ret
= netmask_str2prefix_str(address_str
, netmask_str
,
5557 vty_out(vty
, "%% Inconsistent address and mask\n");
5558 return CMD_WARNING_CONFIG_FAILED
;
5562 return bgp_static_set(
5563 vty
, no
, address_str
? addr_prefix_str
: prefix_str
, AFI_IP
,
5564 bgp_node_safi(vty
), map_name
, backdoor
? 1 : 0,
5565 label_index
? (uint32_t)label_index
: BGP_INVALID_LABEL_INDEX
);
5568 DEFPY(ipv6_bgp_network
,
5569 ipv6_bgp_network_cmd
,
5570 "[no] network X:X::X:X/M$prefix \
5571 [{route-map WORD$map_name|label-index (0-1048560)$label_index}]",
5573 "Specify a network to announce via BGP\n"
5575 "Route-map to modify the attributes\n"
5576 "Name of the route map\n"
5577 "Label index to associate with the prefix\n"
5578 "Label index value\n")
5580 return bgp_static_set(
5581 vty
, no
, prefix_str
, AFI_IP6
, bgp_node_safi(vty
), map_name
, 0,
5582 label_index
? (uint32_t)label_index
: BGP_INVALID_LABEL_INDEX
);
5585 static struct bgp_aggregate
*bgp_aggregate_new(void)
5587 return XCALLOC(MTYPE_BGP_AGGREGATE
, sizeof(struct bgp_aggregate
));
5590 static void bgp_aggregate_free(struct bgp_aggregate
*aggregate
)
5592 XFREE(MTYPE_BGP_AGGREGATE
, aggregate
);
5595 static int bgp_aggregate_info_same(struct bgp_path_info
*pi
, uint8_t origin
,
5596 struct aspath
*aspath
,
5597 struct community
*comm
,
5598 struct ecommunity
*ecomm
,
5599 struct lcommunity
*lcomm
)
5601 static struct aspath
*ae
= NULL
;
5604 ae
= aspath_empty();
5609 if (origin
!= pi
->attr
->origin
)
5612 if (!aspath_cmp(pi
->attr
->aspath
, (aspath
) ? aspath
: ae
))
5615 if (!community_cmp(pi
->attr
->community
, comm
))
5618 if (!ecommunity_cmp(pi
->attr
->ecommunity
, ecomm
))
5621 if (!lcommunity_cmp(pi
->attr
->lcommunity
, lcomm
))
5624 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
))
5630 static void bgp_aggregate_install(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5631 struct prefix
*p
, uint8_t origin
,
5632 struct aspath
*aspath
,
5633 struct community
*community
,
5634 struct ecommunity
*ecommunity
,
5635 struct lcommunity
*lcommunity
,
5636 uint8_t atomic_aggregate
,
5637 struct bgp_aggregate
*aggregate
)
5639 struct bgp_node
*rn
;
5640 struct bgp_table
*table
;
5641 struct bgp_path_info
*pi
, *orig
, *new;
5643 table
= bgp
->rib
[afi
][safi
];
5645 rn
= bgp_node_get(table
, p
);
5647 for (orig
= pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
5648 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
5649 && pi
->sub_type
== BGP_ROUTE_AGGREGATE
)
5652 if (aggregate
->count
> 0) {
5654 * If the aggregate information has not changed
5655 * no need to re-install it again.
5657 if (bgp_aggregate_info_same(orig
, origin
, aspath
, community
,
5658 ecommunity
, lcommunity
)) {
5659 bgp_unlock_node(rn
);
5662 aspath_free(aspath
);
5664 community_free(&community
);
5666 ecommunity_free(&ecommunity
);
5668 lcommunity_free(&lcommunity
);
5674 * Mark the old as unusable
5677 bgp_path_info_delete(rn
, pi
);
5679 new = info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_AGGREGATE
, 0,
5681 bgp_attr_aggregate_intern(bgp
, origin
, aspath
,
5682 community
, ecommunity
,
5687 SET_FLAG(new->flags
, BGP_PATH_VALID
);
5689 bgp_path_info_add(rn
, new);
5690 bgp_process(bgp
, rn
, afi
, safi
);
5692 for (pi
= orig
; pi
; pi
= pi
->next
)
5693 if (pi
->peer
== bgp
->peer_self
5694 && pi
->type
== ZEBRA_ROUTE_BGP
5695 && pi
->sub_type
== BGP_ROUTE_AGGREGATE
)
5698 /* Withdraw static BGP route from routing table. */
5700 bgp_path_info_delete(rn
, pi
);
5701 bgp_process(bgp
, rn
, afi
, safi
);
5705 bgp_unlock_node(rn
);
5708 /* Update an aggregate as routes are added/removed from the BGP table */
5709 static void bgp_aggregate_route(struct bgp
*bgp
, struct prefix
*p
,
5710 afi_t afi
, safi_t safi
,
5711 struct bgp_aggregate
*aggregate
)
5713 struct bgp_table
*table
;
5714 struct bgp_node
*top
;
5715 struct bgp_node
*rn
;
5717 struct aspath
*aspath
= NULL
;
5718 struct community
*community
= NULL
;
5719 struct ecommunity
*ecommunity
= NULL
;
5720 struct lcommunity
*lcommunity
= NULL
;
5721 struct bgp_path_info
*pi
;
5722 unsigned long match
= 0;
5723 uint8_t atomic_aggregate
= 0;
5725 /* ORIGIN attribute: If at least one route among routes that are
5726 aggregated has ORIGIN with the value INCOMPLETE, then the
5727 aggregated route must have the ORIGIN attribute with the value
5728 INCOMPLETE. Otherwise, if at least one route among routes that
5729 are aggregated has ORIGIN with the value EGP, then the aggregated
5730 route must have the origin attribute with the value EGP. In all
5731 other case the value of the ORIGIN attribute of the aggregated
5732 route is INTERNAL. */
5733 origin
= BGP_ORIGIN_IGP
;
5735 table
= bgp
->rib
[afi
][safi
];
5737 top
= bgp_node_get(table
, p
);
5738 for (rn
= bgp_node_get(table
, p
); rn
;
5739 rn
= bgp_route_next_until(rn
, top
)) {
5740 if (rn
->p
.prefixlen
<= p
->prefixlen
)
5745 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
5746 if (BGP_PATH_HOLDDOWN(pi
))
5750 & ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
))
5751 atomic_aggregate
= 1;
5753 if (pi
->sub_type
== BGP_ROUTE_AGGREGATE
)
5757 * summary-only aggregate route suppress
5758 * aggregated route announcements.
5760 if (aggregate
->summary_only
) {
5761 (bgp_path_info_extra_get(pi
))->suppress
++;
5762 bgp_path_info_set_flag(rn
, pi
,
5763 BGP_PATH_ATTR_CHANGED
);
5770 * If at least one route among routes that are
5771 * aggregated has ORIGIN with the value INCOMPLETE,
5772 * then the aggregated route MUST have the ORIGIN
5773 * attribute with the value INCOMPLETE. Otherwise, if
5774 * at least one route among routes that are aggregated
5775 * has ORIGIN with the value EGP, then the aggregated
5776 * route MUST have the ORIGIN attribute with the value
5779 switch (pi
->attr
->origin
) {
5780 case BGP_ORIGIN_INCOMPLETE
:
5781 aggregate
->incomplete_origin_count
++;
5783 case BGP_ORIGIN_EGP
:
5784 aggregate
->egp_origin_count
++;
5792 if (!aggregate
->as_set
)
5796 * as-set aggregate route generate origin, as path,
5797 * and community aggregation.
5799 /* Compute aggregate route's as-path.
5801 bgp_compute_aggregate_aspath(aggregate
,
5804 /* Compute aggregate route's community.
5806 if (pi
->attr
->community
)
5807 bgp_compute_aggregate_community(
5809 pi
->attr
->community
);
5811 /* Compute aggregate route's extended community.
5813 if (pi
->attr
->ecommunity
)
5814 bgp_compute_aggregate_ecommunity(
5816 pi
->attr
->ecommunity
);
5818 /* Compute aggregate route's large community.
5820 if (pi
->attr
->lcommunity
)
5821 bgp_compute_aggregate_lcommunity(
5823 pi
->attr
->lcommunity
);
5826 bgp_process(bgp
, rn
, afi
, safi
);
5828 bgp_unlock_node(top
);
5831 if (aggregate
->incomplete_origin_count
> 0)
5832 origin
= BGP_ORIGIN_INCOMPLETE
;
5833 else if (aggregate
->egp_origin_count
> 0)
5834 origin
= BGP_ORIGIN_EGP
;
5836 if (aggregate
->as_set
) {
5837 if (aggregate
->aspath
)
5838 /* Retrieve aggregate route's as-path.
5840 aspath
= aspath_dup(aggregate
->aspath
);
5842 if (aggregate
->community
)
5843 /* Retrieve aggregate route's community.
5845 community
= community_dup(aggregate
->community
);
5847 if (aggregate
->ecommunity
)
5848 /* Retrieve aggregate route's ecommunity.
5850 ecommunity
= ecommunity_dup(aggregate
->ecommunity
);
5852 if (aggregate
->lcommunity
)
5853 /* Retrieve aggregate route's lcommunity.
5855 lcommunity
= lcommunity_dup(aggregate
->lcommunity
);
5858 bgp_aggregate_install(bgp
, afi
, safi
, p
, origin
, aspath
, community
,
5859 ecommunity
, lcommunity
, atomic_aggregate
,
5863 static void bgp_aggregate_delete(struct bgp
*bgp
, struct prefix
*p
, afi_t afi
,
5864 safi_t safi
, struct bgp_aggregate
*aggregate
)
5866 struct bgp_table
*table
;
5867 struct bgp_node
*top
;
5868 struct bgp_node
*rn
;
5869 struct bgp_path_info
*pi
;
5870 unsigned long match
;
5872 table
= bgp
->rib
[afi
][safi
];
5874 /* If routes exists below this node, generate aggregate routes. */
5875 top
= bgp_node_get(table
, p
);
5876 for (rn
= bgp_node_get(table
, p
); rn
;
5877 rn
= bgp_route_next_until(rn
, top
)) {
5878 if (rn
->p
.prefixlen
<= p
->prefixlen
)
5882 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
5883 if (BGP_PATH_HOLDDOWN(pi
))
5886 if (pi
->sub_type
== BGP_ROUTE_AGGREGATE
)
5889 if (aggregate
->summary_only
&& pi
->extra
) {
5890 pi
->extra
->suppress
--;
5892 if (pi
->extra
->suppress
== 0) {
5893 bgp_path_info_set_flag(
5894 rn
, pi
, BGP_PATH_ATTR_CHANGED
);
5900 if (pi
->attr
->origin
== BGP_ORIGIN_INCOMPLETE
)
5901 aggregate
->incomplete_origin_count
--;
5902 else if (pi
->attr
->origin
== BGP_ORIGIN_EGP
)
5903 aggregate
->egp_origin_count
--;
5905 if (aggregate
->as_set
) {
5906 /* Remove as-path from aggregate.
5908 bgp_remove_aspath_from_aggregate(
5912 if (pi
->attr
->community
)
5913 /* Remove community from aggregate.
5915 bgp_remove_community_from_aggregate(
5917 pi
->attr
->community
);
5919 if (pi
->attr
->ecommunity
)
5920 /* Remove ecommunity from aggregate.
5922 bgp_remove_ecommunity_from_aggregate(
5924 pi
->attr
->ecommunity
);
5926 if (pi
->attr
->lcommunity
)
5927 /* Remove lcommunity from aggregate.
5929 bgp_remove_lcommunity_from_aggregate(
5931 pi
->attr
->lcommunity
);
5936 /* If this node was suppressed, process the change. */
5938 bgp_process(bgp
, rn
, afi
, safi
);
5940 bgp_unlock_node(top
);
5943 static void bgp_add_route_to_aggregate(struct bgp
*bgp
, struct prefix
*aggr_p
,
5944 struct bgp_path_info
*pinew
, afi_t afi
,
5946 struct bgp_aggregate
*aggregate
)
5949 struct aspath
*aspath
= NULL
;
5950 uint8_t atomic_aggregate
= 0;
5951 struct community
*community
= NULL
;
5952 struct ecommunity
*ecommunity
= NULL
;
5953 struct lcommunity
*lcommunity
= NULL
;
5955 /* ORIGIN attribute: If at least one route among routes that are
5956 * aggregated has ORIGIN with the value INCOMPLETE, then the
5957 * aggregated route must have the ORIGIN attribute with the value
5958 * INCOMPLETE. Otherwise, if at least one route among routes that
5959 * are aggregated has ORIGIN with the value EGP, then the aggregated
5960 * route must have the origin attribute with the value EGP. In all
5961 * other case the value of the ORIGIN attribute of the aggregated
5962 * route is INTERNAL.
5964 origin
= BGP_ORIGIN_IGP
;
5968 if (aggregate
->summary_only
)
5969 (bgp_path_info_extra_get(pinew
))->suppress
++;
5971 switch (pinew
->attr
->origin
) {
5972 case BGP_ORIGIN_INCOMPLETE
:
5973 aggregate
->incomplete_origin_count
++;
5975 case BGP_ORIGIN_EGP
:
5976 aggregate
->egp_origin_count
++;
5984 if (aggregate
->incomplete_origin_count
> 0)
5985 origin
= BGP_ORIGIN_INCOMPLETE
;
5986 else if (aggregate
->egp_origin_count
> 0)
5987 origin
= BGP_ORIGIN_EGP
;
5989 if (aggregate
->as_set
) {
5990 /* Compute aggregate route's as-path.
5992 bgp_compute_aggregate_aspath(aggregate
,
5993 pinew
->attr
->aspath
);
5995 /* Compute aggregate route's community.
5997 if (pinew
->attr
->community
)
5998 bgp_compute_aggregate_community(
6000 pinew
->attr
->community
);
6002 /* Compute aggregate route's extended community.
6004 if (pinew
->attr
->ecommunity
)
6005 bgp_compute_aggregate_ecommunity(
6007 pinew
->attr
->ecommunity
);
6009 /* Compute aggregate route's large community.
6011 if (pinew
->attr
->lcommunity
)
6012 bgp_compute_aggregate_lcommunity(
6014 pinew
->attr
->lcommunity
);
6016 /* Retrieve aggregate route's as-path.
6018 if (aggregate
->aspath
)
6019 aspath
= aspath_dup(aggregate
->aspath
);
6021 /* Retrieve aggregate route's community.
6023 if (aggregate
->community
)
6024 community
= community_dup(aggregate
->community
);
6026 /* Retrieve aggregate route's ecommunity.
6028 if (aggregate
->ecommunity
)
6029 ecommunity
= ecommunity_dup(aggregate
->ecommunity
);
6031 /* Retrieve aggregate route's lcommunity.
6033 if (aggregate
->lcommunity
)
6034 lcommunity
= lcommunity_dup(aggregate
->lcommunity
);
6037 bgp_aggregate_install(bgp
, afi
, safi
, aggr_p
, origin
,
6038 aspath
, community
, ecommunity
,
6039 lcommunity
, atomic_aggregate
, aggregate
);
6042 static void bgp_remove_route_from_aggregate(struct bgp
*bgp
, afi_t afi
,
6044 struct bgp_path_info
*pi
,
6045 struct bgp_aggregate
*aggregate
,
6046 struct prefix
*aggr_p
)
6049 struct aspath
*aspath
= NULL
;
6050 uint8_t atomic_aggregate
= 0;
6051 struct community
*community
= NULL
;
6052 struct ecommunity
*ecommunity
= NULL
;
6053 struct lcommunity
*lcommunity
= NULL
;
6054 unsigned long match
= 0;
6056 if (BGP_PATH_HOLDDOWN(pi
))
6059 if (pi
->sub_type
== BGP_ROUTE_AGGREGATE
)
6062 if (aggregate
->summary_only
6064 && pi
->extra
->suppress
> 0) {
6065 pi
->extra
->suppress
--;
6067 if (pi
->extra
->suppress
== 0) {
6068 bgp_path_info_set_flag(pi
->net
, pi
,
6069 BGP_PATH_ATTR_CHANGED
);
6074 if (aggregate
->count
> 0)
6077 if (pi
->attr
->origin
== BGP_ORIGIN_INCOMPLETE
)
6078 aggregate
->incomplete_origin_count
--;
6079 else if (pi
->attr
->origin
== BGP_ORIGIN_EGP
)
6080 aggregate
->egp_origin_count
--;
6082 if (aggregate
->as_set
) {
6083 /* Remove as-path from aggregate.
6085 bgp_remove_aspath_from_aggregate(aggregate
,
6088 if (pi
->attr
->community
)
6089 /* Remove community from aggregate.
6091 bgp_remove_community_from_aggregate(
6093 pi
->attr
->community
);
6095 if (pi
->attr
->ecommunity
)
6096 /* Remove ecommunity from aggregate.
6098 bgp_remove_ecommunity_from_aggregate(
6100 pi
->attr
->ecommunity
);
6102 if (pi
->attr
->lcommunity
)
6103 /* Remove lcommunity from aggregate.
6105 bgp_remove_lcommunity_from_aggregate(
6107 pi
->attr
->lcommunity
);
6110 /* If this node was suppressed, process the change. */
6112 bgp_process(bgp
, pi
->net
, afi
, safi
);
6114 origin
= BGP_ORIGIN_IGP
;
6115 if (aggregate
->incomplete_origin_count
> 0)
6116 origin
= BGP_ORIGIN_INCOMPLETE
;
6117 else if (aggregate
->egp_origin_count
> 0)
6118 origin
= BGP_ORIGIN_EGP
;
6120 if (aggregate
->as_set
) {
6121 /* Retrieve aggregate route's as-path.
6123 if (aggregate
->aspath
)
6124 aspath
= aspath_dup(aggregate
->aspath
);
6126 /* Retrieve aggregate route's community.
6128 if (aggregate
->community
)
6129 community
= community_dup(aggregate
->community
);
6131 /* Retrieve aggregate route's ecommunity.
6133 if (aggregate
->ecommunity
)
6134 ecommunity
= ecommunity_dup(aggregate
->ecommunity
);
6136 /* Retrieve aggregate route's lcommunity.
6138 if (aggregate
->lcommunity
)
6139 lcommunity
= lcommunity_dup(aggregate
->lcommunity
);
6142 bgp_aggregate_install(bgp
, afi
, safi
, aggr_p
, origin
,
6143 aspath
, community
, ecommunity
,
6144 lcommunity
, atomic_aggregate
, aggregate
);
6147 void bgp_aggregate_increment(struct bgp
*bgp
, struct prefix
*p
,
6148 struct bgp_path_info
*pi
, afi_t afi
, safi_t safi
)
6150 struct bgp_node
*child
;
6151 struct bgp_node
*rn
;
6152 struct bgp_aggregate
*aggregate
;
6153 struct bgp_table
*table
;
6155 table
= bgp
->aggregate
[afi
][safi
];
6157 /* No aggregates configured. */
6158 if (bgp_table_top_nolock(table
) == NULL
)
6161 if (p
->prefixlen
== 0)
6164 if (BGP_PATH_HOLDDOWN(pi
))
6167 child
= bgp_node_get(table
, p
);
6169 /* Aggregate address configuration check. */
6170 for (rn
= child
; rn
; rn
= bgp_node_parent_nolock(rn
)) {
6171 aggregate
= bgp_node_get_bgp_aggregate_info(rn
);
6172 if (aggregate
!= NULL
&& rn
->p
.prefixlen
< p
->prefixlen
) {
6173 bgp_add_route_to_aggregate(bgp
, &rn
->p
, pi
, afi
,
6177 bgp_unlock_node(child
);
6180 void bgp_aggregate_decrement(struct bgp
*bgp
, struct prefix
*p
,
6181 struct bgp_path_info
*del
, afi_t afi
, safi_t safi
)
6183 struct bgp_node
*child
;
6184 struct bgp_node
*rn
;
6185 struct bgp_aggregate
*aggregate
;
6186 struct bgp_table
*table
;
6188 table
= bgp
->aggregate
[afi
][safi
];
6190 /* No aggregates configured. */
6191 if (bgp_table_top_nolock(table
) == NULL
)
6194 if (p
->prefixlen
== 0)
6197 child
= bgp_node_get(table
, p
);
6199 /* Aggregate address configuration check. */
6200 for (rn
= child
; rn
; rn
= bgp_node_parent_nolock(rn
)) {
6201 aggregate
= bgp_node_get_bgp_aggregate_info(rn
);
6202 if (aggregate
!= NULL
&& rn
->p
.prefixlen
< p
->prefixlen
) {
6203 bgp_remove_route_from_aggregate(bgp
, afi
, safi
,
6204 del
, aggregate
, &rn
->p
);
6207 bgp_unlock_node(child
);
6210 /* Aggregate route attribute. */
6211 #define AGGREGATE_SUMMARY_ONLY 1
6212 #define AGGREGATE_AS_SET 1
6214 static int bgp_aggregate_unset(struct vty
*vty
, const char *prefix_str
,
6215 afi_t afi
, safi_t safi
)
6217 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
6220 struct bgp_node
*rn
;
6221 struct bgp_aggregate
*aggregate
;
6223 /* Convert string to prefix structure. */
6224 ret
= str2prefix(prefix_str
, &p
);
6226 vty_out(vty
, "Malformed prefix\n");
6227 return CMD_WARNING_CONFIG_FAILED
;
6231 /* Old configuration check. */
6232 rn
= bgp_node_lookup(bgp
->aggregate
[afi
][safi
], &p
);
6235 "%% There is no aggregate-address configuration.\n");
6236 return CMD_WARNING_CONFIG_FAILED
;
6239 aggregate
= bgp_node_get_bgp_aggregate_info(rn
);
6240 bgp_aggregate_delete(bgp
, &p
, afi
, safi
, aggregate
);
6241 bgp_aggregate_install(bgp
, afi
, safi
, &p
, 0, NULL
, NULL
,
6242 NULL
, NULL
, 0, aggregate
);
6244 /* Unlock aggregate address configuration. */
6245 bgp_node_set_bgp_aggregate_info(rn
, NULL
);
6247 if (aggregate
->community
)
6248 community_free(&aggregate
->community
);
6250 if (aggregate
->community_hash
) {
6251 /* Delete all communities in the hash.
6253 hash_clean(aggregate
->community_hash
,
6254 bgp_aggr_community_remove
);
6255 /* Free up the community_hash.
6257 hash_free(aggregate
->community_hash
);
6260 if (aggregate
->ecommunity
)
6261 ecommunity_free(&aggregate
->ecommunity
);
6263 if (aggregate
->ecommunity_hash
) {
6264 /* Delete all ecommunities in the hash.
6266 hash_clean(aggregate
->ecommunity_hash
,
6267 bgp_aggr_ecommunity_remove
);
6268 /* Free up the ecommunity_hash.
6270 hash_free(aggregate
->ecommunity_hash
);
6273 if (aggregate
->lcommunity
)
6274 lcommunity_free(&aggregate
->lcommunity
);
6276 if (aggregate
->lcommunity_hash
) {
6277 /* Delete all lcommunities in the hash.
6279 hash_clean(aggregate
->lcommunity_hash
,
6280 bgp_aggr_lcommunity_remove
);
6281 /* Free up the lcommunity_hash.
6283 hash_free(aggregate
->lcommunity_hash
);
6286 if (aggregate
->aspath
)
6287 aspath_free(aggregate
->aspath
);
6289 if (aggregate
->aspath_hash
) {
6290 /* Delete all as-paths in the hash.
6292 hash_clean(aggregate
->aspath_hash
,
6293 bgp_aggr_aspath_remove
);
6294 /* Free up the aspath_hash.
6296 hash_free(aggregate
->aspath_hash
);
6299 bgp_aggregate_free(aggregate
);
6300 bgp_unlock_node(rn
);
6301 bgp_unlock_node(rn
);
6306 static int bgp_aggregate_set(struct vty
*vty
, const char *prefix_str
, afi_t afi
,
6307 safi_t safi
, uint8_t summary_only
, uint8_t as_set
)
6309 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
6312 struct bgp_node
*rn
;
6313 struct bgp_aggregate
*aggregate
;
6315 /* Convert string to prefix structure. */
6316 ret
= str2prefix(prefix_str
, &p
);
6318 vty_out(vty
, "Malformed prefix\n");
6319 return CMD_WARNING_CONFIG_FAILED
;
6323 if ((afi
== AFI_IP
&& p
.prefixlen
== IPV4_MAX_BITLEN
) ||
6324 (afi
== AFI_IP6
&& p
.prefixlen
== IPV6_MAX_BITLEN
)) {
6325 vty_out(vty
, "Specified prefix: %s will not result in any useful aggregation, disallowing\n",
6327 return CMD_WARNING_CONFIG_FAILED
;
6330 /* Old configuration check. */
6331 rn
= bgp_node_get(bgp
->aggregate
[afi
][safi
], &p
);
6333 if (bgp_node_has_bgp_path_info_data(rn
)) {
6334 vty_out(vty
, "There is already same aggregate network.\n");
6335 /* try to remove the old entry */
6336 ret
= bgp_aggregate_unset(vty
, prefix_str
, afi
, safi
);
6338 vty_out(vty
, "Error deleting aggregate.\n");
6339 bgp_unlock_node(rn
);
6340 return CMD_WARNING_CONFIG_FAILED
;
6344 /* Make aggregate address structure. */
6345 aggregate
= bgp_aggregate_new();
6346 aggregate
->summary_only
= summary_only
;
6347 aggregate
->as_set
= as_set
;
6348 aggregate
->safi
= safi
;
6349 bgp_node_set_bgp_aggregate_info(rn
, aggregate
);
6351 /* Aggregate address insert into BGP routing table. */
6352 bgp_aggregate_route(bgp
, &p
, afi
, safi
, aggregate
);
6357 DEFUN (aggregate_address
,
6358 aggregate_address_cmd
,
6359 "aggregate-address A.B.C.D/M [<as-set [summary-only]|summary-only [as-set]>]",
6360 "Configure BGP aggregate entries\n"
6361 "Aggregate prefix\n"
6362 "Generate AS set path information\n"
6363 "Filter more specific routes from updates\n"
6364 "Filter more specific routes from updates\n"
6365 "Generate AS set path information\n")
6368 argv_find(argv
, argc
, "A.B.C.D/M", &idx
);
6369 char *prefix
= argv
[idx
]->arg
;
6371 argv_find(argv
, argc
, "as-set", &idx
) ? AGGREGATE_AS_SET
: 0;
6373 int summary_only
= argv_find(argv
, argc
, "summary-only", &idx
)
6374 ? AGGREGATE_SUMMARY_ONLY
6377 return bgp_aggregate_set(vty
, prefix
, AFI_IP
, bgp_node_safi(vty
),
6378 summary_only
, as_set
);
6381 DEFUN (aggregate_address_mask
,
6382 aggregate_address_mask_cmd
,
6383 "aggregate-address A.B.C.D A.B.C.D [<as-set [summary-only]|summary-only [as-set]>]",
6384 "Configure BGP aggregate entries\n"
6385 "Aggregate address\n"
6387 "Generate AS set path information\n"
6388 "Filter more specific routes from updates\n"
6389 "Filter more specific routes from updates\n"
6390 "Generate AS set path information\n")
6393 argv_find(argv
, argc
, "A.B.C.D", &idx
);
6394 char *prefix
= argv
[idx
]->arg
;
6395 char *mask
= argv
[idx
+ 1]->arg
;
6397 argv_find(argv
, argc
, "as-set", &idx
) ? AGGREGATE_AS_SET
: 0;
6399 int summary_only
= argv_find(argv
, argc
, "summary-only", &idx
)
6400 ? AGGREGATE_SUMMARY_ONLY
6403 char prefix_str
[BUFSIZ
];
6404 int ret
= netmask_str2prefix_str(prefix
, mask
, prefix_str
);
6407 vty_out(vty
, "%% Inconsistent address and mask\n");
6408 return CMD_WARNING_CONFIG_FAILED
;
6411 return bgp_aggregate_set(vty
, prefix_str
, AFI_IP
, bgp_node_safi(vty
),
6412 summary_only
, as_set
);
6415 DEFUN (no_aggregate_address
,
6416 no_aggregate_address_cmd
,
6417 "no aggregate-address A.B.C.D/M [<as-set [summary-only]|summary-only [as-set]>]",
6419 "Configure BGP aggregate entries\n"
6420 "Aggregate prefix\n"
6421 "Generate AS set path information\n"
6422 "Filter more specific routes from updates\n"
6423 "Filter more specific routes from updates\n"
6424 "Generate AS set path information\n")
6427 argv_find(argv
, argc
, "A.B.C.D/M", &idx
);
6428 char *prefix
= argv
[idx
]->arg
;
6429 return bgp_aggregate_unset(vty
, prefix
, AFI_IP
, bgp_node_safi(vty
));
6432 DEFUN (no_aggregate_address_mask
,
6433 no_aggregate_address_mask_cmd
,
6434 "no aggregate-address A.B.C.D A.B.C.D [<as-set [summary-only]|summary-only [as-set]>]",
6436 "Configure BGP aggregate entries\n"
6437 "Aggregate address\n"
6439 "Generate AS set path information\n"
6440 "Filter more specific routes from updates\n"
6441 "Filter more specific routes from updates\n"
6442 "Generate AS set path information\n")
6445 argv_find(argv
, argc
, "A.B.C.D", &idx
);
6446 char *prefix
= argv
[idx
]->arg
;
6447 char *mask
= argv
[idx
+ 1]->arg
;
6449 char prefix_str
[BUFSIZ
];
6450 int ret
= netmask_str2prefix_str(prefix
, mask
, prefix_str
);
6453 vty_out(vty
, "%% Inconsistent address and mask\n");
6454 return CMD_WARNING_CONFIG_FAILED
;
6457 return bgp_aggregate_unset(vty
, prefix_str
, AFI_IP
, bgp_node_safi(vty
));
6460 DEFUN (ipv6_aggregate_address
,
6461 ipv6_aggregate_address_cmd
,
6462 "aggregate-address X:X::X:X/M [summary-only]",
6463 "Configure BGP aggregate entries\n"
6464 "Aggregate prefix\n"
6465 "Filter more specific routes from updates\n")
6468 argv_find(argv
, argc
, "X:X::X:X/M", &idx
);
6469 char *prefix
= argv
[idx
]->arg
;
6470 int sum_only
= argv_find(argv
, argc
, "summary-only", &idx
)
6471 ? AGGREGATE_SUMMARY_ONLY
6473 return bgp_aggregate_set(vty
, prefix
, AFI_IP6
, SAFI_UNICAST
, sum_only
,
6477 DEFUN (no_ipv6_aggregate_address
,
6478 no_ipv6_aggregate_address_cmd
,
6479 "no aggregate-address X:X::X:X/M [summary-only]",
6481 "Configure BGP aggregate entries\n"
6482 "Aggregate prefix\n"
6483 "Filter more specific routes from updates\n")
6486 argv_find(argv
, argc
, "X:X::X:X/M", &idx
);
6487 char *prefix
= argv
[idx
]->arg
;
6488 return bgp_aggregate_unset(vty
, prefix
, AFI_IP6
, SAFI_UNICAST
);
6491 /* Redistribute route treatment. */
6492 void bgp_redistribute_add(struct bgp
*bgp
, struct prefix
*p
,
6493 const union g_addr
*nexthop
, ifindex_t ifindex
,
6494 enum nexthop_types_t nhtype
, uint32_t metric
,
6495 uint8_t type
, unsigned short instance
,
6498 struct bgp_path_info
*new;
6499 struct bgp_path_info
*bpi
;
6500 struct bgp_path_info rmap_path
;
6501 struct bgp_node
*bn
;
6503 struct attr
*new_attr
;
6506 struct bgp_redist
*red
;
6508 /* Make default attribute. */
6509 bgp_attr_default_set(&attr
, BGP_ORIGIN_INCOMPLETE
);
6512 case NEXTHOP_TYPE_IFINDEX
:
6514 case NEXTHOP_TYPE_IPV4
:
6515 case NEXTHOP_TYPE_IPV4_IFINDEX
:
6516 attr
.nexthop
= nexthop
->ipv4
;
6518 case NEXTHOP_TYPE_IPV6
:
6519 case NEXTHOP_TYPE_IPV6_IFINDEX
:
6520 attr
.mp_nexthop_global
= nexthop
->ipv6
;
6521 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
6523 case NEXTHOP_TYPE_BLACKHOLE
:
6524 switch (p
->family
) {
6526 attr
.nexthop
.s_addr
= INADDR_ANY
;
6529 memset(&attr
.mp_nexthop_global
, 0,
6530 sizeof(attr
.mp_nexthop_global
));
6531 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
6536 attr
.nh_ifindex
= ifindex
;
6539 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
6542 afi
= family2afi(p
->family
);
6544 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
6546 struct attr attr_new
;
6548 /* Copy attribute for modification. */
6549 bgp_attr_dup(&attr_new
, &attr
);
6551 if (red
->redist_metric_flag
)
6552 attr_new
.med
= red
->redist_metric
;
6554 /* Apply route-map. */
6555 if (red
->rmap
.name
) {
6556 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
6557 rmap_path
.peer
= bgp
->peer_self
;
6558 rmap_path
.attr
= &attr_new
;
6560 SET_FLAG(bgp
->peer_self
->rmap_type
,
6561 PEER_RMAP_TYPE_REDISTRIBUTE
);
6563 ret
= route_map_apply(red
->rmap
.map
, p
, RMAP_BGP
,
6566 bgp
->peer_self
->rmap_type
= 0;
6568 if (ret
== RMAP_DENYMATCH
) {
6569 /* Free uninterned attribute. */
6570 bgp_attr_flush(&attr_new
);
6572 /* Unintern original. */
6573 aspath_unintern(&attr
.aspath
);
6574 bgp_redistribute_delete(bgp
, p
, type
, instance
);
6579 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
))
6580 bgp_attr_add_gshut_community(&attr_new
);
6582 bn
= bgp_afi_node_get(bgp
->rib
[afi
][SAFI_UNICAST
], afi
,
6583 SAFI_UNICAST
, p
, NULL
);
6585 new_attr
= bgp_attr_intern(&attr_new
);
6587 for (bpi
= bgp_node_get_bgp_path_info(bn
); bpi
;
6589 if (bpi
->peer
== bgp
->peer_self
6590 && bpi
->sub_type
== BGP_ROUTE_REDISTRIBUTE
)
6594 /* Ensure the (source route) type is updated. */
6596 if (attrhash_cmp(bpi
->attr
, new_attr
)
6597 && !CHECK_FLAG(bpi
->flags
, BGP_PATH_REMOVED
)) {
6598 bgp_attr_unintern(&new_attr
);
6599 aspath_unintern(&attr
.aspath
);
6600 bgp_unlock_node(bn
);
6603 /* The attribute is changed. */
6604 bgp_path_info_set_flag(bn
, bpi
,
6605 BGP_PATH_ATTR_CHANGED
);
6607 /* Rewrite BGP route information. */
6608 if (CHECK_FLAG(bpi
->flags
, BGP_PATH_REMOVED
))
6609 bgp_path_info_restore(bn
, bpi
);
6611 bgp_aggregate_decrement(
6612 bgp
, p
, bpi
, afi
, SAFI_UNICAST
);
6613 bgp_attr_unintern(&bpi
->attr
);
6614 bpi
->attr
= new_attr
;
6615 bpi
->uptime
= bgp_clock();
6617 /* Process change. */
6618 bgp_aggregate_increment(bgp
, p
, bpi
, afi
,
6620 bgp_process(bgp
, bn
, afi
, SAFI_UNICAST
);
6621 bgp_unlock_node(bn
);
6622 aspath_unintern(&attr
.aspath
);
6624 if ((bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
6626 == BGP_INSTANCE_TYPE_DEFAULT
)) {
6628 vpn_leak_from_vrf_update(
6629 bgp_get_default(), bgp
, bpi
);
6635 new = info_make(type
, BGP_ROUTE_REDISTRIBUTE
, instance
,
6636 bgp
->peer_self
, new_attr
, bn
);
6637 SET_FLAG(new->flags
, BGP_PATH_VALID
);
6639 bgp_aggregate_increment(bgp
, p
, new, afi
, SAFI_UNICAST
);
6640 bgp_path_info_add(bn
, new);
6641 bgp_unlock_node(bn
);
6642 bgp_process(bgp
, bn
, afi
, SAFI_UNICAST
);
6644 if ((bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
6645 || (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
6647 vpn_leak_from_vrf_update(bgp_get_default(), bgp
, new);
6651 /* Unintern original. */
6652 aspath_unintern(&attr
.aspath
);
6655 void bgp_redistribute_delete(struct bgp
*bgp
, struct prefix
*p
, uint8_t type
,
6656 unsigned short instance
)
6659 struct bgp_node
*rn
;
6660 struct bgp_path_info
*pi
;
6661 struct bgp_redist
*red
;
6663 afi
= family2afi(p
->family
);
6665 red
= bgp_redist_lookup(bgp
, afi
, type
, instance
);
6667 rn
= bgp_afi_node_get(bgp
->rib
[afi
][SAFI_UNICAST
], afi
,
6668 SAFI_UNICAST
, p
, NULL
);
6670 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
6671 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== type
)
6675 if ((bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
6676 || (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
6678 vpn_leak_from_vrf_withdraw(bgp_get_default(),
6681 bgp_aggregate_decrement(bgp
, p
, pi
, afi
, SAFI_UNICAST
);
6682 bgp_path_info_delete(rn
, pi
);
6683 bgp_process(bgp
, rn
, afi
, SAFI_UNICAST
);
6685 bgp_unlock_node(rn
);
6689 /* Withdraw specified route type's route. */
6690 void bgp_redistribute_withdraw(struct bgp
*bgp
, afi_t afi
, int type
,
6691 unsigned short instance
)
6693 struct bgp_node
*rn
;
6694 struct bgp_path_info
*pi
;
6695 struct bgp_table
*table
;
6697 table
= bgp
->rib
[afi
][SAFI_UNICAST
];
6699 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
6700 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
)
6701 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== type
6702 && pi
->instance
== instance
)
6706 if ((bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
6707 || (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)) {
6709 vpn_leak_from_vrf_withdraw(bgp_get_default(),
6712 bgp_aggregate_decrement(bgp
, &rn
->p
, pi
, afi
,
6714 bgp_path_info_delete(rn
, pi
);
6715 bgp_process(bgp
, rn
, afi
, SAFI_UNICAST
);
6720 /* Static function to display route. */
6721 static void route_vty_out_route(struct prefix
*p
, struct vty
*vty
,
6728 if (p
->family
== AF_INET
) {
6732 inet_ntop(p
->family
, &p
->u
.prefix
, buf
, BUFSIZ
),
6735 json_object_string_add(json
, "prefix",
6736 inet_ntop(p
->family
,
6739 json_object_int_add(json
, "prefixLen", p
->prefixlen
);
6740 prefix2str(p
, buf2
, PREFIX_STRLEN
);
6741 json_object_string_add(json
, "network", buf2
);
6743 } else if (p
->family
== AF_ETHERNET
) {
6744 prefix2str(p
, buf
, PREFIX_STRLEN
);
6745 len
= vty_out(vty
, "%s", buf
);
6746 } else if (p
->family
== AF_EVPN
) {
6750 bgp_evpn_route2str((struct prefix_evpn
*)p
, buf
,
6753 bgp_evpn_route2json((struct prefix_evpn
*)p
, json
);
6754 } else if (p
->family
== AF_FLOWSPEC
) {
6755 route_vty_out_flowspec(vty
, p
, NULL
,
6757 NLRI_STRING_FORMAT_JSON_SIMPLE
:
6758 NLRI_STRING_FORMAT_MIN
, json
);
6763 inet_ntop(p
->family
, &p
->u
.prefix
, buf
, BUFSIZ
),
6766 json_object_string_add(json
, "prefix",
6767 inet_ntop(p
->family
,
6770 json_object_int_add(json
, "prefixLen", p
->prefixlen
);
6771 prefix2str(p
, buf2
, PREFIX_STRLEN
);
6772 json_object_string_add(json
, "network", buf2
);
6779 vty_out(vty
, "\n%*s", 20, " ");
6781 vty_out(vty
, "%*s", len
, " ");
6785 enum bgp_display_type
{
6789 /* Print the short form route status for a bgp_path_info */
6790 static void route_vty_short_status_out(struct vty
*vty
,
6791 struct bgp_path_info
*path
,
6792 json_object
*json_path
)
6796 /* Route status display. */
6797 if (CHECK_FLAG(path
->flags
, BGP_PATH_REMOVED
))
6798 json_object_boolean_true_add(json_path
, "removed");
6800 if (CHECK_FLAG(path
->flags
, BGP_PATH_STALE
))
6801 json_object_boolean_true_add(json_path
, "stale");
6803 if (path
->extra
&& path
->extra
->suppress
)
6804 json_object_boolean_true_add(json_path
, "suppressed");
6806 if (CHECK_FLAG(path
->flags
, BGP_PATH_VALID
)
6807 && !CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
))
6808 json_object_boolean_true_add(json_path
, "valid");
6811 if (CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
))
6812 json_object_boolean_true_add(json_path
, "history");
6814 if (CHECK_FLAG(path
->flags
, BGP_PATH_DAMPED
))
6815 json_object_boolean_true_add(json_path
, "damped");
6817 if (CHECK_FLAG(path
->flags
, BGP_PATH_SELECTED
))
6818 json_object_boolean_true_add(json_path
, "bestpath");
6820 if (CHECK_FLAG(path
->flags
, BGP_PATH_MULTIPATH
))
6821 json_object_boolean_true_add(json_path
, "multipath");
6823 /* Internal route. */
6824 if ((path
->peer
->as
)
6825 && (path
->peer
->as
== path
->peer
->local_as
))
6826 json_object_string_add(json_path
, "pathFrom",
6829 json_object_string_add(json_path
, "pathFrom",
6835 /* Route status display. */
6836 if (CHECK_FLAG(path
->flags
, BGP_PATH_REMOVED
))
6838 else if (CHECK_FLAG(path
->flags
, BGP_PATH_STALE
))
6840 else if (path
->extra
&& path
->extra
->suppress
)
6842 else if (CHECK_FLAG(path
->flags
, BGP_PATH_VALID
)
6843 && !CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
))
6849 if (CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
))
6851 else if (CHECK_FLAG(path
->flags
, BGP_PATH_DAMPED
))
6853 else if (CHECK_FLAG(path
->flags
, BGP_PATH_SELECTED
))
6855 else if (CHECK_FLAG(path
->flags
, BGP_PATH_MULTIPATH
))
6860 /* Internal route. */
6861 if (path
->peer
&& (path
->peer
->as
)
6862 && (path
->peer
->as
== path
->peer
->local_as
))
6868 /* called from terminal list command */
6869 void route_vty_out(struct vty
*vty
, struct prefix
*p
,
6870 struct bgp_path_info
*path
, int display
, safi_t safi
,
6871 json_object
*json_paths
)
6874 json_object
*json_path
= NULL
;
6875 json_object
*json_nexthops
= NULL
;
6876 json_object
*json_nexthop_global
= NULL
;
6877 json_object
*json_nexthop_ll
= NULL
;
6878 char vrf_id_str
[VRF_NAMSIZ
] = {0};
6880 CHECK_FLAG(path
->flags
, BGP_PATH_ANNC_NH_SELF
) ? true : false;
6881 bool nexthop_othervrf
= false;
6882 vrf_id_t nexthop_vrfid
= VRF_DEFAULT
;
6883 const char *nexthop_vrfname
= VRF_DEFAULT_NAME
;
6886 json_path
= json_object_new_object();
6888 /* short status lead text */
6889 route_vty_short_status_out(vty
, path
, json_path
);
6892 /* print prefix and mask */
6894 route_vty_out_route(p
, vty
, json_path
);
6896 vty_out(vty
, "%*s", 17, " ");
6898 route_vty_out_route(p
, vty
, json_path
);
6901 /* Print attribute */
6905 json_object_array_add(json_paths
, json_path
);
6913 * If vrf id of nexthop is different from that of prefix,
6914 * set up printable string to append
6916 if (path
->extra
&& path
->extra
->bgp_orig
) {
6917 const char *self
= "";
6922 nexthop_othervrf
= true;
6923 nexthop_vrfid
= path
->extra
->bgp_orig
->vrf_id
;
6925 if (path
->extra
->bgp_orig
->vrf_id
== VRF_UNKNOWN
)
6926 snprintf(vrf_id_str
, sizeof(vrf_id_str
),
6927 "@%s%s", VRFID_NONE_STR
, self
);
6929 snprintf(vrf_id_str
, sizeof(vrf_id_str
), "@%u%s",
6930 path
->extra
->bgp_orig
->vrf_id
, self
);
6932 if (path
->extra
->bgp_orig
->inst_type
6933 != BGP_INSTANCE_TYPE_DEFAULT
)
6935 nexthop_vrfname
= path
->extra
->bgp_orig
->name
;
6937 const char *self
= "";
6942 snprintf(vrf_id_str
, sizeof(vrf_id_str
), "%s", self
);
6946 * For ENCAP and EVPN routes, nexthop address family is not
6947 * neccessarily the same as the prefix address family.
6948 * Both SAFI_MPLS_VPN and SAFI_ENCAP use the MP nexthop field
6949 * EVPN routes are also exchanged with a MP nexthop. Currently,
6951 * is only IPv4, the value will be present in either
6953 * attr->mp_nexthop_global_in
6955 if ((safi
== SAFI_ENCAP
) || (safi
== SAFI_MPLS_VPN
)) {
6958 int af
= NEXTHOP_FAMILY(attr
->mp_nexthop_len
);
6962 sprintf(nexthop
, "%s",
6963 inet_ntop(af
, &attr
->mp_nexthop_global_in
, buf
,
6967 sprintf(nexthop
, "%s",
6968 inet_ntop(af
, &attr
->mp_nexthop_global
, buf
,
6972 sprintf(nexthop
, "?");
6977 json_nexthop_global
= json_object_new_object();
6979 json_object_string_add(json_nexthop_global
, "afi",
6980 (af
== AF_INET
) ? "ip" : "ipv6");
6981 json_object_string_add(json_nexthop_global
,
6982 (af
== AF_INET
) ? "ip" : "ipv6",
6984 json_object_boolean_true_add(json_nexthop_global
,
6987 vty_out(vty
, "%s%s", nexthop
, vrf_id_str
);
6988 } else if (safi
== SAFI_EVPN
) {
6990 json_nexthop_global
= json_object_new_object();
6992 json_object_string_add(json_nexthop_global
, "ip",
6993 inet_ntoa(attr
->nexthop
));
6994 json_object_string_add(json_nexthop_global
, "afi",
6996 json_object_boolean_true_add(json_nexthop_global
,
6999 vty_out(vty
, "%-16s%s", inet_ntoa(attr
->nexthop
),
7001 } else if (safi
== SAFI_FLOWSPEC
) {
7002 if (attr
->nexthop
.s_addr
!= 0) {
7004 json_nexthop_global
= json_object_new_object();
7005 json_object_string_add(
7006 json_nexthop_global
, "ip",
7007 inet_ntoa(attr
->nexthop
));
7008 json_object_string_add(json_nexthop_global
,
7010 json_object_boolean_true_add(
7011 json_nexthop_global
,
7014 vty_out(vty
, "%-16s", inet_ntoa(attr
->nexthop
));
7017 } else if (p
->family
== AF_INET
&& !BGP_ATTR_NEXTHOP_AFI_IP6(attr
)) {
7019 json_nexthop_global
= json_object_new_object();
7021 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_EVPN
))
7022 json_object_string_add(
7023 json_nexthop_global
, "ip",
7024 inet_ntoa(attr
->mp_nexthop_global_in
));
7026 json_object_string_add(
7027 json_nexthop_global
, "ip",
7028 inet_ntoa(attr
->nexthop
));
7030 json_object_string_add(json_nexthop_global
, "afi",
7032 json_object_boolean_true_add(json_nexthop_global
,
7037 snprintf(buf
, sizeof(buf
), "%s%s",
7038 inet_ntoa(attr
->nexthop
), vrf_id_str
);
7039 vty_out(vty
, "%-16s", buf
);
7044 else if (p
->family
== AF_INET6
|| BGP_ATTR_NEXTHOP_AFI_IP6(attr
)) {
7049 json_nexthop_global
= json_object_new_object();
7050 json_object_string_add(
7051 json_nexthop_global
, "ip",
7052 inet_ntop(AF_INET6
, &attr
->mp_nexthop_global
,
7054 json_object_string_add(json_nexthop_global
, "afi",
7056 json_object_string_add(json_nexthop_global
, "scope",
7059 /* We display both LL & GL if both have been
7061 if ((attr
->mp_nexthop_len
== 32)
7062 || (path
->peer
->conf_if
)) {
7063 json_nexthop_ll
= json_object_new_object();
7064 json_object_string_add(
7065 json_nexthop_ll
, "ip",
7067 &attr
->mp_nexthop_local
, buf
,
7069 json_object_string_add(json_nexthop_ll
, "afi",
7071 json_object_string_add(json_nexthop_ll
, "scope",
7074 if ((IPV6_ADDR_CMP(&attr
->mp_nexthop_global
,
7075 &attr
->mp_nexthop_local
)
7077 && !attr
->mp_nexthop_prefer_global
)
7078 json_object_boolean_true_add(
7079 json_nexthop_ll
, "used");
7081 json_object_boolean_true_add(
7082 json_nexthop_global
, "used");
7084 json_object_boolean_true_add(
7085 json_nexthop_global
, "used");
7087 /* Display LL if LL/Global both in table unless
7088 * prefer-global is set */
7089 if (((attr
->mp_nexthop_len
== 32)
7090 && !attr
->mp_nexthop_prefer_global
)
7091 || (path
->peer
->conf_if
)) {
7092 if (path
->peer
->conf_if
) {
7093 len
= vty_out(vty
, "%s",
7094 path
->peer
->conf_if
);
7095 len
= 16 - len
; /* len of IPv6
7101 vty_out(vty
, "\n%*s", 36, " ");
7103 vty_out(vty
, "%*s", len
, " ");
7109 &attr
->mp_nexthop_local
,
7115 vty_out(vty
, "\n%*s", 36, " ");
7117 vty_out(vty
, "%*s", len
, " ");
7123 &attr
->mp_nexthop_global
, buf
,
7129 vty_out(vty
, "\n%*s", 36, " ");
7131 vty_out(vty
, "%*s", len
, " ");
7137 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
))
7141 * Adding "metric" field to match with corresponding
7142 * CLI. "med" will be deprecated in future.
7144 json_object_int_add(json_path
, "med", attr
->med
);
7145 json_object_int_add(json_path
, "metric", attr
->med
);
7147 vty_out(vty
, "%10u", attr
->med
);
7148 else if (!json_paths
)
7152 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
))
7156 * Adding "locPrf" field to match with corresponding
7157 * CLI. "localPref" will be deprecated in future.
7159 json_object_int_add(json_path
, "localpref",
7161 json_object_int_add(json_path
, "locPrf",
7164 vty_out(vty
, "%7u", attr
->local_pref
);
7165 else if (!json_paths
)
7169 json_object_int_add(json_path
, "weight", attr
->weight
);
7171 vty_out(vty
, "%7u ", attr
->weight
);
7175 json_object_string_add(
7176 json_path
, "peerId",
7177 sockunion2str(&path
->peer
->su
, buf
, SU_ADDRSTRLEN
));
7185 * Adding "path" field to match with corresponding
7186 * CLI. "aspath" will be deprecated in future.
7188 json_object_string_add(json_path
, "aspath",
7190 json_object_string_add(json_path
, "path",
7193 aspath_print_vty(vty
, "%s", attr
->aspath
, " ");
7198 json_object_string_add(json_path
, "origin",
7199 bgp_origin_long_str
[attr
->origin
]);
7201 vty_out(vty
, "%s", bgp_origin_str
[attr
->origin
]);
7205 json_object_boolean_true_add(json_path
,
7206 "announceNexthopSelf");
7207 if (nexthop_othervrf
) {
7208 json_object_string_add(json_path
, "nhVrfName",
7211 json_object_int_add(json_path
, "nhVrfId",
7212 ((nexthop_vrfid
== VRF_UNKNOWN
)
7214 : (int)nexthop_vrfid
));
7219 if (json_nexthop_global
|| json_nexthop_ll
) {
7220 json_nexthops
= json_object_new_array();
7222 if (json_nexthop_global
)
7223 json_object_array_add(json_nexthops
,
7224 json_nexthop_global
);
7226 if (json_nexthop_ll
)
7227 json_object_array_add(json_nexthops
,
7230 json_object_object_add(json_path
, "nexthops",
7234 json_object_array_add(json_paths
, json_path
);
7238 /* prints an additional line, indented, with VNC info, if
7240 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
))
7241 rfapi_vty_out_vncinfo(vty
, p
, path
, safi
);
7246 /* called from terminal list command */
7247 void route_vty_out_tmp(struct vty
*vty
, struct prefix
*p
, struct attr
*attr
,
7248 safi_t safi
, bool use_json
, json_object
*json_ar
)
7250 json_object
*json_status
= NULL
;
7251 json_object
*json_net
= NULL
;
7254 /* Route status display. */
7256 json_status
= json_object_new_object();
7257 json_net
= json_object_new_object();
7264 /* print prefix and mask */
7266 json_object_string_add(
7267 json_net
, "addrPrefix",
7268 inet_ntop(p
->family
, &p
->u
.prefix
, buff
, BUFSIZ
));
7269 json_object_int_add(json_net
, "prefixLen", p
->prefixlen
);
7270 prefix2str(p
, buf2
, PREFIX_STRLEN
);
7271 json_object_string_add(json_net
, "network", buf2
);
7273 route_vty_out_route(p
, vty
, NULL
);
7275 /* Print attribute */
7278 if (p
->family
== AF_INET
7279 && (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7280 || safi
== SAFI_EVPN
7281 || !BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
7282 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7283 || safi
== SAFI_EVPN
)
7284 json_object_string_add(
7285 json_net
, "nextHop",
7287 attr
->mp_nexthop_global_in
));
7289 json_object_string_add(
7290 json_net
, "nextHop",
7291 inet_ntoa(attr
->nexthop
));
7292 } else if (p
->family
== AF_INET6
7293 || BGP_ATTR_NEXTHOP_AFI_IP6(attr
)) {
7296 json_object_string_add(
7297 json_net
, "nextHopGlobal",
7299 &attr
->mp_nexthop_global
, buf
,
7304 & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
))
7305 json_object_int_add(json_net
, "metric",
7308 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)) {
7311 * Adding "locPrf" field to match with
7312 * corresponding CLI. "localPref" will be
7313 * deprecated in future.
7315 json_object_int_add(json_net
, "localPref",
7317 json_object_int_add(json_net
, "locPrf",
7321 json_object_int_add(json_net
, "weight", attr
->weight
);
7327 * Adding "path" field to match with
7328 * corresponding CLI. "localPref" will be
7329 * deprecated in future.
7331 json_object_string_add(json_net
, "asPath",
7333 json_object_string_add(json_net
, "path",
7338 json_object_string_add(json_net
, "bgpOriginCode",
7339 bgp_origin_str
[attr
->origin
]);
7341 if (p
->family
== AF_INET
7342 && (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7343 || safi
== SAFI_EVPN
7344 || !BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
7345 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7346 || safi
== SAFI_EVPN
)
7347 vty_out(vty
, "%-16s",
7349 attr
->mp_nexthop_global_in
));
7351 vty_out(vty
, "%-16s",
7352 inet_ntoa(attr
->nexthop
));
7353 } else if (p
->family
== AF_INET6
7354 || BGP_ATTR_NEXTHOP_AFI_IP6(attr
)) {
7361 &attr
->mp_nexthop_global
, buf
,
7365 vty_out(vty
, "\n%*s", 36, " ");
7367 vty_out(vty
, "%*s", len
, " ");
7370 & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
))
7371 vty_out(vty
, "%10u", attr
->med
);
7375 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
))
7376 vty_out(vty
, "%7u", attr
->local_pref
);
7380 vty_out(vty
, "%7u ", attr
->weight
);
7384 aspath_print_vty(vty
, "%s", attr
->aspath
, " ");
7387 vty_out(vty
, "%s", bgp_origin_str
[attr
->origin
]);
7391 json_object_boolean_true_add(json_status
, "*");
7392 json_object_boolean_true_add(json_status
, ">");
7393 json_object_object_add(json_net
, "appliedStatusSymbols",
7395 char buf_cut
[BUFSIZ
];
7396 json_object_object_add(
7398 inet_ntop(p
->family
, &p
->u
.prefix
, buf_cut
, BUFSIZ
),
7404 void route_vty_out_tag(struct vty
*vty
, struct prefix
*p
,
7405 struct bgp_path_info
*path
, int display
, safi_t safi
,
7408 json_object
*json_out
= NULL
;
7410 mpls_label_t label
= MPLS_INVALID_LABEL
;
7416 json_out
= json_object_new_object();
7418 /* short status lead text */
7419 route_vty_short_status_out(vty
, path
, json_out
);
7421 /* print prefix and mask */
7424 route_vty_out_route(p
, vty
, NULL
);
7426 vty_out(vty
, "%*s", 17, " ");
7429 /* Print attribute */
7432 if (((p
->family
== AF_INET
)
7433 && ((safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
)))
7434 || (safi
== SAFI_EVPN
&& !BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
7435 || (!BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
7436 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7437 || safi
== SAFI_EVPN
) {
7439 json_object_string_add(
7440 json_out
, "mpNexthopGlobalIn",
7442 attr
->mp_nexthop_global_in
));
7444 vty_out(vty
, "%-16s",
7446 attr
->mp_nexthop_global_in
));
7449 json_object_string_add(
7450 json_out
, "nexthop",
7451 inet_ntoa(attr
->nexthop
));
7453 vty_out(vty
, "%-16s",
7454 inet_ntoa(attr
->nexthop
));
7456 } else if (((p
->family
== AF_INET6
)
7457 && ((safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
)))
7458 || (safi
== SAFI_EVPN
7459 && BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
7460 || (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
7464 if (attr
->mp_nexthop_len
7465 == BGP_ATTR_NHLEN_IPV6_GLOBAL
) {
7467 json_object_string_add(
7468 json_out
, "mpNexthopGlobalIn",
7471 &attr
->mp_nexthop_global
,
7472 buf_a
, sizeof(buf_a
)));
7477 &attr
->mp_nexthop_global
,
7478 buf_a
, sizeof(buf_a
)));
7479 } else if (attr
->mp_nexthop_len
7480 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
7483 &attr
->mp_nexthop_global
,
7484 buf_a
, sizeof(buf_a
));
7486 &attr
->mp_nexthop_local
,
7487 buf_b
, sizeof(buf_b
));
7488 sprintf(buf_c
, "%s(%s)", buf_a
, buf_b
);
7489 json_object_string_add(
7491 "mpNexthopGlobalLocal", buf_c
);
7493 vty_out(vty
, "%s(%s)",
7496 &attr
->mp_nexthop_global
,
7497 buf_a
, sizeof(buf_a
)),
7500 &attr
->mp_nexthop_local
,
7501 buf_b
, sizeof(buf_b
)));
7506 label
= decode_label(&path
->extra
->label
[0]);
7508 if (bgp_is_valid_label(&label
)) {
7510 json_object_int_add(json_out
, "notag", label
);
7511 json_object_array_add(json
, json_out
);
7513 vty_out(vty
, "notag/%d", label
);
7519 void route_vty_out_overlay(struct vty
*vty
, struct prefix
*p
,
7520 struct bgp_path_info
*path
, int display
,
7521 json_object
*json_paths
)
7525 json_object
*json_path
= NULL
;
7528 json_path
= json_object_new_object();
7533 /* short status lead text */
7534 route_vty_short_status_out(vty
, path
, json_path
);
7536 /* print prefix and mask */
7538 route_vty_out_route(p
, vty
, NULL
);
7540 vty_out(vty
, "%*s", 17, " ");
7542 /* Print attribute */
7546 int af
= NEXTHOP_FAMILY(attr
->mp_nexthop_len
);
7550 vty_out(vty
, "%-16s",
7551 inet_ntop(af
, &attr
->mp_nexthop_global_in
, buf
,
7555 vty_out(vty
, "%s(%s)",
7556 inet_ntop(af
, &attr
->mp_nexthop_global
, buf
,
7558 inet_ntop(af
, &attr
->mp_nexthop_local
, buf1
,
7565 char *str
= esi2str(&(attr
->evpn_overlay
.eth_s_id
));
7567 vty_out(vty
, "%s", str
);
7568 XFREE(MTYPE_TMP
, str
);
7570 if (is_evpn_prefix_ipaddr_v4((struct prefix_evpn
*)p
)) {
7572 inet_ntoa(attr
->evpn_overlay
.gw_ip
.ipv4
));
7573 } else if (is_evpn_prefix_ipaddr_v6((struct prefix_evpn
*)p
)) {
7576 &(attr
->evpn_overlay
.gw_ip
.ipv6
), buf
,
7579 if (attr
->ecommunity
) {
7581 struct ecommunity_val
*routermac
= ecommunity_lookup(
7582 attr
->ecommunity
, ECOMMUNITY_ENCODE_EVPN
,
7583 ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC
);
7585 mac
= ecom_mac2str((char *)routermac
->val
);
7587 vty_out(vty
, "/%s", (char *)mac
);
7588 XFREE(MTYPE_TMP
, mac
);
7596 /* dampening route */
7597 static void damp_route_vty_out(struct vty
*vty
, struct prefix
*p
,
7598 struct bgp_path_info
*path
, int display
,
7599 safi_t safi
, bool use_json
, json_object
*json
)
7603 char timebuf
[BGP_UPTIME_LEN
];
7605 /* short status lead text */
7606 route_vty_short_status_out(vty
, path
, json
);
7608 /* print prefix and mask */
7611 route_vty_out_route(p
, vty
, NULL
);
7613 vty_out(vty
, "%*s", 17, " ");
7616 len
= vty_out(vty
, "%s", path
->peer
->host
);
7620 vty_out(vty
, "\n%*s", 34, " ");
7623 json_object_int_add(json
, "peerHost", len
);
7625 vty_out(vty
, "%*s", len
, " ");
7629 bgp_damp_reuse_time_vty(vty
, path
, timebuf
, BGP_UPTIME_LEN
,
7633 bgp_damp_reuse_time_vty(vty
, path
, timebuf
,
7634 BGP_UPTIME_LEN
, use_json
,
7637 /* Print attribute */
7643 json_object_string_add(json
, "asPath",
7646 aspath_print_vty(vty
, "%s", attr
->aspath
, " ");
7651 json_object_string_add(json
, "origin",
7652 bgp_origin_str
[attr
->origin
]);
7654 vty_out(vty
, "%s", bgp_origin_str
[attr
->origin
]);
7661 static void flap_route_vty_out(struct vty
*vty
, struct prefix
*p
,
7662 struct bgp_path_info
*path
, int display
,
7663 safi_t safi
, bool use_json
, json_object
*json
)
7666 struct bgp_damp_info
*bdi
;
7667 char timebuf
[BGP_UPTIME_LEN
];
7673 bdi
= path
->extra
->damp_info
;
7675 /* short status lead text */
7676 route_vty_short_status_out(vty
, path
, json
);
7678 /* print prefix and mask */
7681 route_vty_out_route(p
, vty
, NULL
);
7683 vty_out(vty
, "%*s", 17, " ");
7686 len
= vty_out(vty
, "%s", path
->peer
->host
);
7690 vty_out(vty
, "\n%*s", 33, " ");
7693 json_object_int_add(json
, "peerHost", len
);
7695 vty_out(vty
, "%*s", len
, " ");
7698 len
= vty_out(vty
, "%d", bdi
->flap
);
7705 json_object_int_add(json
, "bdiFlap", len
);
7707 vty_out(vty
, "%*s", len
, " ");
7711 peer_uptime(bdi
->start_time
, timebuf
, BGP_UPTIME_LEN
, use_json
,
7714 vty_out(vty
, "%s ", peer_uptime(bdi
->start_time
, timebuf
,
7715 BGP_UPTIME_LEN
, 0, NULL
));
7717 if (CHECK_FLAG(path
->flags
, BGP_PATH_DAMPED
)
7718 && !CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
)) {
7720 bgp_damp_reuse_time_vty(vty
, path
, timebuf
,
7721 BGP_UPTIME_LEN
, use_json
, json
);
7724 bgp_damp_reuse_time_vty(vty
, path
, timebuf
,
7729 vty_out(vty
, "%*s ", 8, " ");
7732 /* Print attribute */
7738 json_object_string_add(json
, "asPath",
7741 aspath_print_vty(vty
, "%s", attr
->aspath
, " ");
7746 json_object_string_add(json
, "origin",
7747 bgp_origin_str
[attr
->origin
]);
7749 vty_out(vty
, "%s", bgp_origin_str
[attr
->origin
]);
7755 static void route_vty_out_advertised_to(struct vty
*vty
, struct peer
*peer
,
7756 int *first
, const char *header
,
7757 json_object
*json_adv_to
)
7759 char buf1
[INET6_ADDRSTRLEN
];
7760 json_object
*json_peer
= NULL
;
7763 /* 'advertised-to' is a dictionary of peers we have advertised
7765 * prefix too. The key is the peer's IP or swpX, the value is
7767 * hostname if we know it and "" if not.
7769 json_peer
= json_object_new_object();
7772 json_object_string_add(json_peer
, "hostname",
7776 json_object_object_add(json_adv_to
, peer
->conf_if
,
7779 json_object_object_add(
7781 sockunion2str(&peer
->su
, buf1
, SU_ADDRSTRLEN
),
7785 vty_out(vty
, "%s", header
);
7790 && bgp_flag_check(peer
->bgp
, BGP_FLAG_SHOW_HOSTNAME
)) {
7792 vty_out(vty
, " %s(%s)", peer
->hostname
,
7795 vty_out(vty
, " %s(%s)", peer
->hostname
,
7796 sockunion2str(&peer
->su
, buf1
,
7800 vty_out(vty
, " %s", peer
->conf_if
);
7803 sockunion2str(&peer
->su
, buf1
,
7809 static void route_vty_out_tx_ids(struct vty
*vty
,
7810 struct bgp_addpath_info_data
*d
)
7814 for (i
= 0; i
< BGP_ADDPATH_MAX
; i
++) {
7815 vty_out(vty
, "TX-%s %u%s", bgp_addpath_names(i
)->human_name
,
7816 d
->addpath_tx_id
[i
],
7817 i
< BGP_ADDPATH_MAX
- 1 ? " " : "\n");
7821 void route_vty_out_detail(struct vty
*vty
, struct bgp
*bgp
, struct prefix
*p
,
7822 struct bgp_path_info
*path
, afi_t afi
, safi_t safi
,
7823 json_object
*json_paths
)
7825 char buf
[INET6_ADDRSTRLEN
];
7827 char buf2
[EVPN_ROUTE_STRLEN
];
7829 int sockunion_vty_out(struct vty
*, union sockunion
*);
7831 json_object
*json_bestpath
= NULL
;
7832 json_object
*json_cluster_list
= NULL
;
7833 json_object
*json_cluster_list_list
= NULL
;
7834 json_object
*json_ext_community
= NULL
;
7835 json_object
*json_last_update
= NULL
;
7836 json_object
*json_pmsi
= NULL
;
7837 json_object
*json_nexthop_global
= NULL
;
7838 json_object
*json_nexthop_ll
= NULL
;
7839 json_object
*json_nexthops
= NULL
;
7840 json_object
*json_path
= NULL
;
7841 json_object
*json_peer
= NULL
;
7842 json_object
*json_string
= NULL
;
7843 json_object
*json_adv_to
= NULL
;
7845 struct listnode
*node
, *nnode
;
7847 int addpath_capable
;
7849 unsigned int first_as
;
7851 CHECK_FLAG(path
->flags
, BGP_PATH_ANNC_NH_SELF
) ? true : false;
7855 json_path
= json_object_new_object();
7856 json_peer
= json_object_new_object();
7857 json_nexthop_global
= json_object_new_object();
7860 if (!json_paths
&& safi
== SAFI_EVPN
) {
7863 bgp_evpn_route2str((struct prefix_evpn
*)p
, buf2
, sizeof(buf2
));
7864 vty_out(vty
, " Route %s", buf2
);
7866 if (path
->extra
&& path
->extra
->num_labels
) {
7867 bgp_evpn_label2str(path
->extra
->label
,
7868 path
->extra
->num_labels
, tag_buf
,
7870 vty_out(vty
, " VNI %s", tag_buf
);
7873 if (path
->extra
&& path
->extra
->parent
) {
7874 struct bgp_path_info
*parent_ri
;
7875 struct bgp_node
*rn
, *prn
;
7877 parent_ri
= (struct bgp_path_info
*)path
->extra
->parent
;
7878 rn
= parent_ri
->net
;
7879 if (rn
&& rn
->prn
) {
7881 vty_out(vty
, " Imported from %s:%s\n",
7883 (struct prefix_rd
*)&prn
->p
,
7884 buf1
, sizeof(buf1
)),
7893 /* Line1 display AS-path, Aggregator */
7896 if (!attr
->aspath
->json
)
7897 aspath_str_update(attr
->aspath
, true);
7898 json_object_lock(attr
->aspath
->json
);
7899 json_object_object_add(json_path
, "aspath",
7900 attr
->aspath
->json
);
7902 if (attr
->aspath
->segments
)
7903 aspath_print_vty(vty
, " %s",
7906 vty_out(vty
, " Local");
7910 if (CHECK_FLAG(path
->flags
, BGP_PATH_REMOVED
)) {
7912 json_object_boolean_true_add(json_path
,
7915 vty_out(vty
, ", (removed)");
7918 if (CHECK_FLAG(path
->flags
, BGP_PATH_STALE
)) {
7920 json_object_boolean_true_add(json_path
,
7923 vty_out(vty
, ", (stale)");
7926 if (CHECK_FLAG(attr
->flag
,
7927 ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
))) {
7929 json_object_int_add(json_path
, "aggregatorAs",
7930 attr
->aggregator_as
);
7931 json_object_string_add(
7932 json_path
, "aggregatorId",
7933 inet_ntoa(attr
->aggregator_addr
));
7935 vty_out(vty
, ", (aggregated by %u %s)",
7936 attr
->aggregator_as
,
7937 inet_ntoa(attr
->aggregator_addr
));
7941 if (CHECK_FLAG(path
->peer
->af_flags
[afi
][safi
],
7942 PEER_FLAG_REFLECTOR_CLIENT
)) {
7944 json_object_boolean_true_add(
7945 json_path
, "rxedFromRrClient");
7947 vty_out(vty
, ", (Received from a RR-client)");
7950 if (CHECK_FLAG(path
->peer
->af_flags
[afi
][safi
],
7951 PEER_FLAG_RSERVER_CLIENT
)) {
7953 json_object_boolean_true_add(
7954 json_path
, "rxedFromRsClient");
7956 vty_out(vty
, ", (Received from a RS-client)");
7959 if (CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
)) {
7961 json_object_boolean_true_add(
7962 json_path
, "dampeningHistoryEntry");
7964 vty_out(vty
, ", (history entry)");
7965 } else if (CHECK_FLAG(path
->flags
, BGP_PATH_DAMPED
)) {
7967 json_object_boolean_true_add(
7968 json_path
, "dampeningSuppressed");
7970 vty_out(vty
, ", (suppressed due to dampening)");
7976 /* Line2 display Next-hop, Neighbor, Router-id */
7977 /* Display the nexthop */
7978 if ((p
->family
== AF_INET
|| p
->family
== AF_ETHERNET
7979 || p
->family
== AF_EVPN
)
7980 && (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7981 || safi
== SAFI_EVPN
7982 || !BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
7983 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
7984 || safi
== SAFI_EVPN
) {
7986 json_object_string_add(
7987 json_nexthop_global
, "ip",
7989 attr
->mp_nexthop_global_in
));
7993 attr
->mp_nexthop_global_in
));
7996 json_object_string_add(
7997 json_nexthop_global
, "ip",
7998 inet_ntoa(attr
->nexthop
));
8001 inet_ntoa(attr
->nexthop
));
8005 json_object_string_add(json_nexthop_global
,
8009 json_object_string_add(
8010 json_nexthop_global
, "ip",
8012 &attr
->mp_nexthop_global
, buf
,
8014 json_object_string_add(json_nexthop_global
,
8016 json_object_string_add(json_nexthop_global
,
8021 &attr
->mp_nexthop_global
, buf
,
8026 /* Display the IGP cost or 'inaccessible' */
8027 if (!CHECK_FLAG(path
->flags
, BGP_PATH_VALID
)) {
8029 json_object_boolean_false_add(
8030 json_nexthop_global
, "accessible");
8032 vty_out(vty
, " (inaccessible)");
8034 if (path
->extra
&& path
->extra
->igpmetric
) {
8036 json_object_int_add(
8037 json_nexthop_global
, "metric",
8038 path
->extra
->igpmetric
);
8040 vty_out(vty
, " (metric %u)",
8041 path
->extra
->igpmetric
);
8044 /* IGP cost is 0, display this only for json */
8047 json_object_int_add(json_nexthop_global
,
8052 json_object_boolean_true_add(
8053 json_nexthop_global
, "accessible");
8056 /* Display peer "from" output */
8057 /* This path was originated locally */
8058 if (path
->peer
== bgp
->peer_self
) {
8060 if (safi
== SAFI_EVPN
8061 || (p
->family
== AF_INET
8062 && !BGP_ATTR_NEXTHOP_AFI_IP6(attr
))) {
8064 json_object_string_add(
8065 json_peer
, "peerId", "0.0.0.0");
8067 vty_out(vty
, " from 0.0.0.0 ");
8070 json_object_string_add(json_peer
,
8073 vty_out(vty
, " from :: ");
8077 json_object_string_add(
8078 json_peer
, "routerId",
8079 inet_ntoa(bgp
->router_id
));
8081 vty_out(vty
, "(%s)", inet_ntoa(bgp
->router_id
));
8084 /* We RXed this path from one of our peers */
8088 json_object_string_add(
8089 json_peer
, "peerId",
8090 sockunion2str(&path
->peer
->su
, buf
,
8092 json_object_string_add(
8093 json_peer
, "routerId",
8095 &path
->peer
->remote_id
, buf1
,
8098 if (path
->peer
->hostname
)
8099 json_object_string_add(
8100 json_peer
, "hostname",
8101 path
->peer
->hostname
);
8103 if (path
->peer
->domainname
)
8104 json_object_string_add(
8105 json_peer
, "domainname",
8106 path
->peer
->domainname
);
8108 if (path
->peer
->conf_if
)
8109 json_object_string_add(
8110 json_peer
, "interface",
8111 path
->peer
->conf_if
);
8113 if (path
->peer
->conf_if
) {
8114 if (path
->peer
->hostname
8117 BGP_FLAG_SHOW_HOSTNAME
))
8118 vty_out(vty
, " from %s(%s)",
8119 path
->peer
->hostname
,
8120 path
->peer
->conf_if
);
8122 vty_out(vty
, " from %s",
8123 path
->peer
->conf_if
);
8125 if (path
->peer
->hostname
8128 BGP_FLAG_SHOW_HOSTNAME
))
8129 vty_out(vty
, " from %s(%s)",
8130 path
->peer
->hostname
,
8133 vty_out(vty
, " from %s",
8141 & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
8142 vty_out(vty
, " (%s)",
8143 inet_ntoa(attr
->originator_id
));
8145 vty_out(vty
, " (%s)",
8148 &path
->peer
->remote_id
,
8149 buf1
, sizeof(buf1
)));
8154 * Note when vrfid of nexthop is different from that of prefix
8156 if (path
->extra
&& path
->extra
->bgp_orig
) {
8157 vrf_id_t nexthop_vrfid
= path
->extra
->bgp_orig
->vrf_id
;
8162 if (path
->extra
->bgp_orig
->inst_type
8163 == BGP_INSTANCE_TYPE_DEFAULT
)
8165 vn
= VRF_DEFAULT_NAME
;
8167 vn
= path
->extra
->bgp_orig
->name
;
8169 json_object_string_add(json_path
, "nhVrfName",
8172 if (nexthop_vrfid
== VRF_UNKNOWN
) {
8173 json_object_int_add(json_path
,
8176 json_object_int_add(json_path
,
8177 "nhVrfId", (int)nexthop_vrfid
);
8180 if (nexthop_vrfid
== VRF_UNKNOWN
)
8181 vty_out(vty
, " vrf ?");
8183 vty_out(vty
, " vrf %u", nexthop_vrfid
);
8189 json_object_boolean_true_add(json_path
,
8190 "announceNexthopSelf");
8192 vty_out(vty
, " announce-nh-self");
8199 /* display the link-local nexthop */
8200 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
8202 json_nexthop_ll
= json_object_new_object();
8203 json_object_string_add(
8204 json_nexthop_ll
, "ip",
8206 &attr
->mp_nexthop_local
, buf
,
8208 json_object_string_add(json_nexthop_ll
, "afi",
8210 json_object_string_add(json_nexthop_ll
, "scope",
8213 json_object_boolean_true_add(json_nexthop_ll
,
8216 if (!attr
->mp_nexthop_prefer_global
)
8217 json_object_boolean_true_add(
8218 json_nexthop_ll
, "used");
8220 json_object_boolean_true_add(
8221 json_nexthop_global
, "used");
8223 vty_out(vty
, " (%s) %s\n",
8225 &attr
->mp_nexthop_local
, buf
,
8227 attr
->mp_nexthop_prefer_global
8232 /* If we do not have a link-local nexthop then we must flag the
8236 json_object_boolean_true_add(
8237 json_nexthop_global
, "used");
8240 /* Line 3 display Origin, Med, Locpref, Weight, Tag, valid,
8241 * Int/Ext/Local, Atomic, best */
8243 json_object_string_add(
8244 json_path
, "origin",
8245 bgp_origin_long_str
[attr
->origin
]);
8247 vty_out(vty
, " Origin %s",
8248 bgp_origin_long_str
[attr
->origin
]);
8250 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)) {
8254 * Adding "metric" field to match with
8255 * corresponding CLI. "med" will be
8256 * deprecated in future.
8258 json_object_int_add(json_path
, "med",
8260 json_object_int_add(json_path
, "metric",
8263 vty_out(vty
, ", metric %u", attr
->med
);
8266 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)) {
8268 json_object_int_add(json_path
, "localpref",
8271 vty_out(vty
, ", localpref %u",
8275 if (attr
->weight
!= 0) {
8277 json_object_int_add(json_path
, "weight",
8280 vty_out(vty
, ", weight %u", attr
->weight
);
8283 if (attr
->tag
!= 0) {
8285 json_object_int_add(json_path
, "tag",
8288 vty_out(vty
, ", tag %" ROUTE_TAG_PRI
,
8292 if (!CHECK_FLAG(path
->flags
, BGP_PATH_VALID
)) {
8294 json_object_boolean_false_add(json_path
,
8297 vty_out(vty
, ", invalid");
8298 } else if (!CHECK_FLAG(path
->flags
, BGP_PATH_HISTORY
)) {
8300 json_object_boolean_true_add(json_path
,
8303 vty_out(vty
, ", valid");
8306 if (path
->peer
!= bgp
->peer_self
) {
8307 if (path
->peer
->as
== path
->peer
->local_as
) {
8308 if (CHECK_FLAG(bgp
->config
,
8309 BGP_CONFIG_CONFEDERATION
)) {
8311 json_object_string_add(
8316 ", confed-internal");
8319 json_object_string_add(
8323 vty_out(vty
, ", internal");
8326 if (bgp_confederation_peers_check(
8327 bgp
, path
->peer
->as
)) {
8329 json_object_string_add(
8334 ", confed-external");
8337 json_object_string_add(
8341 vty_out(vty
, ", external");
8344 } else if (path
->sub_type
== BGP_ROUTE_AGGREGATE
) {
8346 json_object_boolean_true_add(json_path
,
8348 json_object_boolean_true_add(json_path
,
8351 vty_out(vty
, ", aggregated, local");
8353 } else if (path
->type
!= ZEBRA_ROUTE_BGP
) {
8355 json_object_boolean_true_add(json_path
,
8358 vty_out(vty
, ", sourced");
8361 json_object_boolean_true_add(json_path
,
8363 json_object_boolean_true_add(json_path
,
8366 vty_out(vty
, ", sourced, local");
8370 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
8372 json_object_boolean_true_add(json_path
,
8375 vty_out(vty
, ", atomic-aggregate");
8378 if (CHECK_FLAG(path
->flags
, BGP_PATH_MULTIPATH
)
8379 || (CHECK_FLAG(path
->flags
, BGP_PATH_SELECTED
)
8380 && bgp_path_info_mpath_count(path
))) {
8382 json_object_boolean_true_add(json_path
,
8385 vty_out(vty
, ", multipath");
8388 // Mark the bestpath(s)
8389 if (CHECK_FLAG(path
->flags
, BGP_PATH_DMED_SELECTED
)) {
8390 first_as
= aspath_get_first_as(attr
->aspath
);
8395 json_object_new_object();
8396 json_object_int_add(json_bestpath
,
8397 "bestpathFromAs", first_as
);
8400 vty_out(vty
, ", bestpath-from-AS %u",
8404 ", bestpath-from-AS Local");
8408 if (CHECK_FLAG(path
->flags
, BGP_PATH_SELECTED
)) {
8412 json_object_new_object();
8413 json_object_boolean_true_add(json_bestpath
,
8416 vty_out(vty
, ", best");
8420 json_object_object_add(json_path
, "bestpath",
8426 /* Line 4 display Community */
8427 if (attr
->community
) {
8429 if (!attr
->community
->json
)
8430 community_str(attr
->community
, true);
8431 json_object_lock(attr
->community
->json
);
8432 json_object_object_add(json_path
, "community",
8433 attr
->community
->json
);
8435 vty_out(vty
, " Community: %s\n",
8436 attr
->community
->str
);
8440 /* Line 5 display Extended-community */
8441 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)) {
8443 json_ext_community
= json_object_new_object();
8444 json_object_string_add(json_ext_community
,
8446 attr
->ecommunity
->str
);
8447 json_object_object_add(json_path
,
8448 "extendedCommunity",
8449 json_ext_community
);
8451 vty_out(vty
, " Extended Community: %s\n",
8452 attr
->ecommunity
->str
);
8456 /* Line 6 display Large community */
8457 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
)) {
8459 if (!attr
->lcommunity
->json
)
8460 lcommunity_str(attr
->lcommunity
, true);
8461 json_object_lock(attr
->lcommunity
->json
);
8462 json_object_object_add(json_path
,
8464 attr
->lcommunity
->json
);
8466 vty_out(vty
, " Large Community: %s\n",
8467 attr
->lcommunity
->str
);
8471 /* Line 7 display Originator, Cluster-id */
8472 if ((attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
8473 || (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
))) {
8475 & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
)) {
8477 json_object_string_add(
8478 json_path
, "originatorId",
8479 inet_ntoa(attr
->originator_id
));
8481 vty_out(vty
, " Originator: %s",
8482 inet_ntoa(attr
->originator_id
));
8485 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
)) {
8490 json_object_new_object();
8491 json_cluster_list_list
=
8492 json_object_new_array();
8495 i
< attr
->cluster
->length
/ 4;
8497 json_string
= json_object_new_string(
8501 json_object_array_add(
8502 json_cluster_list_list
,
8506 /* struct cluster_list does not have
8508 * aspath and community do. Add this
8511 json_object_string_add(json_cluster_list,
8512 "string", attr->cluster->str);
8514 json_object_object_add(
8515 json_cluster_list
, "list",
8516 json_cluster_list_list
);
8517 json_object_object_add(
8518 json_path
, "clusterList",
8521 vty_out(vty
, ", Cluster list: ");
8524 i
< attr
->cluster
->length
/ 4;
8538 if (path
->extra
&& path
->extra
->damp_info
)
8539 bgp_damp_info_vty(vty
, path
, json_path
);
8542 if (path
->extra
&& bgp_is_valid_label(&path
->extra
->label
[0])
8543 && safi
!= SAFI_EVPN
) {
8544 mpls_label_t label
= label_pton(&path
->extra
->label
[0]);
8547 json_object_int_add(json_path
, "remoteLabel",
8550 vty_out(vty
, " Remote label: %d\n", label
);
8554 if (attr
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
8556 json_object_int_add(json_path
, "labelIndex",
8559 vty_out(vty
, " Label Index: %d\n",
8563 /* Line 8 display Addpath IDs */
8564 if (path
->addpath_rx_id
8565 || bgp_addpath_info_has_ids(&path
->tx_addpath
)) {
8567 json_object_int_add(json_path
, "addpathRxId",
8568 path
->addpath_rx_id
);
8570 /* Keep backwards compatibility with the old API
8571 * by putting TX All's ID in the old field
8573 json_object_int_add(
8574 json_path
, "addpathTxId",
8575 path
->tx_addpath
.addpath_tx_id
8578 /* ... but create a specific field for each
8581 for (i
= 0; i
< BGP_ADDPATH_MAX
; i
++) {
8582 json_object_int_add(
8584 bgp_addpath_names(i
)
8590 vty_out(vty
, " AddPath ID: RX %u, ",
8591 path
->addpath_rx_id
);
8593 route_vty_out_tx_ids(vty
, &path
->tx_addpath
);
8597 /* If we used addpath to TX a non-bestpath we need to display
8598 * "Advertised to" on a path-by-path basis
8600 if (bgp_addpath_is_addpath_used(&bgp
->tx_addpath
, afi
, safi
)) {
8603 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8605 bgp_addpath_encode_tx(peer
, afi
, safi
);
8606 has_adj
= bgp_adj_out_lookup(
8608 bgp_addpath_id_for_peer(
8610 &path
->tx_addpath
));
8612 if ((addpath_capable
&& has_adj
)
8613 || (!addpath_capable
&& has_adj
8614 && CHECK_FLAG(path
->flags
,
8615 BGP_PATH_SELECTED
))) {
8616 if (json_path
&& !json_adv_to
)
8618 json_object_new_object();
8620 route_vty_out_advertised_to(
8629 json_object_object_add(json_path
,
8640 /* Line 9 display Uptime */
8641 tbuf
= time(NULL
) - (bgp_clock() - path
->uptime
);
8643 json_last_update
= json_object_new_object();
8644 json_object_int_add(json_last_update
, "epoch", tbuf
);
8645 json_object_string_add(json_last_update
, "string",
8647 json_object_object_add(json_path
, "lastUpdate",
8650 vty_out(vty
, " Last update: %s", ctime(&tbuf
));
8652 /* Line 10 display PMSI tunnel attribute, if present */
8653 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
)) {
8654 const char *str
= lookup_msg(bgp_pmsi_tnltype_str
,
8655 attr
->pmsi_tnl_type
,
8656 PMSI_TNLTYPE_STR_DEFAULT
);
8659 json_pmsi
= json_object_new_object();
8660 json_object_string_add(json_pmsi
,
8662 json_object_int_add(json_pmsi
,
8664 label2vni(&attr
->label
));
8665 json_object_object_add(json_path
, "pmsi",
8669 " PMSI Tunnel Type: %s, label: %d\n",
8670 str
, label2vni(&attr
->label
));
8675 /* We've constructed the json object for this path, add it to the json
8679 if (json_nexthop_global
|| json_nexthop_ll
) {
8680 json_nexthops
= json_object_new_array();
8682 if (json_nexthop_global
)
8683 json_object_array_add(json_nexthops
,
8684 json_nexthop_global
);
8686 if (json_nexthop_ll
)
8687 json_object_array_add(json_nexthops
,
8690 json_object_object_add(json_path
, "nexthops",
8694 json_object_object_add(json_path
, "peer", json_peer
);
8695 json_object_array_add(json_paths
, json_path
);
8700 #define BGP_SHOW_HEADER_CSV "Flags, Network, Next Hop, Metric, LocPrf, Weight, Path"
8701 #define BGP_SHOW_DAMP_HEADER " Network From Reuse Path\n"
8702 #define BGP_SHOW_FLAP_HEADER " Network From Flaps Duration Reuse Path\n"
8704 static int bgp_show_prefix_list(struct vty
*vty
, struct bgp
*bgp
,
8705 const char *prefix_list_str
, afi_t afi
,
8706 safi_t safi
, enum bgp_show_type type
);
8707 static int bgp_show_filter_list(struct vty
*vty
, struct bgp
*bgp
,
8708 const char *filter
, afi_t afi
, safi_t safi
,
8709 enum bgp_show_type type
);
8710 static int bgp_show_route_map(struct vty
*vty
, struct bgp
*bgp
,
8711 const char *rmap_str
, afi_t afi
, safi_t safi
,
8712 enum bgp_show_type type
);
8713 static int bgp_show_community_list(struct vty
*vty
, struct bgp
*bgp
,
8714 const char *com
, int exact
, afi_t afi
,
8716 static int bgp_show_prefix_longer(struct vty
*vty
, struct bgp
*bgp
,
8717 const char *prefix
, afi_t afi
, safi_t safi
,
8718 enum bgp_show_type type
);
8719 static int bgp_show_regexp(struct vty
*vty
, struct bgp
*bgp
, const char *regstr
,
8720 afi_t afi
, safi_t safi
, enum bgp_show_type type
);
8721 static int bgp_show_community(struct vty
*vty
, struct bgp
*bgp
,
8722 const char *comstr
, int exact
, afi_t afi
,
8723 safi_t safi
, bool use_json
);
8726 static int bgp_show_table(struct vty
*vty
, struct bgp
*bgp
, safi_t safi
,
8727 struct bgp_table
*table
, enum bgp_show_type type
,
8728 void *output_arg
, bool use_json
, char *rd
,
8729 int is_last
, unsigned long *output_cum
,
8730 unsigned long *total_cum
,
8731 unsigned long *json_header_depth
)
8733 struct bgp_path_info
*pi
;
8734 struct bgp_node
*rn
;
8737 unsigned long output_count
= 0;
8738 unsigned long total_count
= 0;
8741 json_object
*json_paths
= NULL
;
8744 if (output_cum
&& *output_cum
!= 0)
8747 if (use_json
&& !*json_header_depth
) {
8749 "{\n \"vrfId\": %d,\n \"vrfName\": \"%s\",\n \"tableVersion\": %" PRId64
8750 ",\n \"routerId\": \"%s\",\n \"defaultLocPrf\": %u,\n"
8751 " \"localAS\": %u,\n \"routes\": { ",
8752 bgp
->vrf_id
== VRF_UNKNOWN
? -1 : (int)bgp
->vrf_id
,
8753 bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
8756 table
->version
, inet_ntoa(bgp
->router_id
),
8757 bgp
->default_local_pref
, bgp
->as
);
8758 *json_header_depth
= 2;
8760 vty_out(vty
, " \"routeDistinguishers\" : {");
8761 ++*json_header_depth
;
8765 if (use_json
&& rd
) {
8766 vty_out(vty
, " \"%s\" : { ", rd
);
8769 /* Start processing of routes. */
8770 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
8771 pi
= bgp_node_get_bgp_path_info(rn
);
8777 json_paths
= json_object_new_array();
8781 for (; pi
; pi
= pi
->next
) {
8783 if (type
== bgp_show_type_flap_statistics
8784 || type
== bgp_show_type_flap_neighbor
8785 || type
== bgp_show_type_dampend_paths
8786 || type
== bgp_show_type_damp_neighbor
) {
8787 if (!(pi
->extra
&& pi
->extra
->damp_info
))
8790 if (type
== bgp_show_type_regexp
) {
8791 regex_t
*regex
= output_arg
;
8793 if (bgp_regexec(regex
, pi
->attr
->aspath
)
8797 if (type
== bgp_show_type_prefix_list
) {
8798 struct prefix_list
*plist
= output_arg
;
8800 if (prefix_list_apply(plist
, &rn
->p
)
8804 if (type
== bgp_show_type_filter_list
) {
8805 struct as_list
*as_list
= output_arg
;
8807 if (as_list_apply(as_list
, pi
->attr
->aspath
)
8808 != AS_FILTER_PERMIT
)
8811 if (type
== bgp_show_type_route_map
) {
8812 struct route_map
*rmap
= output_arg
;
8813 struct bgp_path_info path
;
8814 struct attr dummy_attr
;
8817 bgp_attr_dup(&dummy_attr
, pi
->attr
);
8819 path
.peer
= pi
->peer
;
8820 path
.attr
= &dummy_attr
;
8822 ret
= route_map_apply(rmap
, &rn
->p
, RMAP_BGP
,
8824 if (ret
== RMAP_DENYMATCH
)
8827 if (type
== bgp_show_type_neighbor
8828 || type
== bgp_show_type_flap_neighbor
8829 || type
== bgp_show_type_damp_neighbor
) {
8830 union sockunion
*su
= output_arg
;
8832 if (pi
->peer
== NULL
8833 || pi
->peer
->su_remote
== NULL
8834 || !sockunion_same(pi
->peer
->su_remote
, su
))
8837 if (type
== bgp_show_type_cidr_only
) {
8838 uint32_t destination
;
8840 destination
= ntohl(rn
->p
.u
.prefix4
.s_addr
);
8841 if (IN_CLASSC(destination
)
8842 && rn
->p
.prefixlen
== 24)
8844 if (IN_CLASSB(destination
)
8845 && rn
->p
.prefixlen
== 16)
8847 if (IN_CLASSA(destination
)
8848 && rn
->p
.prefixlen
== 8)
8851 if (type
== bgp_show_type_prefix_longer
) {
8853 if (!prefix_match(p
, &rn
->p
))
8856 if (type
== bgp_show_type_community_all
) {
8857 if (!pi
->attr
->community
)
8860 if (type
== bgp_show_type_community
) {
8861 struct community
*com
= output_arg
;
8863 if (!pi
->attr
->community
8864 || !community_match(pi
->attr
->community
,
8868 if (type
== bgp_show_type_community_exact
) {
8869 struct community
*com
= output_arg
;
8871 if (!pi
->attr
->community
8872 || !community_cmp(pi
->attr
->community
, com
))
8875 if (type
== bgp_show_type_community_list
) {
8876 struct community_list
*list
= output_arg
;
8878 if (!community_list_match(pi
->attr
->community
,
8882 if (type
== bgp_show_type_community_list_exact
) {
8883 struct community_list
*list
= output_arg
;
8885 if (!community_list_exact_match(
8886 pi
->attr
->community
, list
))
8889 if (type
== bgp_show_type_lcommunity
) {
8890 struct lcommunity
*lcom
= output_arg
;
8892 if (!pi
->attr
->lcommunity
8893 || !lcommunity_match(pi
->attr
->lcommunity
,
8897 if (type
== bgp_show_type_lcommunity_list
) {
8898 struct community_list
*list
= output_arg
;
8900 if (!lcommunity_list_match(pi
->attr
->lcommunity
,
8904 if (type
== bgp_show_type_lcommunity_all
) {
8905 if (!pi
->attr
->lcommunity
)
8908 if (type
== bgp_show_type_dampend_paths
8909 || type
== bgp_show_type_damp_neighbor
) {
8910 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_DAMPED
)
8911 || CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
))
8915 if (!use_json
&& header
) {
8916 vty_out(vty
, "BGP table version is %" PRIu64
8917 ", local router ID is %s, vrf id ",
8919 inet_ntoa(bgp
->router_id
));
8920 if (bgp
->vrf_id
== VRF_UNKNOWN
)
8921 vty_out(vty
, "%s", VRFID_NONE_STR
);
8923 vty_out(vty
, "%u", bgp
->vrf_id
);
8925 vty_out(vty
, "Default local pref %u, ",
8926 bgp
->default_local_pref
);
8927 vty_out(vty
, "local AS %u\n", bgp
->as
);
8928 vty_out(vty
, BGP_SHOW_SCODE_HEADER
);
8929 vty_out(vty
, BGP_SHOW_NCODE_HEADER
);
8930 vty_out(vty
, BGP_SHOW_OCODE_HEADER
);
8931 if (type
== bgp_show_type_dampend_paths
8932 || type
== bgp_show_type_damp_neighbor
)
8933 vty_out(vty
, BGP_SHOW_DAMP_HEADER
);
8934 else if (type
== bgp_show_type_flap_statistics
8935 || type
== bgp_show_type_flap_neighbor
)
8936 vty_out(vty
, BGP_SHOW_FLAP_HEADER
);
8938 vty_out(vty
, BGP_SHOW_HEADER
);
8941 if (rd
!= NULL
&& !display
&& !output_count
) {
8944 "Route Distinguisher: %s\n",
8947 if (type
== bgp_show_type_dampend_paths
8948 || type
== bgp_show_type_damp_neighbor
)
8949 damp_route_vty_out(vty
, &rn
->p
, pi
, display
,
8950 safi
, use_json
, json_paths
);
8951 else if (type
== bgp_show_type_flap_statistics
8952 || type
== bgp_show_type_flap_neighbor
)
8953 flap_route_vty_out(vty
, &rn
->p
, pi
, display
,
8954 safi
, use_json
, json_paths
);
8956 route_vty_out(vty
, &rn
->p
, pi
, display
, safi
,
8968 if (p
->family
== AF_FLOWSPEC
) {
8969 char retstr
[BGP_FLOWSPEC_STRING_DISPLAY_MAX
];
8971 bgp_fs_nlri_get_string((unsigned char *)
8972 p
->u
.prefix_flowspec
.ptr
,
8973 p
->u
.prefix_flowspec
8976 NLRI_STRING_FORMAT_MIN
,
8979 vty_out(vty
, "\"%s/%d\": ",
8981 p
->u
.prefix_flowspec
.prefixlen
);
8983 vty_out(vty
, ",\"%s/%d\": ",
8985 p
->u
.prefix_flowspec
.prefixlen
);
8987 prefix2str(p
, buf2
, sizeof(buf2
));
8989 vty_out(vty
, "\"%s\": ", buf2
);
8991 vty_out(vty
, ",\"%s\": ", buf2
);
8994 json_object_to_json_string(json_paths
));
8995 json_object_free(json_paths
);
9002 output_count
+= *output_cum
;
9003 *output_cum
= output_count
;
9006 total_count
+= *total_cum
;
9007 *total_cum
= total_count
;
9011 vty_out(vty
, " }%s ", (is_last
? "" : ","));
9015 for (i
= 0; i
< *json_header_depth
; ++i
)
9016 vty_out(vty
, " } ");
9021 /* No route is displayed */
9022 if (output_count
== 0) {
9023 if (type
== bgp_show_type_normal
)
9025 "No BGP prefixes displayed, %ld exist\n",
9029 "\nDisplayed %ld routes and %ld total paths\n",
9030 output_count
, total_count
);
9037 int bgp_show_table_rd(struct vty
*vty
, struct bgp
*bgp
, safi_t safi
,
9038 struct bgp_table
*table
, struct prefix_rd
*prd_match
,
9039 enum bgp_show_type type
, void *output_arg
, bool use_json
)
9041 struct bgp_node
*rn
, *next
;
9042 unsigned long output_cum
= 0;
9043 unsigned long total_cum
= 0;
9044 unsigned long json_header_depth
= 0;
9045 struct bgp_table
*itable
;
9048 show_msg
= (!use_json
&& type
== bgp_show_type_normal
);
9050 for (rn
= bgp_table_top(table
); rn
; rn
= next
) {
9051 next
= bgp_route_next(rn
);
9052 if (prd_match
&& memcmp(rn
->p
.u
.val
, prd_match
->val
, 8) != 0)
9055 itable
= bgp_node_get_bgp_table_info(rn
);
9056 if (itable
!= NULL
) {
9057 struct prefix_rd prd
;
9058 char rd
[RD_ADDRSTRLEN
];
9060 memcpy(&prd
, &(rn
->p
), sizeof(struct prefix_rd
));
9061 prefix_rd2str(&prd
, rd
, sizeof(rd
));
9062 bgp_show_table(vty
, bgp
, safi
, itable
, type
, output_arg
,
9063 use_json
, rd
, next
== NULL
, &output_cum
,
9064 &total_cum
, &json_header_depth
);
9070 if (output_cum
== 0)
9071 vty_out(vty
, "No BGP prefixes displayed, %ld exist\n",
9075 "\nDisplayed %ld routes and %ld total paths\n",
9076 output_cum
, total_cum
);
9080 static int bgp_show(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
, safi_t safi
,
9081 enum bgp_show_type type
, void *output_arg
, bool use_json
)
9083 struct bgp_table
*table
;
9084 unsigned long json_header_depth
= 0;
9087 bgp
= bgp_get_default();
9092 vty_out(vty
, "No BGP process is configured\n");
9094 vty_out(vty
, "{}\n");
9098 table
= bgp
->rib
[afi
][safi
];
9099 /* use MPLS and ENCAP specific shows until they are merged */
9100 if (safi
== SAFI_MPLS_VPN
) {
9101 return bgp_show_table_rd(vty
, bgp
, safi
, table
, NULL
, type
,
9102 output_arg
, use_json
);
9105 if (safi
== SAFI_FLOWSPEC
&& type
== bgp_show_type_detail
) {
9106 return bgp_show_table_flowspec(vty
, bgp
, afi
, table
, type
,
9107 output_arg
, use_json
,
9110 /* labeled-unicast routes live in the unicast table */
9111 else if (safi
== SAFI_LABELED_UNICAST
)
9112 safi
= SAFI_UNICAST
;
9114 return bgp_show_table(vty
, bgp
, safi
, table
, type
, output_arg
, use_json
,
9115 NULL
, 1, NULL
, NULL
, &json_header_depth
);
9118 static void bgp_show_all_instances_routes_vty(struct vty
*vty
, afi_t afi
,
9119 safi_t safi
, bool use_json
)
9121 struct listnode
*node
, *nnode
;
9124 bool route_output
= false;
9127 vty_out(vty
, "{\n");
9129 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
9130 route_output
= true;
9133 vty_out(vty
, ",\n");
9137 vty_out(vty
, "\"%s\":",
9138 (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
9142 vty_out(vty
, "\nInstance %s:\n",
9143 (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
9147 bgp_show(vty
, bgp
, afi
, safi
, bgp_show_type_normal
, NULL
,
9152 vty_out(vty
, "}\n");
9153 else if (!route_output
)
9154 vty_out(vty
, "%% BGP instance not found\n");
9157 /* Header of detailed BGP route information */
9158 void route_vty_out_detail_header(struct vty
*vty
, struct bgp
*bgp
,
9159 struct bgp_node
*rn
, struct prefix_rd
*prd
,
9160 afi_t afi
, safi_t safi
, json_object
*json
)
9162 struct bgp_path_info
*pi
;
9165 struct listnode
*node
, *nnode
;
9166 char buf1
[RD_ADDRSTRLEN
];
9167 char buf2
[INET6_ADDRSTRLEN
];
9168 char buf3
[EVPN_ROUTE_STRLEN
];
9169 char prefix_str
[BUFSIZ
];
9174 int route_filter_translated_v4
= 0;
9175 int route_filter_v4
= 0;
9176 int route_filter_translated_v6
= 0;
9177 int route_filter_v6
= 0;
9180 int accept_own_nexthop
= 0;
9183 int no_advertise
= 0;
9187 int has_valid_label
= 0;
9188 mpls_label_t label
= 0;
9189 json_object
*json_adv_to
= NULL
;
9192 has_valid_label
= bgp_is_valid_label(&rn
->local_label
);
9194 if (has_valid_label
)
9195 label
= label_pton(&rn
->local_label
);
9198 if (has_valid_label
)
9199 json_object_int_add(json
, "localLabel", label
);
9201 json_object_string_add(
9203 prefix2str(p
, prefix_str
, sizeof(prefix_str
)));
9205 if (safi
== SAFI_EVPN
)
9206 vty_out(vty
, "BGP routing table entry for %s%s%s\n",
9207 prd
? prefix_rd2str(prd
, buf1
, sizeof(buf1
))
9210 bgp_evpn_route2str((struct prefix_evpn
*)p
,
9211 buf3
, sizeof(buf3
)));
9213 vty_out(vty
, "BGP routing table entry for %s%s%s/%d\n",
9214 ((safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
)
9215 ? prefix_rd2str(prd
, buf1
,
9218 safi
== SAFI_MPLS_VPN
? ":" : "",
9219 inet_ntop(p
->family
, &p
->u
.prefix
, buf2
,
9223 if (has_valid_label
)
9224 vty_out(vty
, "Local label: %d\n", label
);
9225 if (bgp_labeled_safi(safi
) && safi
!= SAFI_EVPN
)
9226 vty_out(vty
, "not allocated\n");
9229 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
9231 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
9233 if (pi
->extra
&& pi
->extra
->suppress
)
9236 if (pi
->attr
->community
== NULL
)
9239 no_advertise
+= community_include(
9240 pi
->attr
->community
, COMMUNITY_NO_ADVERTISE
);
9241 no_export
+= community_include(pi
->attr
->community
,
9242 COMMUNITY_NO_EXPORT
);
9243 local_as
+= community_include(pi
->attr
->community
,
9244 COMMUNITY_LOCAL_AS
);
9245 accept_own
+= community_include(pi
->attr
->community
,
9246 COMMUNITY_ACCEPT_OWN
);
9247 route_filter_translated_v4
+= community_include(
9248 pi
->attr
->community
,
9249 COMMUNITY_ROUTE_FILTER_TRANSLATED_v4
);
9250 route_filter_translated_v6
+= community_include(
9251 pi
->attr
->community
,
9252 COMMUNITY_ROUTE_FILTER_TRANSLATED_v6
);
9253 route_filter_v4
+= community_include(
9254 pi
->attr
->community
, COMMUNITY_ROUTE_FILTER_v4
);
9255 route_filter_v6
+= community_include(
9256 pi
->attr
->community
, COMMUNITY_ROUTE_FILTER_v6
);
9257 llgr_stale
+= community_include(pi
->attr
->community
,
9258 COMMUNITY_LLGR_STALE
);
9259 no_llgr
+= community_include(pi
->attr
->community
,
9261 accept_own_nexthop
+=
9262 community_include(pi
->attr
->community
,
9263 COMMUNITY_ACCEPT_OWN_NEXTHOP
);
9264 blackhole
+= community_include(pi
->attr
->community
,
9265 COMMUNITY_BLACKHOLE
);
9266 no_peer
+= community_include(pi
->attr
->community
,
9272 vty_out(vty
, "Paths: (%d available", count
);
9274 vty_out(vty
, ", best #%d", best
);
9275 if (safi
== SAFI_UNICAST
)
9276 vty_out(vty
, ", table %s",
9278 == BGP_INSTANCE_TYPE_DEFAULT
)
9282 vty_out(vty
, ", no best path");
9286 ", accept own local route exported and imported in different VRF");
9287 else if (route_filter_translated_v4
)
9289 ", mark translated RTs for VPNv4 route filtering");
9290 else if (route_filter_v4
)
9292 ", attach RT as-is for VPNv4 route filtering");
9293 else if (route_filter_translated_v6
)
9295 ", mark translated RTs for VPNv6 route filtering");
9296 else if (route_filter_v6
)
9298 ", attach RT as-is for VPNv6 route filtering");
9299 else if (llgr_stale
)
9301 ", mark routes to be retained for a longer time. Requeres support for Long-lived BGP Graceful Restart");
9304 ", mark routes to not be treated according to Long-lived BGP Graceful Restart operations");
9305 else if (accept_own_nexthop
)
9307 ", accept local nexthop");
9309 vty_out(vty
, ", inform peer to blackhole prefix");
9311 vty_out(vty
, ", not advertised to EBGP peer");
9312 else if (no_advertise
)
9313 vty_out(vty
, ", not advertised to any peer");
9315 vty_out(vty
, ", not advertised outside local AS");
9318 ", inform EBGP peer not to advertise to their EBGP peers");
9322 ", Advertisements suppressed by an aggregate.");
9323 vty_out(vty
, ")\n");
9326 /* If we are not using addpath then we can display Advertised to and
9328 * show what peers we advertised the bestpath to. If we are using
9330 * though then we must display Advertised to on a path-by-path basis. */
9331 if (!bgp_addpath_is_addpath_used(&bgp
->tx_addpath
, afi
, safi
)) {
9332 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
9333 if (bgp_adj_out_lookup(peer
, rn
, 0)) {
9334 if (json
&& !json_adv_to
)
9335 json_adv_to
= json_object_new_object();
9337 route_vty_out_advertised_to(
9339 " Advertised to non peer-group peers:\n ",
9346 json_object_object_add(json
, "advertisedTo",
9351 vty_out(vty
, " Not advertised to any peer");
9357 /* Display specified route of BGP table. */
9358 static int bgp_show_route_in_table(struct vty
*vty
, struct bgp
*bgp
,
9359 struct bgp_table
*rib
, const char *ip_str
,
9360 afi_t afi
, safi_t safi
,
9361 struct prefix_rd
*prd
, int prefix_check
,
9362 enum bgp_path_type pathtype
, bool use_json
)
9367 struct prefix match
;
9368 struct bgp_node
*rn
;
9369 struct bgp_node
*rm
;
9370 struct bgp_path_info
*pi
;
9371 struct bgp_table
*table
;
9372 json_object
*json
= NULL
;
9373 json_object
*json_paths
= NULL
;
9375 /* Check IP address argument. */
9376 ret
= str2prefix(ip_str
, &match
);
9378 vty_out(vty
, "address is malformed\n");
9382 match
.family
= afi2family(afi
);
9385 json
= json_object_new_object();
9386 json_paths
= json_object_new_array();
9389 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
|| safi
== SAFI_EVPN
) {
9390 for (rn
= bgp_table_top(rib
); rn
; rn
= bgp_route_next(rn
)) {
9391 if (prd
&& memcmp(rn
->p
.u
.val
, prd
->val
, 8) != 0)
9393 table
= bgp_node_get_bgp_table_info(rn
);
9399 if ((rm
= bgp_node_match(table
, &match
)) == NULL
)
9403 && rm
->p
.prefixlen
!= match
.prefixlen
) {
9404 bgp_unlock_node(rm
);
9408 for (pi
= bgp_node_get_bgp_path_info(rm
); pi
;
9411 route_vty_out_detail_header(
9413 (struct prefix_rd
*)&rn
->p
,
9414 AFI_IP
, safi
, json
);
9419 if (pathtype
== BGP_PATH_SHOW_ALL
9420 || (pathtype
== BGP_PATH_SHOW_BESTPATH
9421 && CHECK_FLAG(pi
->flags
,
9423 || (pathtype
== BGP_PATH_SHOW_MULTIPATH
9424 && (CHECK_FLAG(pi
->flags
,
9426 || CHECK_FLAG(pi
->flags
,
9427 BGP_PATH_SELECTED
))))
9428 route_vty_out_detail(vty
, bgp
, &rm
->p
,
9433 bgp_unlock_node(rm
);
9435 } else if (safi
== SAFI_FLOWSPEC
) {
9436 display
= bgp_flowspec_display_match_per_ip(afi
, rib
,
9437 &match
, prefix_check
,
9444 if ((rn
= bgp_node_match(rib
, &match
)) != NULL
) {
9446 || rn
->p
.prefixlen
== match
.prefixlen
) {
9447 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
;
9450 route_vty_out_detail_header(
9451 vty
, bgp
, rn
, NULL
, afi
,
9457 if (pathtype
== BGP_PATH_SHOW_ALL
9459 == BGP_PATH_SHOW_BESTPATH
9464 == BGP_PATH_SHOW_MULTIPATH
9470 BGP_PATH_SELECTED
))))
9471 route_vty_out_detail(
9472 vty
, bgp
, &rn
->p
, pi
,
9473 afi
, safi
, json_paths
);
9477 bgp_unlock_node(rn
);
9483 json_object_object_add(json
, "paths", json_paths
);
9485 vty_out(vty
, "%s\n", json_object_to_json_string_ext(
9486 json
, JSON_C_TO_STRING_PRETTY
));
9487 json_object_free(json
);
9490 vty_out(vty
, "%% Network not in table\n");
9498 /* Display specified route of Main RIB */
9499 static int bgp_show_route(struct vty
*vty
, struct bgp
*bgp
, const char *ip_str
,
9500 afi_t afi
, safi_t safi
, struct prefix_rd
*prd
,
9501 int prefix_check
, enum bgp_path_type pathtype
,
9505 bgp
= bgp_get_default();
9508 vty_out(vty
, "No BGP process is configured\n");
9510 vty_out(vty
, "{}\n");
9515 /* labeled-unicast routes live in the unicast table */
9516 if (safi
== SAFI_LABELED_UNICAST
)
9517 safi
= SAFI_UNICAST
;
9519 return bgp_show_route_in_table(vty
, bgp
, bgp
->rib
[afi
][safi
], ip_str
,
9520 afi
, safi
, prd
, prefix_check
, pathtype
,
9524 static int bgp_show_lcommunity(struct vty
*vty
, struct bgp
*bgp
, int argc
,
9525 struct cmd_token
**argv
, afi_t afi
, safi_t safi
,
9528 struct lcommunity
*lcom
;
9534 b
= buffer_new(1024);
9535 for (i
= 0; i
< argc
; i
++) {
9537 buffer_putc(b
, ' ');
9539 if (strmatch(argv
[i
]->text
, "AA:BB:CC")) {
9541 buffer_putstr(b
, argv
[i
]->arg
);
9545 buffer_putc(b
, '\0');
9547 str
= buffer_getstr(b
);
9550 lcom
= lcommunity_str2com(str
);
9551 XFREE(MTYPE_TMP
, str
);
9553 vty_out(vty
, "%% Large-community malformed\n");
9557 return bgp_show(vty
, bgp
, afi
, safi
, bgp_show_type_lcommunity
, lcom
,
9561 static int bgp_show_lcommunity_list(struct vty
*vty
, struct bgp
*bgp
,
9562 const char *lcom
, afi_t afi
, safi_t safi
,
9565 struct community_list
*list
;
9567 list
= community_list_lookup(bgp_clist
, lcom
, 0,
9568 LARGE_COMMUNITY_LIST_MASTER
);
9570 vty_out(vty
, "%% %s is not a valid large-community-list name\n",
9575 return bgp_show(vty
, bgp
, afi
, safi
, bgp_show_type_lcommunity_list
,
9579 DEFUN (show_ip_bgp_large_community_list
,
9580 show_ip_bgp_large_community_list_cmd
,
9581 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] large-community-list <(1-500)|WORD> [json]",
9585 BGP_INSTANCE_HELP_STR
9587 BGP_SAFI_WITH_LABEL_HELP_STR
9588 "Display routes matching the large-community-list\n"
9589 "large-community-list number\n"
9590 "large-community-list name\n"
9594 afi_t afi
= AFI_IP6
;
9595 safi_t safi
= SAFI_UNICAST
;
9598 if (argv_find(argv
, argc
, "ip", &idx
))
9600 if (argv_find(argv
, argc
, "view", &idx
)
9601 || argv_find(argv
, argc
, "vrf", &idx
))
9602 vrf
= argv
[++idx
]->arg
;
9603 if (argv_find(argv
, argc
, "ipv4", &idx
)
9604 || argv_find(argv
, argc
, "ipv6", &idx
)) {
9605 afi
= strmatch(argv
[idx
]->text
, "ipv6") ? AFI_IP6
: AFI_IP
;
9606 if (argv_find(argv
, argc
, "unicast", &idx
)
9607 || argv_find(argv
, argc
, "multicast", &idx
))
9608 safi
= bgp_vty_safi_from_str(argv
[idx
]->text
);
9611 bool uj
= use_json(argc
, argv
);
9613 struct bgp
*bgp
= bgp_lookup_by_name(vrf
);
9615 vty_out(vty
, "Can't find BGP instance %s\n", vrf
);
9619 argv_find(argv
, argc
, "large-community-list", &idx
);
9620 return bgp_show_lcommunity_list(vty
, bgp
, argv
[idx
+ 1]->arg
, afi
, safi
,
9623 DEFUN (show_ip_bgp_large_community
,
9624 show_ip_bgp_large_community_cmd
,
9625 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] large-community [AA:BB:CC] [json]",
9629 BGP_INSTANCE_HELP_STR
9631 BGP_SAFI_WITH_LABEL_HELP_STR
9632 "Display routes matching the large-communities\n"
9633 "List of large-community numbers\n"
9637 afi_t afi
= AFI_IP6
;
9638 safi_t safi
= SAFI_UNICAST
;
9641 if (argv_find(argv
, argc
, "ip", &idx
))
9643 if (argv_find(argv
, argc
, "view", &idx
)
9644 || argv_find(argv
, argc
, "vrf", &idx
))
9645 vrf
= argv
[++idx
]->arg
;
9646 if (argv_find(argv
, argc
, "ipv4", &idx
)
9647 || argv_find(argv
, argc
, "ipv6", &idx
)) {
9648 afi
= strmatch(argv
[idx
]->text
, "ipv6") ? AFI_IP6
: AFI_IP
;
9649 if (argv_find(argv
, argc
, "unicast", &idx
)
9650 || argv_find(argv
, argc
, "multicast", &idx
))
9651 safi
= bgp_vty_safi_from_str(argv
[idx
]->text
);
9654 bool uj
= use_json(argc
, argv
);
9656 struct bgp
*bgp
= bgp_lookup_by_name(vrf
);
9658 vty_out(vty
, "Can't find BGP instance %s\n", vrf
);
9662 if (argv_find(argv
, argc
, "AA:BB:CC", &idx
))
9663 return bgp_show_lcommunity(vty
, bgp
, argc
, argv
, afi
, safi
, uj
);
9665 return bgp_show(vty
, bgp
, afi
, safi
,
9666 bgp_show_type_lcommunity_all
, NULL
, uj
);
9669 static int bgp_table_stats(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
9673 /* BGP route print out function without JSON */
9676 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]]\
9677 <dampening <parameters>\
9682 |community-list <(1-500)|WORD> [exact-match]\
9683 |A.B.C.D/M longer-prefixes\
9684 |X:X::X:X/M longer-prefixes\
9689 BGP_INSTANCE_HELP_STR
9691 BGP_SAFI_WITH_LABEL_HELP_STR
9692 "Display detailed information about dampening\n"
9693 "Display detail of configured dampening parameters\n"
9694 "Display routes matching the route-map\n"
9695 "A route-map to match on\n"
9696 "Display routes conforming to the prefix-list\n"
9697 "Prefix-list name\n"
9698 "Display routes conforming to the filter-list\n"
9699 "Regular expression access list name\n"
9700 "BGP RIB advertisement statistics\n"
9701 "Display routes matching the community-list\n"
9702 "community-list number\n"
9703 "community-list name\n"
9704 "Exact match of the communities\n"
9706 "Display route and more specific routes\n"
9708 "Display route and more specific routes\n")
9710 afi_t afi
= AFI_IP6
;
9711 safi_t safi
= SAFI_UNICAST
;
9712 int exact_match
= 0;
9713 struct bgp
*bgp
= NULL
;
9716 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
9721 if (argv_find(argv
, argc
, "dampening", &idx
)) {
9722 if (argv_find(argv
, argc
, "parameters", &idx
))
9723 return bgp_show_dampening_parameters(vty
, afi
, safi
);
9726 if (argv_find(argv
, argc
, "prefix-list", &idx
))
9727 return bgp_show_prefix_list(vty
, bgp
, argv
[idx
+ 1]->arg
, afi
,
9728 safi
, bgp_show_type_prefix_list
);
9730 if (argv_find(argv
, argc
, "filter-list", &idx
))
9731 return bgp_show_filter_list(vty
, bgp
, argv
[idx
+ 1]->arg
, afi
,
9732 safi
, bgp_show_type_filter_list
);
9734 if (argv_find(argv
, argc
, "statistics", &idx
))
9735 return bgp_table_stats(vty
, bgp
, afi
, safi
);
9737 if (argv_find(argv
, argc
, "route-map", &idx
))
9738 return bgp_show_route_map(vty
, bgp
, argv
[idx
+ 1]->arg
, afi
,
9739 safi
, bgp_show_type_route_map
);
9741 if (argv_find(argv
, argc
, "community-list", &idx
)) {
9742 const char *clist_number_or_name
= argv
[++idx
]->arg
;
9743 if (++idx
< argc
&& strmatch(argv
[idx
]->text
, "exact-match"))
9745 return bgp_show_community_list(vty
, bgp
, clist_number_or_name
,
9746 exact_match
, afi
, safi
);
9749 if (argv_find(argv
, argc
, "A.B.C.D/M", &idx
)
9750 || argv_find(argv
, argc
, "X:X::X:X/M", &idx
))
9751 return bgp_show_prefix_longer(vty
, bgp
, argv
[idx
]->arg
, afi
,
9753 bgp_show_type_prefix_longer
);
9758 /* BGP route print out function with JSON */
9759 DEFUN (show_ip_bgp_json
,
9760 show_ip_bgp_json_cmd
,
9761 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]]\
9763 |dampening <flap-statistics|dampened-paths>\
9764 |community [AA:NN|local-AS|no-advertise|no-export\
9765 |graceful-shutdown|no-peer|blackhole|llgr-stale|no-llgr\
9766 |accept-own|accept-own-nexthop|route-filter-v6\
9767 |route-filter-v4|route-filter-translated-v6\
9768 |route-filter-translated-v4] [exact-match]\
9773 BGP_INSTANCE_HELP_STR
9775 BGP_SAFI_WITH_LABEL_HELP_STR
9776 "Display only routes with non-natural netmasks\n"
9777 "Display detailed information about dampening\n"
9778 "Display flap statistics of routes\n"
9779 "Display paths suppressed due to dampening\n"
9780 "Display routes matching the communities\n"
9782 "Do not send outside local AS (well-known community)\n"
9783 "Do not advertise to any peer (well-known community)\n"
9784 "Do not export to next AS (well-known community)\n"
9785 "Graceful shutdown (well-known community)\n"
9786 "Do not export to any peer (well-known community)\n"
9787 "Inform EBGP peers to blackhole traffic to prefix (well-known community)\n"
9788 "Staled Long-lived Graceful Restart VPN route (well-known community)\n"
9789 "Removed because Long-lived Graceful Restart was not enabled for VPN route (well-known community)\n"
9790 "Should accept local VPN route if exported and imported into different VRF (well-known community)\n"
9791 "Should accept VPN route with local nexthop (well-known community)\n"
9792 "RT VPNv6 route filtering (well-known community)\n"
9793 "RT VPNv4 route filtering (well-known community)\n"
9794 "RT translated VPNv6 route filtering (well-known community)\n"
9795 "RT translated VPNv4 route filtering (well-known community)\n"
9796 "Exact match of the communities\n"
9799 afi_t afi
= AFI_IP6
;
9800 safi_t safi
= SAFI_UNICAST
;
9801 enum bgp_show_type sh_type
= bgp_show_type_normal
;
9802 struct bgp
*bgp
= NULL
;
9804 int exact_match
= 0;
9805 bool uj
= use_json(argc
, argv
);
9810 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
9815 if (argv_find(argv
, argc
, "cidr-only", &idx
))
9816 return bgp_show(vty
, bgp
, afi
, safi
, bgp_show_type_cidr_only
,
9819 if (argv_find(argv
, argc
, "dampening", &idx
)) {
9820 if (argv_find(argv
, argc
, "dampened-paths", &idx
))
9821 return bgp_show(vty
, bgp
, afi
, safi
,
9822 bgp_show_type_dampend_paths
, NULL
, uj
);
9823 else if (argv_find(argv
, argc
, "flap-statistics", &idx
))
9824 return bgp_show(vty
, bgp
, afi
, safi
,
9825 bgp_show_type_flap_statistics
, NULL
,
9829 if (argv_find(argv
, argc
, "community", &idx
)) {
9830 char *maybecomm
= NULL
;
9831 char *community
= NULL
;
9833 if (idx
+ 1 < argc
) {
9834 if (argv
[idx
+ 1]->type
== VARIABLE_TKN
)
9835 maybecomm
= argv
[idx
+ 1]->arg
;
9837 maybecomm
= argv
[idx
+ 1]->text
;
9840 if (maybecomm
&& !strmatch(maybecomm
, "json")
9841 && !strmatch(maybecomm
, "exact-match"))
9842 community
= maybecomm
;
9844 if (argv_find(argv
, argc
, "exact-match", &idx
))
9848 return bgp_show_community(vty
, bgp
, community
,
9849 exact_match
, afi
, safi
, uj
);
9851 return (bgp_show(vty
, bgp
, afi
, safi
,
9852 bgp_show_type_community_all
, NULL
,
9856 return bgp_show(vty
, bgp
, afi
, safi
, sh_type
, NULL
, uj
);
9859 DEFUN (show_ip_bgp_route
,
9860 show_ip_bgp_route_cmd
,
9861 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]]"
9862 "<A.B.C.D|A.B.C.D/M|X:X::X:X|X:X::X:X/M> [<bestpath|multipath>] [json]",
9866 BGP_INSTANCE_HELP_STR
9868 BGP_SAFI_WITH_LABEL_HELP_STR
9869 "Network in the BGP routing table to display\n"
9871 "Network in the BGP routing table to display\n"
9873 "Display only the bestpath\n"
9874 "Display only multipaths\n"
9877 int prefix_check
= 0;
9879 afi_t afi
= AFI_IP6
;
9880 safi_t safi
= SAFI_UNICAST
;
9881 char *prefix
= NULL
;
9882 struct bgp
*bgp
= NULL
;
9883 enum bgp_path_type path_type
;
9884 bool uj
= use_json(argc
, argv
);
9888 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
9895 "Specified 'all' vrf's but this command currently only works per view/vrf\n");
9899 /* <A.B.C.D|A.B.C.D/M|X:X::X:X|X:X::X:X/M> */
9900 if (argv_find(argv
, argc
, "A.B.C.D", &idx
)
9901 || argv_find(argv
, argc
, "X:X::X:X", &idx
))
9903 else if (argv_find(argv
, argc
, "A.B.C.D/M", &idx
)
9904 || argv_find(argv
, argc
, "X:X::X:X/M", &idx
))
9907 if ((argv
[idx
]->type
== IPV6_TKN
|| argv
[idx
]->type
== IPV6_PREFIX_TKN
)
9908 && afi
!= AFI_IP6
) {
9910 "%% Cannot specify IPv6 address or prefix with IPv4 AFI\n");
9913 if ((argv
[idx
]->type
== IPV4_TKN
|| argv
[idx
]->type
== IPV4_PREFIX_TKN
)
9916 "%% Cannot specify IPv4 address or prefix with IPv6 AFI\n");
9920 prefix
= argv
[idx
]->arg
;
9922 /* [<bestpath|multipath>] */
9923 if (argv_find(argv
, argc
, "bestpath", &idx
))
9924 path_type
= BGP_PATH_SHOW_BESTPATH
;
9925 else if (argv_find(argv
, argc
, "multipath", &idx
))
9926 path_type
= BGP_PATH_SHOW_MULTIPATH
;
9928 path_type
= BGP_PATH_SHOW_ALL
;
9930 return bgp_show_route(vty
, bgp
, prefix
, afi
, safi
, NULL
, prefix_check
,
9934 DEFUN (show_ip_bgp_regexp
,
9935 show_ip_bgp_regexp_cmd
,
9936 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] regexp REGEX...",
9940 BGP_INSTANCE_HELP_STR
9942 BGP_SAFI_WITH_LABEL_HELP_STR
9943 "Display routes matching the AS path regular expression\n"
9944 "A regular-expression (1234567890_^|[,{}() ]$*+.?-\\) to match the BGP AS paths\n")
9946 afi_t afi
= AFI_IP6
;
9947 safi_t safi
= SAFI_UNICAST
;
9948 struct bgp
*bgp
= NULL
;
9951 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
9956 // get index of regex
9957 argv_find(argv
, argc
, "regexp", &idx
);
9960 char *regstr
= argv_concat(argv
, argc
, idx
);
9961 int rc
= bgp_show_regexp(vty
, bgp
, (const char *)regstr
, afi
, safi
,
9962 bgp_show_type_regexp
);
9963 XFREE(MTYPE_TMP
, regstr
);
9967 DEFUN (show_ip_bgp_instance_all
,
9968 show_ip_bgp_instance_all_cmd
,
9969 "show [ip] bgp <view|vrf> all ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] [json]",
9973 BGP_INSTANCE_ALL_HELP_STR
9975 BGP_SAFI_WITH_LABEL_HELP_STR
9979 safi_t safi
= SAFI_UNICAST
;
9980 struct bgp
*bgp
= NULL
;
9982 bool uj
= use_json(argc
, argv
);
9987 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
9992 bgp_show_all_instances_routes_vty(vty
, afi
, safi
, uj
);
9996 static int bgp_show_regexp(struct vty
*vty
, struct bgp
*bgp
, const char *regstr
,
9997 afi_t afi
, safi_t safi
, enum bgp_show_type type
)
10002 if (!config_bgp_aspath_validate(regstr
)) {
10003 vty_out(vty
, "Invalid character in as-path access-list %s\n",
10005 return CMD_WARNING_CONFIG_FAILED
;
10008 regex
= bgp_regcomp(regstr
);
10010 vty_out(vty
, "Can't compile regexp %s\n", regstr
);
10011 return CMD_WARNING
;
10014 rc
= bgp_show(vty
, bgp
, afi
, safi
, type
, regex
, 0);
10015 bgp_regex_free(regex
);
10019 static int bgp_show_prefix_list(struct vty
*vty
, struct bgp
*bgp
,
10020 const char *prefix_list_str
, afi_t afi
,
10021 safi_t safi
, enum bgp_show_type type
)
10023 struct prefix_list
*plist
;
10025 plist
= prefix_list_lookup(afi
, prefix_list_str
);
10026 if (plist
== NULL
) {
10027 vty_out(vty
, "%% %s is not a valid prefix-list name\n",
10029 return CMD_WARNING
;
10032 return bgp_show(vty
, bgp
, afi
, safi
, type
, plist
, 0);
10035 static int bgp_show_filter_list(struct vty
*vty
, struct bgp
*bgp
,
10036 const char *filter
, afi_t afi
, safi_t safi
,
10037 enum bgp_show_type type
)
10039 struct as_list
*as_list
;
10041 as_list
= as_list_lookup(filter
);
10042 if (as_list
== NULL
) {
10043 vty_out(vty
, "%% %s is not a valid AS-path access-list name\n",
10045 return CMD_WARNING
;
10048 return bgp_show(vty
, bgp
, afi
, safi
, type
, as_list
, 0);
10051 static int bgp_show_route_map(struct vty
*vty
, struct bgp
*bgp
,
10052 const char *rmap_str
, afi_t afi
, safi_t safi
,
10053 enum bgp_show_type type
)
10055 struct route_map
*rmap
;
10057 rmap
= route_map_lookup_by_name(rmap_str
);
10059 vty_out(vty
, "%% %s is not a valid route-map name\n", rmap_str
);
10060 return CMD_WARNING
;
10063 return bgp_show(vty
, bgp
, afi
, safi
, type
, rmap
, 0);
10066 static int bgp_show_community(struct vty
*vty
, struct bgp
*bgp
,
10067 const char *comstr
, int exact
, afi_t afi
,
10068 safi_t safi
, bool use_json
)
10070 struct community
*com
;
10073 com
= community_str2com(comstr
);
10075 vty_out(vty
, "%% Community malformed: %s\n", comstr
);
10076 return CMD_WARNING
;
10079 ret
= bgp_show(vty
, bgp
, afi
, safi
,
10080 (exact
? bgp_show_type_community_exact
10081 : bgp_show_type_community
),
10083 community_free(&com
);
10088 static int bgp_show_community_list(struct vty
*vty
, struct bgp
*bgp
,
10089 const char *com
, int exact
, afi_t afi
,
10092 struct community_list
*list
;
10094 list
= community_list_lookup(bgp_clist
, com
, 0, COMMUNITY_LIST_MASTER
);
10095 if (list
== NULL
) {
10096 vty_out(vty
, "%% %s is not a valid community-list name\n", com
);
10097 return CMD_WARNING
;
10100 return bgp_show(vty
, bgp
, afi
, safi
,
10101 (exact
? bgp_show_type_community_list_exact
10102 : bgp_show_type_community_list
),
10106 static int bgp_show_prefix_longer(struct vty
*vty
, struct bgp
*bgp
,
10107 const char *prefix
, afi_t afi
, safi_t safi
,
10108 enum bgp_show_type type
)
10115 ret
= str2prefix(prefix
, p
);
10117 vty_out(vty
, "%% Malformed Prefix\n");
10118 return CMD_WARNING
;
10121 ret
= bgp_show(vty
, bgp
, afi
, safi
, type
, p
, 0);
10126 static struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
10127 const char *ip_str
, bool use_json
)
10131 union sockunion su
;
10133 /* Get peer sockunion. */
10134 ret
= str2sockunion(ip_str
, &su
);
10136 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
10138 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
10142 json_object
*json_no
= NULL
;
10143 json_no
= json_object_new_object();
10144 json_object_string_add(
10146 "malformedAddressOrName",
10148 vty_out(vty
, "%s\n",
10149 json_object_to_json_string_ext(
10151 JSON_C_TO_STRING_PRETTY
));
10152 json_object_free(json_no
);
10155 "%% Malformed address or name: %s\n",
10163 /* Peer structure lookup. */
10164 peer
= peer_lookup(bgp
, &su
);
10167 json_object
*json_no
= NULL
;
10168 json_no
= json_object_new_object();
10169 json_object_string_add(json_no
, "warning",
10170 "No such neighbor in this view/vrf");
10171 vty_out(vty
, "%s\n",
10172 json_object_to_json_string_ext(
10173 json_no
, JSON_C_TO_STRING_PRETTY
));
10174 json_object_free(json_no
);
10176 vty_out(vty
, "No such neighbor in this view/vrf\n");
10184 BGP_STATS_MAXBITLEN
= 0,
10186 BGP_STATS_PREFIXES
,
10188 BGP_STATS_UNAGGREGATEABLE
,
10189 BGP_STATS_MAX_AGGREGATEABLE
,
10190 BGP_STATS_AGGREGATES
,
10192 BGP_STATS_ASPATH_COUNT
,
10193 BGP_STATS_ASPATH_MAXHOPS
,
10194 BGP_STATS_ASPATH_TOTHOPS
,
10195 BGP_STATS_ASPATH_MAXSIZE
,
10196 BGP_STATS_ASPATH_TOTSIZE
,
10197 BGP_STATS_ASN_HIGHEST
,
10201 static const char *table_stats_strs
[] = {
10202 [BGP_STATS_PREFIXES
] = "Total Prefixes",
10203 [BGP_STATS_TOTPLEN
] = "Average prefix length",
10204 [BGP_STATS_RIB
] = "Total Advertisements",
10205 [BGP_STATS_UNAGGREGATEABLE
] = "Unaggregateable prefixes",
10206 [BGP_STATS_MAX_AGGREGATEABLE
] =
10207 "Maximum aggregateable prefixes",
10208 [BGP_STATS_AGGREGATES
] = "BGP Aggregate advertisements",
10209 [BGP_STATS_SPACE
] = "Address space advertised",
10210 [BGP_STATS_ASPATH_COUNT
] = "Advertisements with paths",
10211 [BGP_STATS_ASPATH_MAXHOPS
] = "Longest AS-Path (hops)",
10212 [BGP_STATS_ASPATH_MAXSIZE
] = "Largest AS-Path (bytes)",
10213 [BGP_STATS_ASPATH_TOTHOPS
] = "Average AS-Path length (hops)",
10214 [BGP_STATS_ASPATH_TOTSIZE
] = "Average AS-Path size (bytes)",
10215 [BGP_STATS_ASN_HIGHEST
] = "Highest public ASN",
10216 [BGP_STATS_MAX
] = NULL
,
10219 struct bgp_table_stats
{
10220 struct bgp_table
*table
;
10221 unsigned long long counts
[BGP_STATS_MAX
];
10222 double total_space
;
10226 #define TALLY_SIGFIG 100000
10227 static unsigned long
10228 ravg_tally (unsigned long count
, unsigned long oldavg
, unsigned long newval
)
10230 unsigned long newtot
= (count
-1) * oldavg
+ (newval
* TALLY_SIGFIG
);
10231 unsigned long res
= (newtot
* TALLY_SIGFIG
) / count
;
10232 unsigned long ret
= newtot
/ count
;
10234 if ((res
% TALLY_SIGFIG
) > (TALLY_SIGFIG
/2))
10241 static void bgp_table_stats_rn(struct bgp_node
*rn
, struct bgp_node
*top
,
10242 struct bgp_table_stats
*ts
, unsigned int space
)
10244 struct bgp_node
*prn
= bgp_node_parent_nolock(rn
);
10245 struct bgp_path_info
*pi
;
10250 if (!bgp_node_has_bgp_path_info_data(rn
))
10253 ts
->counts
[BGP_STATS_PREFIXES
]++;
10254 ts
->counts
[BGP_STATS_TOTPLEN
] += rn
->p
.prefixlen
;
10257 ts
->counts
[BGP_STATS_AVGPLEN
]
10258 = ravg_tally (ts
->counts
[BGP_STATS_PREFIXES
],
10259 ts
->counts
[BGP_STATS_AVGPLEN
],
10263 /* check if the prefix is included by any other announcements */
10264 while (prn
&& !bgp_node_has_bgp_path_info_data(prn
))
10265 prn
= bgp_node_parent_nolock(prn
);
10267 if (prn
== NULL
|| prn
== top
) {
10268 ts
->counts
[BGP_STATS_UNAGGREGATEABLE
]++;
10269 /* announced address space */
10271 ts
->total_space
+= pow(2.0, space
- rn
->p
.prefixlen
);
10272 } else if (bgp_node_has_bgp_path_info_data(prn
))
10273 ts
->counts
[BGP_STATS_MAX_AGGREGATEABLE
]++;
10276 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
10277 ts
->counts
[BGP_STATS_RIB
]++;
10280 && (CHECK_FLAG(pi
->attr
->flag
,
10281 ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
))))
10282 ts
->counts
[BGP_STATS_AGGREGATES
]++;
10284 /* as-path stats */
10285 if (pi
->attr
&& pi
->attr
->aspath
) {
10286 unsigned int hops
= aspath_count_hops(pi
->attr
->aspath
);
10287 unsigned int size
= aspath_size(pi
->attr
->aspath
);
10288 as_t highest
= aspath_highest(pi
->attr
->aspath
);
10290 ts
->counts
[BGP_STATS_ASPATH_COUNT
]++;
10292 if (hops
> ts
->counts
[BGP_STATS_ASPATH_MAXHOPS
])
10293 ts
->counts
[BGP_STATS_ASPATH_MAXHOPS
] = hops
;
10295 if (size
> ts
->counts
[BGP_STATS_ASPATH_MAXSIZE
])
10296 ts
->counts
[BGP_STATS_ASPATH_MAXSIZE
] = size
;
10298 ts
->counts
[BGP_STATS_ASPATH_TOTHOPS
] += hops
;
10299 ts
->counts
[BGP_STATS_ASPATH_TOTSIZE
] += size
;
10301 ts
->counts
[BGP_STATS_ASPATH_AVGHOPS
]
10302 = ravg_tally (ts
->counts
[BGP_STATS_ASPATH_COUNT
],
10303 ts
->counts
[BGP_STATS_ASPATH_AVGHOPS
],
10305 ts
->counts
[BGP_STATS_ASPATH_AVGSIZE
]
10306 = ravg_tally (ts
->counts
[BGP_STATS_ASPATH_COUNT
],
10307 ts
->counts
[BGP_STATS_ASPATH_AVGSIZE
],
10310 if (highest
> ts
->counts
[BGP_STATS_ASN_HIGHEST
])
10311 ts
->counts
[BGP_STATS_ASN_HIGHEST
] = highest
;
10316 static int bgp_table_stats_walker(struct thread
*t
)
10318 struct bgp_node
*rn
, *nrn
;
10319 struct bgp_node
*top
;
10320 struct bgp_table_stats
*ts
= THREAD_ARG(t
);
10321 unsigned int space
= 0;
10323 if (!(top
= bgp_table_top(ts
->table
)))
10326 switch (ts
->table
->afi
) {
10328 space
= IPV4_MAX_BITLEN
;
10331 space
= IPV6_MAX_BITLEN
;
10337 ts
->counts
[BGP_STATS_MAXBITLEN
] = space
;
10339 for (rn
= top
; rn
; rn
= bgp_route_next(rn
)) {
10340 if (ts
->table
->safi
== SAFI_MPLS_VPN
) {
10341 struct bgp_table
*table
;
10343 table
= bgp_node_get_bgp_table_info(rn
);
10347 top
= bgp_table_top(table
);
10348 for (nrn
= bgp_table_top(table
); nrn
;
10349 nrn
= bgp_route_next(nrn
))
10350 bgp_table_stats_rn(nrn
, top
, ts
, space
);
10352 bgp_table_stats_rn(rn
, top
, ts
, space
);
10359 static int bgp_table_stats(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
10362 struct bgp_table_stats ts
;
10365 if (!bgp
->rib
[afi
][safi
]) {
10366 vty_out(vty
, "%% No RIB exist's for the AFI(%d)/SAFI(%d)\n",
10368 return CMD_WARNING
;
10371 vty_out(vty
, "BGP %s RIB statistics\n", afi_safi_print(afi
, safi
));
10373 /* labeled-unicast routes live in the unicast table */
10374 if (safi
== SAFI_LABELED_UNICAST
)
10375 safi
= SAFI_UNICAST
;
10377 memset(&ts
, 0, sizeof(ts
));
10378 ts
.table
= bgp
->rib
[afi
][safi
];
10379 thread_execute(bm
->master
, bgp_table_stats_walker
, &ts
, 0);
10381 for (i
= 0; i
< BGP_STATS_MAX
; i
++) {
10382 if (!table_stats_strs
[i
])
10387 case BGP_STATS_ASPATH_AVGHOPS
:
10388 case BGP_STATS_ASPATH_AVGSIZE
:
10389 case BGP_STATS_AVGPLEN
:
10390 vty_out (vty
, "%-30s: ", table_stats_strs
[i
]);
10391 vty_out (vty
, "%12.2f",
10392 (float)ts
.counts
[i
] / (float)TALLY_SIGFIG
);
10395 case BGP_STATS_ASPATH_TOTHOPS
:
10396 case BGP_STATS_ASPATH_TOTSIZE
:
10397 vty_out(vty
, "%-30s: ", table_stats_strs
[i
]);
10398 vty_out(vty
, "%12.2f",
10400 ? (float)ts
.counts
[i
]
10402 [BGP_STATS_ASPATH_COUNT
]
10405 case BGP_STATS_TOTPLEN
:
10406 vty_out(vty
, "%-30s: ", table_stats_strs
[i
]);
10407 vty_out(vty
, "%12.2f",
10409 ? (float)ts
.counts
[i
]
10411 [BGP_STATS_PREFIXES
]
10414 case BGP_STATS_SPACE
:
10415 vty_out(vty
, "%-30s: ", table_stats_strs
[i
]);
10416 vty_out(vty
, "%12g\n", ts
.total_space
);
10418 if (afi
== AFI_IP6
) {
10419 vty_out(vty
, "%30s: ", "/32 equivalent ");
10420 vty_out(vty
, "%12g\n",
10421 ts
.total_space
* pow(2.0, -128 + 32));
10422 vty_out(vty
, "%30s: ", "/48 equivalent ");
10423 vty_out(vty
, "%12g\n",
10424 ts
.total_space
* pow(2.0, -128 + 48));
10426 vty_out(vty
, "%30s: ", "% announced ");
10427 vty_out(vty
, "%12.2f\n",
10428 ts
.total_space
* 100. * pow(2.0, -32));
10429 vty_out(vty
, "%30s: ", "/8 equivalent ");
10430 vty_out(vty
, "%12.2f\n",
10431 ts
.total_space
* pow(2.0, -32 + 8));
10432 vty_out(vty
, "%30s: ", "/24 equivalent ");
10433 vty_out(vty
, "%12.2f\n",
10434 ts
.total_space
* pow(2.0, -32 + 24));
10438 vty_out(vty
, "%-30s: ", table_stats_strs
[i
]);
10439 vty_out(vty
, "%12llu", ts
.counts
[i
]);
10442 vty_out(vty
, "\n");
10444 return CMD_SUCCESS
;
10456 PCOUNT_PFCNT
, /* the figure we display to users */
10460 static const char *pcount_strs
[] = {
10461 [PCOUNT_ADJ_IN
] = "Adj-in",
10462 [PCOUNT_DAMPED
] = "Damped",
10463 [PCOUNT_REMOVED
] = "Removed",
10464 [PCOUNT_HISTORY
] = "History",
10465 [PCOUNT_STALE
] = "Stale",
10466 [PCOUNT_VALID
] = "Valid",
10467 [PCOUNT_ALL
] = "All RIB",
10468 [PCOUNT_COUNTED
] = "PfxCt counted",
10469 [PCOUNT_PFCNT
] = "Useable",
10470 [PCOUNT_MAX
] = NULL
,
10473 struct peer_pcounts
{
10474 unsigned int count
[PCOUNT_MAX
];
10475 const struct peer
*peer
;
10476 const struct bgp_table
*table
;
10479 static int bgp_peer_count_walker(struct thread
*t
)
10481 struct bgp_node
*rn
;
10482 struct peer_pcounts
*pc
= THREAD_ARG(t
);
10483 const struct peer
*peer
= pc
->peer
;
10485 for (rn
= bgp_table_top(pc
->table
); rn
; rn
= bgp_route_next(rn
)) {
10486 struct bgp_adj_in
*ain
;
10487 struct bgp_path_info
*pi
;
10489 for (ain
= rn
->adj_in
; ain
; ain
= ain
->next
)
10490 if (ain
->peer
== peer
)
10491 pc
->count
[PCOUNT_ADJ_IN
]++;
10493 for (pi
= bgp_node_get_bgp_path_info(rn
); pi
; pi
= pi
->next
) {
10495 if (pi
->peer
!= peer
)
10498 pc
->count
[PCOUNT_ALL
]++;
10500 if (CHECK_FLAG(pi
->flags
, BGP_PATH_DAMPED
))
10501 pc
->count
[PCOUNT_DAMPED
]++;
10502 if (CHECK_FLAG(pi
->flags
, BGP_PATH_HISTORY
))
10503 pc
->count
[PCOUNT_HISTORY
]++;
10504 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
10505 pc
->count
[PCOUNT_REMOVED
]++;
10506 if (CHECK_FLAG(pi
->flags
, BGP_PATH_STALE
))
10507 pc
->count
[PCOUNT_STALE
]++;
10508 if (CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
))
10509 pc
->count
[PCOUNT_VALID
]++;
10510 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_UNUSEABLE
))
10511 pc
->count
[PCOUNT_PFCNT
]++;
10513 if (CHECK_FLAG(pi
->flags
, BGP_PATH_COUNTED
)) {
10514 pc
->count
[PCOUNT_COUNTED
]++;
10515 if (CHECK_FLAG(pi
->flags
, BGP_PATH_UNUSEABLE
))
10517 EC_LIB_DEVELOPMENT
,
10518 "Attempting to count but flags say it is unusable");
10520 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_UNUSEABLE
))
10522 EC_LIB_DEVELOPMENT
,
10523 "Not counted but flags say we should");
10530 static int bgp_peer_counts(struct vty
*vty
, struct peer
*peer
, afi_t afi
,
10531 safi_t safi
, bool use_json
)
10533 struct peer_pcounts pcounts
= {.peer
= peer
};
10535 json_object
*json
= NULL
;
10536 json_object
*json_loop
= NULL
;
10539 json
= json_object_new_object();
10540 json_loop
= json_object_new_object();
10543 if (!peer
|| !peer
->bgp
|| !peer
->afc
[afi
][safi
]
10544 || !peer
->bgp
->rib
[afi
][safi
]) {
10546 json_object_string_add(
10548 "No such neighbor or address family");
10549 vty_out(vty
, "%s\n", json_object_to_json_string(json
));
10550 json_object_free(json
);
10552 vty_out(vty
, "%% No such neighbor or address family\n");
10554 return CMD_WARNING
;
10557 memset(&pcounts
, 0, sizeof(pcounts
));
10558 pcounts
.peer
= peer
;
10559 pcounts
.table
= peer
->bgp
->rib
[afi
][safi
];
10561 /* in-place call via thread subsystem so as to record execution time
10562 * stats for the thread-walk (i.e. ensure this can't be blamed on
10563 * on just vty_read()).
10565 thread_execute(bm
->master
, bgp_peer_count_walker
, &pcounts
, 0);
10568 json_object_string_add(json
, "prefixCountsFor", peer
->host
);
10569 json_object_string_add(json
, "multiProtocol",
10570 afi_safi_print(afi
, safi
));
10571 json_object_int_add(json
, "pfxCounter",
10572 peer
->pcount
[afi
][safi
]);
10574 for (i
= 0; i
< PCOUNT_MAX
; i
++)
10575 json_object_int_add(json_loop
, pcount_strs
[i
],
10578 json_object_object_add(json
, "ribTableWalkCounters", json_loop
);
10580 if (pcounts
.count
[PCOUNT_PFCNT
] != peer
->pcount
[afi
][safi
]) {
10581 json_object_string_add(json
, "pfxctDriftFor",
10583 json_object_string_add(
10584 json
, "recommended",
10585 "Please report this bug, with the above command output");
10587 vty_out(vty
, "%s\n", json_object_to_json_string_ext(
10588 json
, JSON_C_TO_STRING_PRETTY
));
10589 json_object_free(json
);
10593 && bgp_flag_check(peer
->bgp
, BGP_FLAG_SHOW_HOSTNAME
)) {
10594 vty_out(vty
, "Prefix counts for %s/%s, %s\n",
10595 peer
->hostname
, peer
->host
,
10596 afi_safi_print(afi
, safi
));
10598 vty_out(vty
, "Prefix counts for %s, %s\n", peer
->host
,
10599 afi_safi_print(afi
, safi
));
10602 vty_out(vty
, "PfxCt: %ld\n", peer
->pcount
[afi
][safi
]);
10603 vty_out(vty
, "\nCounts from RIB table walk:\n\n");
10605 for (i
= 0; i
< PCOUNT_MAX
; i
++)
10606 vty_out(vty
, "%20s: %-10d\n", pcount_strs
[i
],
10609 if (pcounts
.count
[PCOUNT_PFCNT
] != peer
->pcount
[afi
][safi
]) {
10610 vty_out(vty
, "%s [pcount] PfxCt drift!\n", peer
->host
);
10612 "Please report this bug, with the above command output\n");
10616 return CMD_SUCCESS
;
10619 DEFUN (show_ip_bgp_instance_neighbor_prefix_counts
,
10620 show_ip_bgp_instance_neighbor_prefix_counts_cmd
,
10621 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_CMD_STR
"]] "
10622 "neighbors <A.B.C.D|X:X::X:X|WORD> prefix-counts [json]",
10626 BGP_INSTANCE_HELP_STR
10629 "Detailed information on TCP and BGP neighbor connections\n"
10630 "Neighbor to display information about\n"
10631 "Neighbor to display information about\n"
10632 "Neighbor on BGP configured interface\n"
10633 "Display detailed prefix count information\n"
10636 afi_t afi
= AFI_IP6
;
10637 safi_t safi
= SAFI_UNICAST
;
10640 struct bgp
*bgp
= NULL
;
10641 bool uj
= use_json(argc
, argv
);
10646 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
10649 return CMD_WARNING
;
10651 argv_find(argv
, argc
, "neighbors", &idx
);
10652 peer
= peer_lookup_in_view(vty
, bgp
, argv
[idx
+ 1]->arg
, uj
);
10654 return CMD_WARNING
;
10656 return bgp_peer_counts(vty
, peer
, AFI_IP
, SAFI_UNICAST
, uj
);
10659 #ifdef KEEP_OLD_VPN_COMMANDS
10660 DEFUN (show_ip_bgp_vpn_neighbor_prefix_counts
,
10661 show_ip_bgp_vpn_neighbor_prefix_counts_cmd
,
10662 "show [ip] bgp <vpnv4|vpnv6> all neighbors <A.B.C.D|X:X::X:X|WORD> prefix-counts [json]",
10667 "Display information about all VPNv4 NLRIs\n"
10668 "Detailed information on TCP and BGP neighbor connections\n"
10669 "Neighbor to display information about\n"
10670 "Neighbor to display information about\n"
10671 "Neighbor on BGP configured interface\n"
10672 "Display detailed prefix count information\n"
10677 bool uj
= use_json(argc
, argv
);
10679 peer
= peer_lookup_in_view(vty
, NULL
, argv
[idx_peer
]->arg
, uj
);
10681 return CMD_WARNING
;
10683 return bgp_peer_counts(vty
, peer
, AFI_IP
, SAFI_MPLS_VPN
, uj
);
10686 DEFUN (show_ip_bgp_vpn_all_route_prefix
,
10687 show_ip_bgp_vpn_all_route_prefix_cmd
,
10688 "show [ip] bgp <vpnv4|vpnv6> all <A.B.C.D|A.B.C.D/M> [json]",
10693 "Display information about all VPNv4 NLRIs\n"
10694 "Network in the BGP routing table to display\n"
10695 "Network in the BGP routing table to display\n"
10699 char *network
= NULL
;
10700 struct bgp
*bgp
= bgp_get_default();
10702 vty_out(vty
, "Can't find default instance\n");
10703 return CMD_WARNING
;
10706 if (argv_find(argv
, argc
, "A.B.C.D", &idx
))
10707 network
= argv
[idx
]->arg
;
10708 else if (argv_find(argv
, argc
, "A.B.C.D/M", &idx
))
10709 network
= argv
[idx
]->arg
;
10711 vty_out(vty
, "Unable to figure out Network\n");
10712 return CMD_WARNING
;
10715 return bgp_show_route(vty
, bgp
, network
, AFI_IP
, SAFI_MPLS_VPN
, NULL
, 0,
10716 BGP_PATH_SHOW_ALL
, use_json(argc
, argv
));
10718 #endif /* KEEP_OLD_VPN_COMMANDS */
10720 DEFUN (show_ip_bgp_l2vpn_evpn_all_route_prefix
,
10721 show_ip_bgp_l2vpn_evpn_all_route_prefix_cmd
,
10722 "show [ip] bgp l2vpn evpn all <A.B.C.D|A.B.C.D/M> [json]",
10728 "Display information about all EVPN NLRIs\n"
10729 "Network in the BGP routing table to display\n"
10730 "Network in the BGP routing table to display\n"
10734 char *network
= NULL
;
10736 if (argv_find(argv
, argc
, "A.B.C.D", &idx
))
10737 network
= argv
[idx
]->arg
;
10738 else if (argv_find(argv
, argc
, "A.B.C.D/M", &idx
))
10739 network
= argv
[idx
]->arg
;
10741 vty_out(vty
, "Unable to figure out Network\n");
10742 return CMD_WARNING
;
10744 return bgp_show_route(vty
, NULL
, network
, AFI_L2VPN
, SAFI_EVPN
, NULL
, 0,
10745 BGP_PATH_SHOW_ALL
, use_json(argc
, argv
));
10748 static void show_adj_route(struct vty
*vty
, struct peer
*peer
, afi_t afi
,
10749 safi_t safi
, enum bgp_show_adj_route_type type
,
10750 const char *rmap_name
, bool use_json
,
10753 struct bgp_table
*table
;
10754 struct bgp_adj_in
*ain
;
10755 struct bgp_adj_out
*adj
;
10756 unsigned long output_count
;
10757 unsigned long filtered_count
;
10758 struct bgp_node
*rn
;
10764 struct update_subgroup
*subgrp
;
10765 json_object
*json_scode
= NULL
;
10766 json_object
*json_ocode
= NULL
;
10767 json_object
*json_ar
= NULL
;
10768 struct peer_af
*paf
;
10769 bool route_filtered
;
10772 json_scode
= json_object_new_object();
10773 json_ocode
= json_object_new_object();
10774 json_ar
= json_object_new_object();
10776 json_object_string_add(json_scode
, "suppressed", "s");
10777 json_object_string_add(json_scode
, "damped", "d");
10778 json_object_string_add(json_scode
, "history", "h");
10779 json_object_string_add(json_scode
, "valid", "*");
10780 json_object_string_add(json_scode
, "best", ">");
10781 json_object_string_add(json_scode
, "multipath", "=");
10782 json_object_string_add(json_scode
, "internal", "i");
10783 json_object_string_add(json_scode
, "ribFailure", "r");
10784 json_object_string_add(json_scode
, "stale", "S");
10785 json_object_string_add(json_scode
, "removed", "R");
10787 json_object_string_add(json_ocode
, "igp", "i");
10788 json_object_string_add(json_ocode
, "egp", "e");
10789 json_object_string_add(json_ocode
, "incomplete", "?");
10796 json_object_string_add(json
, "alert", "no BGP");
10797 vty_out(vty
, "%s\n", json_object_to_json_string(json
));
10798 json_object_free(json
);
10800 vty_out(vty
, "%% No bgp\n");
10804 /* labeled-unicast routes live in the unicast table */
10805 if (safi
== SAFI_LABELED_UNICAST
)
10806 table
= bgp
->rib
[afi
][SAFI_UNICAST
];
10808 table
= bgp
->rib
[afi
][safi
];
10810 output_count
= filtered_count
= 0;
10811 subgrp
= peer_subgroup(peer
, afi
, safi
);
10813 if (type
== bgp_show_adj_route_advertised
&& subgrp
10814 && CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
)) {
10816 json_object_int_add(json
, "bgpTableVersion",
10818 json_object_string_add(json
, "bgpLocalRouterId",
10819 inet_ntoa(bgp
->router_id
));
10820 json_object_int_add(json
, "defaultLocPrf",
10821 bgp
->default_local_pref
);
10822 json_object_int_add(json
, "localAS", bgp
->as
);
10823 json_object_object_add(json
, "bgpStatusCodes",
10825 json_object_object_add(json
, "bgpOriginCodes",
10827 json_object_string_add(
10828 json
, "bgpOriginatingDefaultNetwork",
10829 (afi
== AFI_IP
) ? "0.0.0.0/0" : "::/0");
10831 vty_out(vty
, "BGP table version is %" PRIu64
10832 ", local router ID is %s, vrf id ",
10833 table
->version
, inet_ntoa(bgp
->router_id
));
10834 if (bgp
->vrf_id
== VRF_UNKNOWN
)
10835 vty_out(vty
, "%s", VRFID_NONE_STR
);
10837 vty_out(vty
, "%u", bgp
->vrf_id
);
10838 vty_out(vty
, "\n");
10839 vty_out(vty
, "Default local pref %u, ",
10840 bgp
->default_local_pref
);
10841 vty_out(vty
, "local AS %u\n", bgp
->as
);
10842 vty_out(vty
, BGP_SHOW_SCODE_HEADER
);
10843 vty_out(vty
, BGP_SHOW_NCODE_HEADER
);
10844 vty_out(vty
, BGP_SHOW_OCODE_HEADER
);
10846 vty_out(vty
, "Originating default network %s\n\n",
10847 (afi
== AFI_IP
) ? "0.0.0.0/0" : "::/0");
10852 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
10853 if (type
== bgp_show_adj_route_received
10854 || type
== bgp_show_adj_route_filtered
) {
10855 for (ain
= rn
->adj_in
; ain
; ain
= ain
->next
) {
10856 if (ain
->peer
!= peer
|| !ain
->attr
)
10861 json_object_int_add(
10862 json
, "bgpTableVersion",
10864 json_object_string_add(
10866 "bgpLocalRouterId",
10869 json_object_int_add(json
,
10871 bgp
->default_local_pref
);
10872 json_object_int_add(json
,
10873 "localAS", bgp
->as
);
10874 json_object_object_add(
10875 json
, "bgpStatusCodes",
10877 json_object_object_add(
10878 json
, "bgpOriginCodes",
10882 "BGP table version is 0, local router ID is %s, vrf id ",
10885 if (bgp
->vrf_id
== VRF_UNKNOWN
)
10891 vty_out(vty
, "\n");
10893 "Default local pref %u, ",
10894 bgp
->default_local_pref
);
10895 vty_out(vty
, "local AS %u\n",
10898 BGP_SHOW_SCODE_HEADER
);
10900 BGP_SHOW_NCODE_HEADER
);
10902 BGP_SHOW_OCODE_HEADER
);
10908 vty_out(vty
, BGP_SHOW_HEADER
);
10912 bgp_attr_dup(&attr
, ain
->attr
);
10913 route_filtered
= false;
10915 /* Filter prefix using distribute list,
10916 * filter list or prefix list
10918 if ((bgp_input_filter(peer
, &rn
->p
, &attr
, afi
,
10919 safi
)) == FILTER_DENY
)
10920 route_filtered
= true;
10922 /* Filter prefix using route-map */
10923 ret
= bgp_input_modifier(peer
, &rn
->p
, &attr
,
10924 afi
, safi
, rmap_name
);
10926 if (type
== bgp_show_adj_route_filtered
&&
10927 !route_filtered
&& ret
!= RMAP_DENY
) {
10928 bgp_attr_undup(&attr
, ain
->attr
);
10932 if (type
== bgp_show_adj_route_received
&&
10933 (route_filtered
|| ret
== RMAP_DENY
))
10936 route_vty_out_tmp(vty
, &rn
->p
, &attr
, safi
,
10937 use_json
, json_ar
);
10938 bgp_attr_undup(&attr
, ain
->attr
);
10941 } else if (type
== bgp_show_adj_route_advertised
) {
10942 RB_FOREACH (adj
, bgp_adj_out_rb
, &rn
->adj_out
)
10943 SUBGRP_FOREACH_PEER (adj
->subgroup
, paf
) {
10944 if (paf
->peer
!= peer
|| !adj
->attr
)
10949 json_object_int_add(
10953 json_object_string_add(
10955 "bgpLocalRouterId",
10958 json_object_int_add(
10959 json
, "defaultLocPrf",
10960 bgp
->default_local_pref
10962 json_object_int_add(
10965 json_object_object_add(
10969 json_object_object_add(
10975 "BGP table version is %" PRIu64
10976 ", local router ID is %s, vrf id ",
10989 vty_out(vty
, "\n");
10991 "Default local pref %u, ",
10992 bgp
->default_local_pref
10998 BGP_SHOW_SCODE_HEADER
);
11000 BGP_SHOW_NCODE_HEADER
);
11002 BGP_SHOW_OCODE_HEADER
);
11013 bgp_attr_dup(&attr
, adj
->attr
);
11014 ret
= bgp_output_modifier(
11015 peer
, &rn
->p
, &attr
, afi
, safi
,
11018 if (ret
!= RMAP_DENY
) {
11019 route_vty_out_tmp(vty
, &rn
->p
,
11028 bgp_attr_undup(&attr
, adj
->attr
);
11034 json_object_object_add(json
, "advertisedRoutes", json_ar
);
11035 json_object_int_add(json
, "totalPrefixCounter", output_count
);
11036 json_object_int_add(json
, "filteredPrefixCounter",
11039 vty_out(vty
, "%s\n", json_object_to_json_string_ext(
11040 json
, JSON_C_TO_STRING_PRETTY
));
11041 json_object_free(json
);
11042 } else if (output_count
> 0) {
11043 if (filtered_count
> 0)
11045 "\nTotal number of prefixes %ld (%ld filtered)\n",
11046 output_count
, filtered_count
);
11048 vty_out(vty
, "\nTotal number of prefixes %ld\n",
11053 static int peer_adj_routes(struct vty
*vty
, struct peer
*peer
, afi_t afi
,
11054 safi_t safi
, enum bgp_show_adj_route_type type
,
11055 const char *rmap_name
, bool use_json
)
11057 json_object
*json
= NULL
;
11060 json
= json_object_new_object();
11062 if (!peer
|| !peer
->afc
[afi
][safi
]) {
11064 json_object_string_add(
11066 "No such neighbor or address family");
11067 vty_out(vty
, "%s\n", json_object_to_json_string(json
));
11068 json_object_free(json
);
11070 vty_out(vty
, "%% No such neighbor or address family\n");
11072 return CMD_WARNING
;
11075 if ((type
== bgp_show_adj_route_received
11076 || type
== bgp_show_adj_route_filtered
)
11077 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
11078 PEER_FLAG_SOFT_RECONFIG
)) {
11080 json_object_string_add(
11082 "Inbound soft reconfiguration not enabled");
11083 vty_out(vty
, "%s\n", json_object_to_json_string(json
));
11084 json_object_free(json
);
11087 "%% Inbound soft reconfiguration not enabled\n");
11089 return CMD_WARNING
;
11092 show_adj_route(vty
, peer
, afi
, safi
, type
, rmap_name
, use_json
, json
);
11094 return CMD_SUCCESS
;
11097 DEFUN (show_ip_bgp_instance_neighbor_advertised_route
,
11098 show_ip_bgp_instance_neighbor_advertised_route_cmd
,
11099 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] "
11100 "neighbors <A.B.C.D|X:X::X:X|WORD> <advertised-routes|received-routes|filtered-routes> [route-map WORD] [json]",
11104 BGP_INSTANCE_HELP_STR
11106 BGP_SAFI_WITH_LABEL_HELP_STR
11107 "Detailed information on TCP and BGP neighbor connections\n"
11108 "Neighbor to display information about\n"
11109 "Neighbor to display information about\n"
11110 "Neighbor on BGP configured interface\n"
11111 "Display the routes advertised to a BGP neighbor\n"
11112 "Display the received routes from neighbor\n"
11113 "Display the filtered routes received from neighbor\n"
11114 "Route-map to modify the attributes\n"
11115 "Name of the route map\n"
11118 afi_t afi
= AFI_IP6
;
11119 safi_t safi
= SAFI_UNICAST
;
11120 char *rmap_name
= NULL
;
11121 char *peerstr
= NULL
;
11122 struct bgp
*bgp
= NULL
;
11124 enum bgp_show_adj_route_type type
= bgp_show_adj_route_advertised
;
11126 bool uj
= use_json(argc
, argv
);
11131 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
11134 return CMD_WARNING
;
11136 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
11137 argv_find(argv
, argc
, "neighbors", &idx
);
11138 peerstr
= argv
[++idx
]->arg
;
11140 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
11142 return CMD_WARNING
;
11144 if (argv_find(argv
, argc
, "advertised-routes", &idx
))
11145 type
= bgp_show_adj_route_advertised
;
11146 else if (argv_find(argv
, argc
, "received-routes", &idx
))
11147 type
= bgp_show_adj_route_received
;
11148 else if (argv_find(argv
, argc
, "filtered-routes", &idx
))
11149 type
= bgp_show_adj_route_filtered
;
11151 if (argv_find(argv
, argc
, "route-map", &idx
))
11152 rmap_name
= argv
[++idx
]->arg
;
11154 return peer_adj_routes(vty
, peer
, afi
, safi
, type
, rmap_name
, uj
);
11157 DEFUN (show_ip_bgp_neighbor_received_prefix_filter
,
11158 show_ip_bgp_neighbor_received_prefix_filter_cmd
,
11159 "show [ip] bgp [<ipv4|ipv6> [unicast]] neighbors <A.B.C.D|X:X::X:X|WORD> received prefix-filter [json]",
11165 "Address Family modifier\n"
11166 "Detailed information on TCP and BGP neighbor connections\n"
11167 "Neighbor to display information about\n"
11168 "Neighbor to display information about\n"
11169 "Neighbor on BGP configured interface\n"
11170 "Display information received from a BGP neighbor\n"
11171 "Display the prefixlist filter\n"
11174 afi_t afi
= AFI_IP6
;
11175 safi_t safi
= SAFI_UNICAST
;
11176 char *peerstr
= NULL
;
11179 union sockunion su
;
11185 /* show [ip] bgp */
11186 if (argv_find(argv
, argc
, "ip", &idx
))
11188 /* [<ipv4|ipv6> [unicast]] */
11189 if (argv_find(argv
, argc
, "ipv4", &idx
))
11191 if (argv_find(argv
, argc
, "ipv6", &idx
))
11193 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
11194 argv_find(argv
, argc
, "neighbors", &idx
);
11195 peerstr
= argv
[++idx
]->arg
;
11197 bool uj
= use_json(argc
, argv
);
11199 ret
= str2sockunion(peerstr
, &su
);
11201 peer
= peer_lookup_by_conf_if(NULL
, peerstr
);
11204 vty_out(vty
, "{}\n");
11207 "%% Malformed address or name: %s\n",
11209 return CMD_WARNING
;
11212 peer
= peer_lookup(NULL
, &su
);
11215 vty_out(vty
, "{}\n");
11217 vty_out(vty
, "No peer\n");
11218 return CMD_WARNING
;
11222 sprintf(name
, "%s.%d.%d", peer
->host
, afi
, safi
);
11223 count
= prefix_bgp_show_prefix_list(NULL
, afi
, name
, uj
);
11226 vty_out(vty
, "Address Family: %s\n",
11227 afi_safi_print(afi
, safi
));
11228 prefix_bgp_show_prefix_list(vty
, afi
, name
, uj
);
11231 vty_out(vty
, "{}\n");
11233 vty_out(vty
, "No functional output\n");
11236 return CMD_SUCCESS
;
11239 static int bgp_show_neighbor_route(struct vty
*vty
, struct peer
*peer
,
11240 afi_t afi
, safi_t safi
,
11241 enum bgp_show_type type
, bool use_json
)
11243 /* labeled-unicast routes live in the unicast table */
11244 if (safi
== SAFI_LABELED_UNICAST
)
11245 safi
= SAFI_UNICAST
;
11247 if (!peer
|| !peer
->afc
[afi
][safi
]) {
11249 json_object
*json_no
= NULL
;
11250 json_no
= json_object_new_object();
11251 json_object_string_add(
11252 json_no
, "warning",
11253 "No such neighbor or address family");
11254 vty_out(vty
, "%s\n",
11255 json_object_to_json_string(json_no
));
11256 json_object_free(json_no
);
11258 vty_out(vty
, "%% No such neighbor or address family\n");
11259 return CMD_WARNING
;
11262 return bgp_show(vty
, peer
->bgp
, afi
, safi
, type
, &peer
->su
, use_json
);
11265 DEFUN (show_ip_bgp_flowspec_routes_detailed
,
11266 show_ip_bgp_flowspec_routes_detailed_cmd
,
11267 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" flowspec] detail [json]",
11271 BGP_INSTANCE_HELP_STR
11274 "Detailed information on flowspec entries\n"
11277 afi_t afi
= AFI_IP
;
11278 safi_t safi
= SAFI_UNICAST
;
11279 struct bgp
*bgp
= NULL
;
11281 bool uj
= use_json(argc
, argv
);
11286 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
11289 return CMD_WARNING
;
11291 return bgp_show(vty
, bgp
, afi
, safi
, bgp_show_type_detail
, NULL
, uj
);
11294 DEFUN (show_ip_bgp_neighbor_routes
,
11295 show_ip_bgp_neighbor_routes_cmd
,
11296 "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR
" ["BGP_SAFI_WITH_LABEL_CMD_STR
"]] "
11297 "neighbors <A.B.C.D|X:X::X:X|WORD> <flap-statistics|dampened-routes|routes> [json]",
11301 BGP_INSTANCE_HELP_STR
11303 BGP_SAFI_WITH_LABEL_HELP_STR
11304 "Detailed information on TCP and BGP neighbor connections\n"
11305 "Neighbor to display information about\n"
11306 "Neighbor to display information about\n"
11307 "Neighbor on BGP configured interface\n"
11308 "Display flap statistics of the routes learned from neighbor\n"
11309 "Display the dampened routes received from neighbor\n"
11310 "Display routes learned from neighbor\n"
11313 char *peerstr
= NULL
;
11314 struct bgp
*bgp
= NULL
;
11315 afi_t afi
= AFI_IP6
;
11316 safi_t safi
= SAFI_UNICAST
;
11318 enum bgp_show_type sh_type
= bgp_show_type_neighbor
;
11320 bool uj
= use_json(argc
, argv
);
11325 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
11328 return CMD_WARNING
;
11330 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
11331 argv_find(argv
, argc
, "neighbors", &idx
);
11332 peerstr
= argv
[++idx
]->arg
;
11334 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
11336 return CMD_WARNING
;
11338 if (argv_find(argv
, argc
, "flap-statistics", &idx
))
11339 sh_type
= bgp_show_type_flap_neighbor
;
11340 else if (argv_find(argv
, argc
, "dampened-routes", &idx
))
11341 sh_type
= bgp_show_type_damp_neighbor
;
11342 else if (argv_find(argv
, argc
, "routes", &idx
))
11343 sh_type
= bgp_show_type_neighbor
;
11345 return bgp_show_neighbor_route(vty
, peer
, afi
, safi
, sh_type
, uj
);
11348 struct bgp_table
*bgp_distance_table
[AFI_MAX
][SAFI_MAX
];
11350 struct bgp_distance
{
11351 /* Distance value for the IP source prefix. */
11354 /* Name of the access-list to be matched. */
11358 DEFUN (show_bgp_afi_vpn_rd_route
,
11359 show_bgp_afi_vpn_rd_route_cmd
,
11360 "show bgp "BGP_AFI_CMD_STR
" vpn rd ASN:NN_OR_IP-ADDRESS:NN <A.B.C.D/M|X:X::X:X/M> [json]",
11364 "Address Family modifier\n"
11365 "Display information for a route distinguisher\n"
11366 "Route Distinguisher\n"
11367 "Network in the BGP routing table to display\n"
11368 "Network in the BGP routing table to display\n"
11372 struct prefix_rd prd
;
11373 afi_t afi
= AFI_MAX
;
11376 if (!argv_find_and_parse_afi(argv
, argc
, &idx
, &afi
)) {
11377 vty_out(vty
, "%% Malformed Address Family\n");
11378 return CMD_WARNING
;
11381 ret
= str2prefix_rd(argv
[5]->arg
, &prd
);
11383 vty_out(vty
, "%% Malformed Route Distinguisher\n");
11384 return CMD_WARNING
;
11387 return bgp_show_route(vty
, NULL
, argv
[6]->arg
, afi
, SAFI_MPLS_VPN
, &prd
,
11388 0, BGP_PATH_SHOW_ALL
, use_json(argc
, argv
));
11391 static struct bgp_distance
*bgp_distance_new(void)
11393 return XCALLOC(MTYPE_BGP_DISTANCE
, sizeof(struct bgp_distance
));
11396 static void bgp_distance_free(struct bgp_distance
*bdistance
)
11398 XFREE(MTYPE_BGP_DISTANCE
, bdistance
);
11401 static int bgp_distance_set(struct vty
*vty
, const char *distance_str
,
11402 const char *ip_str
, const char *access_list_str
)
11409 struct bgp_node
*rn
;
11410 struct bgp_distance
*bdistance
;
11412 afi
= bgp_node_afi(vty
);
11413 safi
= bgp_node_safi(vty
);
11415 ret
= str2prefix(ip_str
, &p
);
11417 vty_out(vty
, "Malformed prefix\n");
11418 return CMD_WARNING_CONFIG_FAILED
;
11421 distance
= atoi(distance_str
);
11423 /* Get BGP distance node. */
11424 rn
= bgp_node_get(bgp_distance_table
[afi
][safi
], (struct prefix
*)&p
);
11425 bdistance
= bgp_node_get_bgp_distance_info(rn
);
11427 bgp_unlock_node(rn
);
11429 bdistance
= bgp_distance_new();
11430 bgp_node_set_bgp_distance_info(rn
, bdistance
);
11433 /* Set distance value. */
11434 bdistance
->distance
= distance
;
11436 /* Reset access-list configuration. */
11437 if (bdistance
->access_list
) {
11438 XFREE(MTYPE_AS_LIST
, bdistance
->access_list
);
11439 bdistance
->access_list
= NULL
;
11441 if (access_list_str
)
11442 bdistance
->access_list
=
11443 XSTRDUP(MTYPE_AS_LIST
, access_list_str
);
11445 return CMD_SUCCESS
;
11448 static int bgp_distance_unset(struct vty
*vty
, const char *distance_str
,
11449 const char *ip_str
, const char *access_list_str
)
11456 struct bgp_node
*rn
;
11457 struct bgp_distance
*bdistance
;
11459 afi
= bgp_node_afi(vty
);
11460 safi
= bgp_node_safi(vty
);
11462 ret
= str2prefix(ip_str
, &p
);
11464 vty_out(vty
, "Malformed prefix\n");
11465 return CMD_WARNING_CONFIG_FAILED
;
11468 rn
= bgp_node_lookup(bgp_distance_table
[afi
][safi
],
11469 (struct prefix
*)&p
);
11471 vty_out(vty
, "Can't find specified prefix\n");
11472 return CMD_WARNING_CONFIG_FAILED
;
11475 bdistance
= bgp_node_get_bgp_distance_info(rn
);
11476 distance
= atoi(distance_str
);
11478 if (bdistance
->distance
!= distance
) {
11479 vty_out(vty
, "Distance does not match configured\n");
11480 return CMD_WARNING_CONFIG_FAILED
;
11483 XFREE(MTYPE_AS_LIST
, bdistance
->access_list
);
11484 bgp_distance_free(bdistance
);
11486 bgp_node_set_bgp_path_info(rn
, NULL
);
11487 bgp_unlock_node(rn
);
11488 bgp_unlock_node(rn
);
11490 return CMD_SUCCESS
;
11493 /* Apply BGP information to distance method. */
11494 uint8_t bgp_distance_apply(struct prefix
*p
, struct bgp_path_info
*pinfo
,
11495 afi_t afi
, safi_t safi
, struct bgp
*bgp
)
11497 struct bgp_node
*rn
;
11500 struct bgp_distance
*bdistance
;
11501 struct access_list
*alist
;
11502 struct bgp_static
*bgp_static
;
11507 peer
= pinfo
->peer
;
11509 /* Check source address. */
11510 sockunion2hostprefix(&peer
->su
, &q
);
11511 rn
= bgp_node_match(bgp_distance_table
[afi
][safi
], &q
);
11513 bdistance
= bgp_node_get_bgp_distance_info(rn
);
11514 bgp_unlock_node(rn
);
11516 if (bdistance
->access_list
) {
11517 alist
= access_list_lookup(afi
, bdistance
->access_list
);
11519 && access_list_apply(alist
, p
) == FILTER_PERMIT
)
11520 return bdistance
->distance
;
11522 return bdistance
->distance
;
11525 /* Backdoor check. */
11526 rn
= bgp_node_lookup(bgp
->route
[afi
][safi
], p
);
11528 bgp_static
= bgp_node_get_bgp_static_info(rn
);
11529 bgp_unlock_node(rn
);
11531 if (bgp_static
->backdoor
) {
11532 if (bgp
->distance_local
[afi
][safi
])
11533 return bgp
->distance_local
[afi
][safi
];
11535 return ZEBRA_IBGP_DISTANCE_DEFAULT
;
11539 if (peer
->sort
== BGP_PEER_EBGP
) {
11540 if (bgp
->distance_ebgp
[afi
][safi
])
11541 return bgp
->distance_ebgp
[afi
][safi
];
11542 return ZEBRA_EBGP_DISTANCE_DEFAULT
;
11544 if (bgp
->distance_ibgp
[afi
][safi
])
11545 return bgp
->distance_ibgp
[afi
][safi
];
11546 return ZEBRA_IBGP_DISTANCE_DEFAULT
;
11550 DEFUN (bgp_distance
,
11552 "distance bgp (1-255) (1-255) (1-255)",
11553 "Define an administrative distance\n"
11555 "Distance for routes external to the AS\n"
11556 "Distance for routes internal to the AS\n"
11557 "Distance for local routes\n")
11559 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
11560 int idx_number
= 2;
11561 int idx_number_2
= 3;
11562 int idx_number_3
= 4;
11566 afi
= bgp_node_afi(vty
);
11567 safi
= bgp_node_safi(vty
);
11569 bgp
->distance_ebgp
[afi
][safi
] = atoi(argv
[idx_number
]->arg
);
11570 bgp
->distance_ibgp
[afi
][safi
] = atoi(argv
[idx_number_2
]->arg
);
11571 bgp
->distance_local
[afi
][safi
] = atoi(argv
[idx_number_3
]->arg
);
11572 return CMD_SUCCESS
;
11575 DEFUN (no_bgp_distance
,
11576 no_bgp_distance_cmd
,
11577 "no distance bgp [(1-255) (1-255) (1-255)]",
11579 "Define an administrative distance\n"
11581 "Distance for routes external to the AS\n"
11582 "Distance for routes internal to the AS\n"
11583 "Distance for local routes\n")
11585 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
11589 afi
= bgp_node_afi(vty
);
11590 safi
= bgp_node_safi(vty
);
11592 bgp
->distance_ebgp
[afi
][safi
] = 0;
11593 bgp
->distance_ibgp
[afi
][safi
] = 0;
11594 bgp
->distance_local
[afi
][safi
] = 0;
11595 return CMD_SUCCESS
;
11599 DEFUN (bgp_distance_source
,
11600 bgp_distance_source_cmd
,
11601 "distance (1-255) A.B.C.D/M",
11602 "Define an administrative distance\n"
11603 "Administrative distance\n"
11604 "IP source prefix\n")
11606 int idx_number
= 1;
11607 int idx_ipv4_prefixlen
= 2;
11608 bgp_distance_set(vty
, argv
[idx_number
]->arg
,
11609 argv
[idx_ipv4_prefixlen
]->arg
, NULL
);
11610 return CMD_SUCCESS
;
11613 DEFUN (no_bgp_distance_source
,
11614 no_bgp_distance_source_cmd
,
11615 "no distance (1-255) A.B.C.D/M",
11617 "Define an administrative distance\n"
11618 "Administrative distance\n"
11619 "IP source prefix\n")
11621 int idx_number
= 2;
11622 int idx_ipv4_prefixlen
= 3;
11623 bgp_distance_unset(vty
, argv
[idx_number
]->arg
,
11624 argv
[idx_ipv4_prefixlen
]->arg
, NULL
);
11625 return CMD_SUCCESS
;
11628 DEFUN (bgp_distance_source_access_list
,
11629 bgp_distance_source_access_list_cmd
,
11630 "distance (1-255) A.B.C.D/M WORD",
11631 "Define an administrative distance\n"
11632 "Administrative distance\n"
11633 "IP source prefix\n"
11634 "Access list name\n")
11636 int idx_number
= 1;
11637 int idx_ipv4_prefixlen
= 2;
11639 bgp_distance_set(vty
, argv
[idx_number
]->arg
,
11640 argv
[idx_ipv4_prefixlen
]->arg
, argv
[idx_word
]->arg
);
11641 return CMD_SUCCESS
;
11644 DEFUN (no_bgp_distance_source_access_list
,
11645 no_bgp_distance_source_access_list_cmd
,
11646 "no distance (1-255) A.B.C.D/M WORD",
11648 "Define an administrative distance\n"
11649 "Administrative distance\n"
11650 "IP source prefix\n"
11651 "Access list name\n")
11653 int idx_number
= 2;
11654 int idx_ipv4_prefixlen
= 3;
11656 bgp_distance_unset(vty
, argv
[idx_number
]->arg
,
11657 argv
[idx_ipv4_prefixlen
]->arg
, argv
[idx_word
]->arg
);
11658 return CMD_SUCCESS
;
11661 DEFUN (ipv6_bgp_distance_source
,
11662 ipv6_bgp_distance_source_cmd
,
11663 "distance (1-255) X:X::X:X/M",
11664 "Define an administrative distance\n"
11665 "Administrative distance\n"
11666 "IP source prefix\n")
11668 bgp_distance_set(vty
, argv
[1]->arg
, argv
[2]->arg
, NULL
);
11669 return CMD_SUCCESS
;
11672 DEFUN (no_ipv6_bgp_distance_source
,
11673 no_ipv6_bgp_distance_source_cmd
,
11674 "no distance (1-255) X:X::X:X/M",
11676 "Define an administrative distance\n"
11677 "Administrative distance\n"
11678 "IP source prefix\n")
11680 bgp_distance_unset(vty
, argv
[2]->arg
, argv
[3]->arg
, NULL
);
11681 return CMD_SUCCESS
;
11684 DEFUN (ipv6_bgp_distance_source_access_list
,
11685 ipv6_bgp_distance_source_access_list_cmd
,
11686 "distance (1-255) X:X::X:X/M WORD",
11687 "Define an administrative distance\n"
11688 "Administrative distance\n"
11689 "IP source prefix\n"
11690 "Access list name\n")
11692 bgp_distance_set(vty
, argv
[1]->arg
, argv
[2]->arg
, argv
[3]->arg
);
11693 return CMD_SUCCESS
;
11696 DEFUN (no_ipv6_bgp_distance_source_access_list
,
11697 no_ipv6_bgp_distance_source_access_list_cmd
,
11698 "no distance (1-255) X:X::X:X/M WORD",
11700 "Define an administrative distance\n"
11701 "Administrative distance\n"
11702 "IP source prefix\n"
11703 "Access list name\n")
11705 bgp_distance_unset(vty
, argv
[2]->arg
, argv
[3]->arg
, argv
[4]->arg
);
11706 return CMD_SUCCESS
;
11709 DEFUN (bgp_damp_set
,
11711 "bgp dampening [(1-45) [(1-20000) (1-20000) (1-255)]]",
11712 "BGP Specific commands\n"
11713 "Enable route-flap dampening\n"
11714 "Half-life time for the penalty\n"
11715 "Value to start reusing a route\n"
11716 "Value to start suppressing a route\n"
11717 "Maximum duration to suppress a stable route\n")
11719 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
11720 int idx_half_life
= 2;
11722 int idx_suppress
= 4;
11723 int idx_max_suppress
= 5;
11724 int half
= DEFAULT_HALF_LIFE
* 60;
11725 int reuse
= DEFAULT_REUSE
;
11726 int suppress
= DEFAULT_SUPPRESS
;
11727 int max
= 4 * half
;
11730 half
= atoi(argv
[idx_half_life
]->arg
) * 60;
11731 reuse
= atoi(argv
[idx_reuse
]->arg
);
11732 suppress
= atoi(argv
[idx_suppress
]->arg
);
11733 max
= atoi(argv
[idx_max_suppress
]->arg
) * 60;
11734 } else if (argc
== 3) {
11735 half
= atoi(argv
[idx_half_life
]->arg
) * 60;
11739 if (suppress
< reuse
) {
11741 "Suppress value cannot be less than reuse value \n");
11745 return bgp_damp_enable(bgp
, bgp_node_afi(vty
), bgp_node_safi(vty
), half
,
11746 reuse
, suppress
, max
);
11749 DEFUN (bgp_damp_unset
,
11750 bgp_damp_unset_cmd
,
11751 "no bgp dampening [(1-45) [(1-20000) (1-20000) (1-255)]]",
11753 "BGP Specific commands\n"
11754 "Enable route-flap dampening\n"
11755 "Half-life time for the penalty\n"
11756 "Value to start reusing a route\n"
11757 "Value to start suppressing a route\n"
11758 "Maximum duration to suppress a stable route\n")
11760 VTY_DECLVAR_CONTEXT(bgp
, bgp
);
11761 return bgp_damp_disable(bgp
, bgp_node_afi(vty
), bgp_node_safi(vty
));
11764 /* Display specified route of BGP table. */
11765 static int bgp_clear_damp_route(struct vty
*vty
, const char *view_name
,
11766 const char *ip_str
, afi_t afi
, safi_t safi
,
11767 struct prefix_rd
*prd
, int prefix_check
)
11770 struct prefix match
;
11771 struct bgp_node
*rn
;
11772 struct bgp_node
*rm
;
11773 struct bgp_path_info
*pi
;
11774 struct bgp_path_info
*pi_temp
;
11776 struct bgp_table
*table
;
11778 /* BGP structure lookup. */
11780 bgp
= bgp_lookup_by_name(view_name
);
11782 vty_out(vty
, "%% Can't find BGP instance %s\n",
11784 return CMD_WARNING
;
11787 bgp
= bgp_get_default();
11789 vty_out(vty
, "%% No BGP process is configured\n");
11790 return CMD_WARNING
;
11794 /* Check IP address argument. */
11795 ret
= str2prefix(ip_str
, &match
);
11797 vty_out(vty
, "%% address is malformed\n");
11798 return CMD_WARNING
;
11801 match
.family
= afi2family(afi
);
11803 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)
11804 || (safi
== SAFI_EVPN
)) {
11805 for (rn
= bgp_table_top(bgp
->rib
[AFI_IP
][safi
]); rn
;
11806 rn
= bgp_route_next(rn
)) {
11807 if (prd
&& memcmp(rn
->p
.u
.val
, prd
->val
, 8) != 0)
11809 table
= bgp_node_get_bgp_table_info(rn
);
11812 if ((rm
= bgp_node_match(table
, &match
)) == NULL
)
11816 || rm
->p
.prefixlen
== match
.prefixlen
) {
11817 pi
= bgp_node_get_bgp_path_info(rm
);
11819 if (pi
->extra
&& pi
->extra
->damp_info
) {
11820 pi_temp
= pi
->next
;
11821 bgp_damp_info_free(
11822 pi
->extra
->damp_info
,
11830 bgp_unlock_node(rm
);
11833 if ((rn
= bgp_node_match(bgp
->rib
[afi
][safi
], &match
))
11836 || rn
->p
.prefixlen
== match
.prefixlen
) {
11837 pi
= bgp_node_get_bgp_path_info(rn
);
11839 if (pi
->extra
&& pi
->extra
->damp_info
) {
11840 pi_temp
= pi
->next
;
11841 bgp_damp_info_free(
11842 pi
->extra
->damp_info
,
11850 bgp_unlock_node(rn
);
11854 return CMD_SUCCESS
;
11857 DEFUN (clear_ip_bgp_dampening
,
11858 clear_ip_bgp_dampening_cmd
,
11859 "clear ip bgp dampening",
11863 "Clear route flap dampening information\n")
11865 bgp_damp_info_clean();
11866 return CMD_SUCCESS
;
11869 DEFUN (clear_ip_bgp_dampening_prefix
,
11870 clear_ip_bgp_dampening_prefix_cmd
,
11871 "clear ip bgp dampening A.B.C.D/M",
11875 "Clear route flap dampening information\n"
11878 int idx_ipv4_prefixlen
= 4;
11879 return bgp_clear_damp_route(vty
, NULL
, argv
[idx_ipv4_prefixlen
]->arg
,
11880 AFI_IP
, SAFI_UNICAST
, NULL
, 1);
11883 DEFUN (clear_ip_bgp_dampening_address
,
11884 clear_ip_bgp_dampening_address_cmd
,
11885 "clear ip bgp dampening A.B.C.D",
11889 "Clear route flap dampening information\n"
11890 "Network to clear damping information\n")
11893 return bgp_clear_damp_route(vty
, NULL
, argv
[idx_ipv4
]->arg
, AFI_IP
,
11894 SAFI_UNICAST
, NULL
, 0);
11897 DEFUN (clear_ip_bgp_dampening_address_mask
,
11898 clear_ip_bgp_dampening_address_mask_cmd
,
11899 "clear ip bgp dampening A.B.C.D A.B.C.D",
11903 "Clear route flap dampening information\n"
11904 "Network to clear damping information\n"
11908 int idx_ipv4_2
= 5;
11910 char prefix_str
[BUFSIZ
];
11912 ret
= netmask_str2prefix_str(argv
[idx_ipv4
]->arg
, argv
[idx_ipv4_2
]->arg
,
11915 vty_out(vty
, "%% Inconsistent address and mask\n");
11916 return CMD_WARNING
;
11919 return bgp_clear_damp_route(vty
, NULL
, prefix_str
, AFI_IP
, SAFI_UNICAST
,
11923 static void show_bgp_peerhash_entry(struct hash_bucket
*bucket
, void *arg
)
11925 struct vty
*vty
= arg
;
11926 struct peer
*peer
= bucket
->data
;
11927 char buf
[SU_ADDRSTRLEN
];
11929 vty_out(vty
, "\tPeer: %s %s\n", peer
->host
,
11930 sockunion2str(&peer
->su
, buf
, sizeof(buf
)));
11933 DEFUN (show_bgp_peerhash
,
11934 show_bgp_peerhash_cmd
,
11935 "show bgp peerhash",
11938 "Display information about the BGP peerhash\n")
11940 struct list
*instances
= bm
->bgp
;
11941 struct listnode
*node
;
11944 for (ALL_LIST_ELEMENTS_RO(instances
, node
, bgp
)) {
11945 vty_out(vty
, "BGP: %s\n", bgp
->name
);
11946 hash_iterate(bgp
->peerhash
, show_bgp_peerhash_entry
,
11950 return CMD_SUCCESS
;
11953 /* also used for encap safi */
11954 static void bgp_config_write_network_vpn(struct vty
*vty
, struct bgp
*bgp
,
11955 afi_t afi
, safi_t safi
)
11957 struct bgp_node
*prn
;
11958 struct bgp_node
*rn
;
11959 struct bgp_table
*table
;
11961 struct prefix_rd
*prd
;
11962 struct bgp_static
*bgp_static
;
11963 mpls_label_t label
;
11964 char buf
[SU_ADDRSTRLEN
];
11965 char rdbuf
[RD_ADDRSTRLEN
];
11967 /* Network configuration. */
11968 for (prn
= bgp_table_top(bgp
->route
[afi
][safi
]); prn
;
11969 prn
= bgp_route_next(prn
)) {
11970 table
= bgp_node_get_bgp_table_info(prn
);
11974 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
11975 bgp_static
= bgp_node_get_bgp_static_info(rn
);
11976 if (bgp_static
== NULL
)
11980 prd
= (struct prefix_rd
*)&prn
->p
;
11982 /* "network" configuration display. */
11983 prefix_rd2str(prd
, rdbuf
, sizeof(rdbuf
));
11984 label
= decode_label(&bgp_static
->label
);
11986 vty_out(vty
, " network %s/%d rd %s",
11987 inet_ntop(p
->family
, &p
->u
.prefix
, buf
,
11989 p
->prefixlen
, rdbuf
);
11990 if (safi
== SAFI_MPLS_VPN
)
11991 vty_out(vty
, " label %u", label
);
11993 if (bgp_static
->rmap
.name
)
11994 vty_out(vty
, " route-map %s",
11995 bgp_static
->rmap
.name
);
11997 if (bgp_static
->backdoor
)
11998 vty_out(vty
, " backdoor");
12000 vty_out(vty
, "\n");
12005 static void bgp_config_write_network_evpn(struct vty
*vty
, struct bgp
*bgp
,
12006 afi_t afi
, safi_t safi
)
12008 struct bgp_node
*prn
;
12009 struct bgp_node
*rn
;
12010 struct bgp_table
*table
;
12012 struct prefix_rd
*prd
;
12013 struct bgp_static
*bgp_static
;
12014 char buf
[PREFIX_STRLEN
* 2];
12015 char buf2
[SU_ADDRSTRLEN
];
12016 char rdbuf
[RD_ADDRSTRLEN
];
12018 /* Network configuration. */
12019 for (prn
= bgp_table_top(bgp
->route
[afi
][safi
]); prn
;
12020 prn
= bgp_route_next(prn
)) {
12021 table
= bgp_node_get_bgp_table_info(prn
);
12025 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
12026 bgp_static
= bgp_node_get_bgp_static_info(rn
);
12027 if (bgp_static
== NULL
)
12030 char *macrouter
= NULL
;
12033 if (bgp_static
->router_mac
)
12034 macrouter
= prefix_mac2str(
12035 bgp_static
->router_mac
, NULL
, 0);
12036 if (bgp_static
->eth_s_id
)
12037 esi
= esi2str(bgp_static
->eth_s_id
);
12039 prd
= (struct prefix_rd
*)&prn
->p
;
12041 /* "network" configuration display. */
12042 prefix_rd2str(prd
, rdbuf
, sizeof(rdbuf
));
12043 if (p
->u
.prefix_evpn
.route_type
== 5) {
12044 char local_buf
[PREFIX_STRLEN
];
12045 uint8_t family
= is_evpn_prefix_ipaddr_v4((
12046 struct prefix_evpn
*)p
)
12050 &p
->u
.prefix_evpn
.prefix_addr
.ip
.ip
.addr
,
12051 local_buf
, PREFIX_STRLEN
);
12052 sprintf(buf
, "%s/%u", local_buf
,
12053 p
->u
.prefix_evpn
.prefix_addr
.ip_prefix_length
);
12055 prefix2str(p
, buf
, sizeof(buf
));
12058 if (bgp_static
->gatewayIp
.family
== AF_INET
12059 || bgp_static
->gatewayIp
.family
== AF_INET6
)
12060 inet_ntop(bgp_static
->gatewayIp
.family
,
12061 &bgp_static
->gatewayIp
.u
.prefix
, buf2
,
12064 " network %s rd %s ethtag %u label %u esi %s gwip %s routermac %s\n",
12066 p
->u
.prefix_evpn
.prefix_addr
.eth_tag
,
12067 decode_label(&bgp_static
->label
), esi
, buf2
,
12070 XFREE(MTYPE_TMP
, macrouter
);
12071 XFREE(MTYPE_TMP
, esi
);
12076 /* Configuration of static route announcement and aggregate
12078 void bgp_config_write_network(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
12081 struct bgp_node
*rn
;
12083 struct bgp_static
*bgp_static
;
12084 struct bgp_aggregate
*bgp_aggregate
;
12085 char buf
[SU_ADDRSTRLEN
];
12087 if ((safi
== SAFI_MPLS_VPN
) || (safi
== SAFI_ENCAP
)) {
12088 bgp_config_write_network_vpn(vty
, bgp
, afi
, safi
);
12092 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
12093 bgp_config_write_network_evpn(vty
, bgp
, afi
, safi
);
12097 /* Network configuration. */
12098 for (rn
= bgp_table_top(bgp
->route
[afi
][safi
]); rn
;
12099 rn
= bgp_route_next(rn
)) {
12100 bgp_static
= bgp_node_get_bgp_static_info(rn
);
12101 if (bgp_static
== NULL
)
12106 /* "network" configuration display. */
12107 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
) && afi
== AFI_IP
) {
12108 uint32_t destination
;
12109 struct in_addr netmask
;
12111 destination
= ntohl(p
->u
.prefix4
.s_addr
);
12112 masklen2ip(p
->prefixlen
, &netmask
);
12113 vty_out(vty
, " network %s",
12114 inet_ntop(p
->family
, &p
->u
.prefix
, buf
,
12117 if ((IN_CLASSC(destination
) && p
->prefixlen
== 24)
12118 || (IN_CLASSB(destination
) && p
->prefixlen
== 16)
12119 || (IN_CLASSA(destination
) && p
->prefixlen
== 8)
12120 || p
->u
.prefix4
.s_addr
== 0) {
12121 /* Natural mask is not display. */
12123 vty_out(vty
, " mask %s", inet_ntoa(netmask
));
12125 vty_out(vty
, " network %s/%d",
12126 inet_ntop(p
->family
, &p
->u
.prefix
, buf
,
12131 if (bgp_static
->label_index
!= BGP_INVALID_LABEL_INDEX
)
12132 vty_out(vty
, " label-index %u",
12133 bgp_static
->label_index
);
12135 if (bgp_static
->rmap
.name
)
12136 vty_out(vty
, " route-map %s", bgp_static
->rmap
.name
);
12138 if (bgp_static
->backdoor
)
12139 vty_out(vty
, " backdoor");
12141 vty_out(vty
, "\n");
12144 /* Aggregate-address configuration. */
12145 for (rn
= bgp_table_top(bgp
->aggregate
[afi
][safi
]); rn
;
12146 rn
= bgp_route_next(rn
)) {
12147 bgp_aggregate
= bgp_node_get_bgp_aggregate_info(rn
);
12148 if (bgp_aggregate
== NULL
)
12153 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
) && afi
== AFI_IP
) {
12154 struct in_addr netmask
;
12156 masklen2ip(p
->prefixlen
, &netmask
);
12157 vty_out(vty
, " aggregate-address %s %s",
12158 inet_ntop(p
->family
, &p
->u
.prefix
, buf
,
12160 inet_ntoa(netmask
));
12162 vty_out(vty
, " aggregate-address %s/%d",
12163 inet_ntop(p
->family
, &p
->u
.prefix
, buf
,
12168 if (bgp_aggregate
->as_set
)
12169 vty_out(vty
, " as-set");
12171 if (bgp_aggregate
->summary_only
)
12172 vty_out(vty
, " summary-only");
12174 vty_out(vty
, "\n");
12178 void bgp_config_write_distance(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
12181 struct bgp_node
*rn
;
12182 struct bgp_distance
*bdistance
;
12184 /* Distance configuration. */
12185 if (bgp
->distance_ebgp
[afi
][safi
] && bgp
->distance_ibgp
[afi
][safi
]
12186 && bgp
->distance_local
[afi
][safi
]
12187 && (bgp
->distance_ebgp
[afi
][safi
] != ZEBRA_EBGP_DISTANCE_DEFAULT
12188 || bgp
->distance_ibgp
[afi
][safi
] != ZEBRA_IBGP_DISTANCE_DEFAULT
12189 || bgp
->distance_local
[afi
][safi
]
12190 != ZEBRA_IBGP_DISTANCE_DEFAULT
)) {
12191 vty_out(vty
, " distance bgp %d %d %d\n",
12192 bgp
->distance_ebgp
[afi
][safi
],
12193 bgp
->distance_ibgp
[afi
][safi
],
12194 bgp
->distance_local
[afi
][safi
]);
12197 for (rn
= bgp_table_top(bgp_distance_table
[afi
][safi
]); rn
;
12198 rn
= bgp_route_next(rn
)) {
12199 bdistance
= bgp_node_get_bgp_distance_info(rn
);
12200 if (bdistance
!= NULL
) {
12201 char buf
[PREFIX_STRLEN
];
12203 vty_out(vty
, " distance %d %s %s\n",
12204 bdistance
->distance
,
12205 prefix2str(&rn
->p
, buf
, sizeof(buf
)),
12206 bdistance
->access_list
? bdistance
->access_list
12212 /* Allocate routing table structure and install commands. */
12213 void bgp_route_init(void)
12218 /* Init BGP distance table. */
12219 FOREACH_AFI_SAFI (afi
, safi
)
12220 bgp_distance_table
[afi
][safi
] = bgp_table_init(NULL
, afi
, safi
);
12222 /* IPv4 BGP commands. */
12223 install_element(BGP_NODE
, &bgp_table_map_cmd
);
12224 install_element(BGP_NODE
, &bgp_network_cmd
);
12225 install_element(BGP_NODE
, &no_bgp_table_map_cmd
);
12227 install_element(BGP_NODE
, &aggregate_address_cmd
);
12228 install_element(BGP_NODE
, &aggregate_address_mask_cmd
);
12229 install_element(BGP_NODE
, &no_aggregate_address_cmd
);
12230 install_element(BGP_NODE
, &no_aggregate_address_mask_cmd
);
12232 /* IPv4 unicast configuration. */
12233 install_element(BGP_IPV4_NODE
, &bgp_table_map_cmd
);
12234 install_element(BGP_IPV4_NODE
, &bgp_network_cmd
);
12235 install_element(BGP_IPV4_NODE
, &no_bgp_table_map_cmd
);
12237 install_element(BGP_IPV4_NODE
, &aggregate_address_cmd
);
12238 install_element(BGP_IPV4_NODE
, &aggregate_address_mask_cmd
);
12239 install_element(BGP_IPV4_NODE
, &no_aggregate_address_cmd
);
12240 install_element(BGP_IPV4_NODE
, &no_aggregate_address_mask_cmd
);
12242 /* IPv4 multicast configuration. */
12243 install_element(BGP_IPV4M_NODE
, &bgp_table_map_cmd
);
12244 install_element(BGP_IPV4M_NODE
, &bgp_network_cmd
);
12245 install_element(BGP_IPV4M_NODE
, &no_bgp_table_map_cmd
);
12246 install_element(BGP_IPV4M_NODE
, &aggregate_address_cmd
);
12247 install_element(BGP_IPV4M_NODE
, &aggregate_address_mask_cmd
);
12248 install_element(BGP_IPV4M_NODE
, &no_aggregate_address_cmd
);
12249 install_element(BGP_IPV4M_NODE
, &no_aggregate_address_mask_cmd
);
12251 /* IPv4 labeled-unicast configuration. */
12252 install_element(VIEW_NODE
, &show_ip_bgp_instance_all_cmd
);
12253 install_element(VIEW_NODE
, &show_ip_bgp_cmd
);
12254 install_element(VIEW_NODE
, &show_ip_bgp_json_cmd
);
12255 install_element(VIEW_NODE
, &show_ip_bgp_route_cmd
);
12256 install_element(VIEW_NODE
, &show_ip_bgp_regexp_cmd
);
12258 install_element(VIEW_NODE
,
12259 &show_ip_bgp_instance_neighbor_advertised_route_cmd
);
12260 install_element(VIEW_NODE
, &show_ip_bgp_neighbor_routes_cmd
);
12261 install_element(VIEW_NODE
,
12262 &show_ip_bgp_neighbor_received_prefix_filter_cmd
);
12263 #ifdef KEEP_OLD_VPN_COMMANDS
12264 install_element(VIEW_NODE
, &show_ip_bgp_vpn_all_route_prefix_cmd
);
12265 #endif /* KEEP_OLD_VPN_COMMANDS */
12266 install_element(VIEW_NODE
, &show_bgp_afi_vpn_rd_route_cmd
);
12267 install_element(VIEW_NODE
,
12268 &show_ip_bgp_l2vpn_evpn_all_route_prefix_cmd
);
12270 /* BGP dampening clear commands */
12271 install_element(ENABLE_NODE
, &clear_ip_bgp_dampening_cmd
);
12272 install_element(ENABLE_NODE
, &clear_ip_bgp_dampening_prefix_cmd
);
12274 install_element(ENABLE_NODE
, &clear_ip_bgp_dampening_address_cmd
);
12275 install_element(ENABLE_NODE
, &clear_ip_bgp_dampening_address_mask_cmd
);
12278 install_element(ENABLE_NODE
,
12279 &show_ip_bgp_instance_neighbor_prefix_counts_cmd
);
12280 #ifdef KEEP_OLD_VPN_COMMANDS
12281 install_element(ENABLE_NODE
,
12282 &show_ip_bgp_vpn_neighbor_prefix_counts_cmd
);
12283 #endif /* KEEP_OLD_VPN_COMMANDS */
12285 /* New config IPv6 BGP commands. */
12286 install_element(BGP_IPV6_NODE
, &bgp_table_map_cmd
);
12287 install_element(BGP_IPV6_NODE
, &ipv6_bgp_network_cmd
);
12288 install_element(BGP_IPV6_NODE
, &no_bgp_table_map_cmd
);
12290 install_element(BGP_IPV6_NODE
, &ipv6_aggregate_address_cmd
);
12291 install_element(BGP_IPV6_NODE
, &no_ipv6_aggregate_address_cmd
);
12293 install_element(BGP_IPV6M_NODE
, &ipv6_bgp_network_cmd
);
12295 install_element(BGP_NODE
, &bgp_distance_cmd
);
12296 install_element(BGP_NODE
, &no_bgp_distance_cmd
);
12297 install_element(BGP_NODE
, &bgp_distance_source_cmd
);
12298 install_element(BGP_NODE
, &no_bgp_distance_source_cmd
);
12299 install_element(BGP_NODE
, &bgp_distance_source_access_list_cmd
);
12300 install_element(BGP_NODE
, &no_bgp_distance_source_access_list_cmd
);
12301 install_element(BGP_IPV4_NODE
, &bgp_distance_cmd
);
12302 install_element(BGP_IPV4_NODE
, &no_bgp_distance_cmd
);
12303 install_element(BGP_IPV4_NODE
, &bgp_distance_source_cmd
);
12304 install_element(BGP_IPV4_NODE
, &no_bgp_distance_source_cmd
);
12305 install_element(BGP_IPV4_NODE
, &bgp_distance_source_access_list_cmd
);
12306 install_element(BGP_IPV4_NODE
, &no_bgp_distance_source_access_list_cmd
);
12307 install_element(BGP_IPV4M_NODE
, &bgp_distance_cmd
);
12308 install_element(BGP_IPV4M_NODE
, &no_bgp_distance_cmd
);
12309 install_element(BGP_IPV4M_NODE
, &bgp_distance_source_cmd
);
12310 install_element(BGP_IPV4M_NODE
, &no_bgp_distance_source_cmd
);
12311 install_element(BGP_IPV4M_NODE
, &bgp_distance_source_access_list_cmd
);
12312 install_element(BGP_IPV4M_NODE
,
12313 &no_bgp_distance_source_access_list_cmd
);
12314 install_element(BGP_IPV6_NODE
, &bgp_distance_cmd
);
12315 install_element(BGP_IPV6_NODE
, &no_bgp_distance_cmd
);
12316 install_element(BGP_IPV6_NODE
, &ipv6_bgp_distance_source_cmd
);
12317 install_element(BGP_IPV6_NODE
, &no_ipv6_bgp_distance_source_cmd
);
12318 install_element(BGP_IPV6_NODE
,
12319 &ipv6_bgp_distance_source_access_list_cmd
);
12320 install_element(BGP_IPV6_NODE
,
12321 &no_ipv6_bgp_distance_source_access_list_cmd
);
12322 install_element(BGP_IPV6M_NODE
, &bgp_distance_cmd
);
12323 install_element(BGP_IPV6M_NODE
, &no_bgp_distance_cmd
);
12324 install_element(BGP_IPV6M_NODE
, &ipv6_bgp_distance_source_cmd
);
12325 install_element(BGP_IPV6M_NODE
, &no_ipv6_bgp_distance_source_cmd
);
12326 install_element(BGP_IPV6M_NODE
,
12327 &ipv6_bgp_distance_source_access_list_cmd
);
12328 install_element(BGP_IPV6M_NODE
,
12329 &no_ipv6_bgp_distance_source_access_list_cmd
);
12331 install_element(BGP_NODE
, &bgp_damp_set_cmd
);
12332 install_element(BGP_NODE
, &bgp_damp_unset_cmd
);
12333 install_element(BGP_IPV4_NODE
, &bgp_damp_set_cmd
);
12334 install_element(BGP_IPV4_NODE
, &bgp_damp_unset_cmd
);
12336 /* IPv4 Multicast Mode */
12337 install_element(BGP_IPV4M_NODE
, &bgp_damp_set_cmd
);
12338 install_element(BGP_IPV4M_NODE
, &bgp_damp_unset_cmd
);
12340 /* Large Communities */
12341 install_element(VIEW_NODE
, &show_ip_bgp_large_community_list_cmd
);
12342 install_element(VIEW_NODE
, &show_ip_bgp_large_community_cmd
);
12344 /* show bgp ipv4 flowspec detailed */
12345 install_element(VIEW_NODE
, &show_ip_bgp_flowspec_routes_detailed_cmd
);
12347 install_element(VIEW_NODE
, &show_bgp_peerhash_cmd
);
12350 void bgp_route_finish(void)
12355 FOREACH_AFI_SAFI (afi
, safi
) {
12356 bgp_table_unlock(bgp_distance_table
[afi
][safi
]);
12357 bgp_distance_table
[afi
][safi
] = NULL
;