2 * bgp_updgrp_adv.c: BGP update group advertisement and adjacency
6 * @copyright Copyright (C) 2014 Cumulus Networks, Inc.
8 * @author Avneesh Sachdev <avneesh@sproute.net>
9 * @author Rajesh Varadarajan <rajesh@sproute.net>
10 * @author Pradosh Mohapatra <pradosh@sproute.net>
12 * This file is part of GNU Zebra.
14 * GNU Zebra is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2, or (at your option) any
19 * GNU Zebra is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
24 * You should have received a copy of the GNU General Public License along
25 * with this program; see the file COPYING; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
40 #include "bgpd/bgpd.h"
41 #include "bgpd/bgp_table.h"
42 #include "bgpd/bgp_debug.h"
43 #include "bgpd/bgp_route.h"
44 #include "bgpd/bgp_advertise.h"
45 #include "bgpd/bgp_attr.h"
46 #include "bgpd/bgp_aspath.h"
47 #include "bgpd/bgp_packet.h"
48 #include "bgpd/bgp_fsm.h"
49 #include "bgpd/bgp_mplsvpn.h"
50 #include "bgpd/bgp_updgrp.h"
51 #include "bgpd/bgp_advertise.h"
52 #include "bgpd/bgp_addpath.h"
58 static int bgp_adj_out_compare(const struct bgp_adj_out
*o1
,
59 const struct bgp_adj_out
*o2
)
61 if (o1
->subgroup
< o2
->subgroup
)
64 if (o1
->subgroup
> o2
->subgroup
)
67 if (o1
->addpath_tx_id
< o2
->addpath_tx_id
)
70 if (o1
->addpath_tx_id
> o2
->addpath_tx_id
)
75 RB_GENERATE(bgp_adj_out_rb
, bgp_adj_out
, adj_entry
, bgp_adj_out_compare
);
77 static inline struct bgp_adj_out
*adj_lookup(struct bgp_dest
*dest
,
78 struct update_subgroup
*subgrp
,
79 uint32_t addpath_tx_id
)
81 struct bgp_adj_out lookup
;
86 /* update-groups that do not support addpath will pass 0 for
88 lookup
.subgroup
= subgrp
;
89 lookup
.addpath_tx_id
= addpath_tx_id
;
91 return RB_FIND(bgp_adj_out_rb
, &dest
->adj_out
, &lookup
);
94 static void adj_free(struct bgp_adj_out
*adj
)
96 TAILQ_REMOVE(&(adj
->subgroup
->adjq
), adj
, subgrp_adj_train
);
97 SUBGRP_DECR_STAT(adj
->subgroup
, adj_count
);
99 RB_REMOVE(bgp_adj_out_rb
, &adj
->dest
->adj_out
, adj
);
100 bgp_dest_unlock_node(adj
->dest
);
102 XFREE(MTYPE_BGP_ADJ_OUT
, adj
);
105 static void subgrp_withdraw_stale_addpath(struct updwalk_context
*ctx
,
106 struct update_subgroup
*subgrp
)
108 struct bgp_adj_out
*adj
, *adj_next
;
110 struct bgp_path_info
*pi
;
111 afi_t afi
= SUBGRP_AFI(subgrp
);
112 safi_t safi
= SUBGRP_SAFI(subgrp
);
113 struct peer
*peer
= SUBGRP_PEER(subgrp
);
115 /* Look through all of the paths we have advertised for this rn and send
116 * a withdraw for the ones that are no longer present */
117 RB_FOREACH_SAFE (adj
, bgp_adj_out_rb
, &ctx
->dest
->adj_out
, adj_next
) {
119 if (adj
->subgroup
== subgrp
) {
120 for (pi
= bgp_dest_get_bgp_path_info(ctx
->dest
); pi
;
122 id
= bgp_addpath_id_for_peer(peer
, afi
, safi
,
125 if (id
== adj
->addpath_tx_id
) {
131 subgroup_process_announce_selected(
132 subgrp
, NULL
, ctx
->dest
,
139 static int group_announce_route_walkcb(struct update_group
*updgrp
, void *arg
)
141 struct updwalk_context
*ctx
= arg
;
142 struct update_subgroup
*subgrp
;
143 struct bgp_path_info
*pi
;
147 struct bgp_adj_out
*adj
, *adj_next
;
148 bool addpath_capable
;
150 afi
= UPDGRP_AFI(updgrp
);
151 safi
= UPDGRP_SAFI(updgrp
);
152 peer
= UPDGRP_PEER(updgrp
);
153 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
155 if (BGP_DEBUG(update
, UPDATE_OUT
))
156 zlog_debug("%s: afi=%s, safi=%s, p=%pRN", __func__
,
157 afi2str(afi
), safi2str(safi
),
158 bgp_dest_to_rnode(ctx
->dest
));
160 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
163 * Skip the subgroups that have coalesce timer running. We will
164 * walk the entire prefix table for those subgroups when the
165 * coalesce timer fires.
167 if (!subgrp
->t_coalesce
) {
168 /* An update-group that uses addpath */
169 if (addpath_capable
) {
170 subgrp_withdraw_stale_addpath(ctx
, subgrp
);
172 for (pi
= bgp_dest_get_bgp_path_info(ctx
->dest
);
174 /* Skip the bestpath for now */
178 subgroup_process_announce_selected(
179 subgrp
, pi
, ctx
->dest
,
180 bgp_addpath_id_for_peer(
185 /* Process the bestpath last so the "show [ip]
186 * bgp neighbor x.x.x.x advertised"
187 * output shows the attributes from the bestpath
190 subgroup_process_announce_selected(
191 subgrp
, ctx
->pi
, ctx
->dest
,
192 bgp_addpath_id_for_peer(
194 &ctx
->pi
->tx_addpath
));
197 /* An update-group that does not use addpath */
200 subgroup_process_announce_selected(
201 subgrp
, ctx
->pi
, ctx
->dest
,
202 bgp_addpath_id_for_peer(
204 &ctx
->pi
->tx_addpath
));
206 /* Find the addpath_tx_id of the path we
209 RB_FOREACH_SAFE (adj
, bgp_adj_out_rb
,
212 if (adj
->subgroup
== subgrp
) {
213 subgroup_process_announce_selected(
223 /* Notify BGP Conditional advertisement */
224 bgp_notify_conditional_adv_scanner(subgrp
);
227 return UPDWALK_CONTINUE
;
230 static void subgrp_show_adjq_vty(struct update_subgroup
*subgrp
,
231 struct vty
*vty
, uint8_t flags
)
233 struct bgp_table
*table
;
234 struct bgp_adj_out
*adj
;
235 unsigned long output_count
;
236 struct bgp_dest
*dest
;
241 bgp
= SUBGRP_INST(subgrp
);
245 table
= bgp
->rib
[SUBGRP_AFI(subgrp
)][SUBGRP_SAFI(subgrp
)];
249 for (dest
= bgp_table_top(table
); dest
; dest
= bgp_route_next(dest
)) {
250 const struct prefix
*dest_p
= bgp_dest_get_prefix(dest
);
252 RB_FOREACH (adj
, bgp_adj_out_rb
, &dest
->adj_out
)
253 if (adj
->subgroup
== subgrp
) {
256 "BGP table version is %" PRIu64
257 ", local router ID is %pI4\n",
260 vty_out(vty
, BGP_SHOW_SCODE_HEADER
);
261 vty_out(vty
, BGP_SHOW_OCODE_HEADER
);
265 vty_out(vty
, BGP_SHOW_HEADER
);
268 if ((flags
& UPDWALK_FLAGS_ADVQUEUE
) && adj
->adv
270 route_vty_out_tmp(vty
, dest
, dest_p
,
276 if ((flags
& UPDWALK_FLAGS_ADVERTISED
)
278 route_vty_out_tmp(vty
, dest
, dest_p
,
286 if (output_count
!= 0)
287 vty_out(vty
, "\nTotal number of prefixes %ld\n", output_count
);
290 static int updgrp_show_adj_walkcb(struct update_group
*updgrp
, void *arg
)
292 struct updwalk_context
*ctx
= arg
;
293 struct update_subgroup
*subgrp
;
297 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
298 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
300 vty_out(vty
, "update group %" PRIu64
", subgroup %" PRIu64
"\n",
301 updgrp
->id
, subgrp
->id
);
302 subgrp_show_adjq_vty(subgrp
, vty
, ctx
->flags
);
304 return UPDWALK_CONTINUE
;
307 static void updgrp_show_adj(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
308 struct vty
*vty
, uint64_t id
, uint8_t flags
)
310 struct updwalk_context ctx
;
311 memset(&ctx
, 0, sizeof(ctx
));
316 update_group_af_walk(bgp
, afi
, safi
, updgrp_show_adj_walkcb
, &ctx
);
319 static int subgroup_coalesce_timer(struct thread
*thread
)
321 struct update_subgroup
*subgrp
;
324 subgrp
= THREAD_ARG(thread
);
325 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
326 zlog_debug("u%" PRIu64
":s%" PRIu64
" announcing routes upon coalesce timer expiry(%u ms)",
327 (SUBGRP_UPDGRP(subgrp
))->id
, subgrp
->id
,
329 subgrp
->t_coalesce
= NULL
;
330 subgrp
->v_coalesce
= 0;
331 bgp
= SUBGRP_INST(subgrp
);
332 subgroup_announce_route(subgrp
);
335 /* While the announce_route() may kick off the route advertisement timer
337 * the members of the subgroup, we'd like to send the initial updates
339 * faster (i.e., without enforcing MRAI). Also, if there were no routes
341 * announce, this is the method currently employed to trigger the EOR.
343 if (!bgp_update_delay_active(SUBGRP_INST(subgrp
)) &&
344 !(BGP_SUPPRESS_FIB_ENABLED(bgp
))) {
348 SUBGRP_FOREACH_PEER (subgrp
, paf
) {
349 peer
= PAF_PEER(paf
);
350 BGP_TIMER_OFF(peer
->t_routeadv
);
351 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
358 static int update_group_announce_walkcb(struct update_group
*updgrp
, void *arg
)
360 struct update_subgroup
*subgrp
;
362 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
363 subgroup_announce_all(subgrp
);
366 return UPDWALK_CONTINUE
;
369 static int update_group_announce_rrc_walkcb(struct update_group
*updgrp
,
372 struct update_subgroup
*subgrp
;
377 afi
= UPDGRP_AFI(updgrp
);
378 safi
= UPDGRP_SAFI(updgrp
);
379 peer
= UPDGRP_PEER(updgrp
);
381 /* Only announce if this is a group of route-reflector-clients */
382 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_REFLECTOR_CLIENT
)) {
383 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
384 subgroup_announce_all(subgrp
);
388 return UPDWALK_CONTINUE
;
391 /********************
393 ********************/
396 * Allocate an adj-out object. Do proper initialization of its fields,
397 * primarily its association with the subgroup and the prefix.
399 struct bgp_adj_out
*bgp_adj_out_alloc(struct update_subgroup
*subgrp
,
400 struct bgp_dest
*dest
,
401 uint32_t addpath_tx_id
)
403 struct bgp_adj_out
*adj
;
405 adj
= XCALLOC(MTYPE_BGP_ADJ_OUT
, sizeof(struct bgp_adj_out
));
406 adj
->subgroup
= subgrp
;
407 adj
->addpath_tx_id
= addpath_tx_id
;
409 RB_INSERT(bgp_adj_out_rb
, &dest
->adj_out
, adj
);
410 bgp_dest_lock_node(dest
);
413 TAILQ_INSERT_TAIL(&(subgrp
->adjq
), adj
, subgrp_adj_train
);
414 SUBGRP_INCR_STAT(subgrp
, adj_count
);
419 struct bgp_advertise
*
420 bgp_advertise_clean_subgroup(struct update_subgroup
*subgrp
,
421 struct bgp_adj_out
*adj
)
423 struct bgp_advertise
*adv
;
424 struct bgp_advertise_attr
*baa
;
425 struct bgp_advertise
*next
;
426 struct bgp_adv_fifo_head
*fhead
;
433 fhead
= &subgrp
->sync
->update
;
435 /* Unlink myself from advertise attribute FIFO. */
436 bgp_advertise_delete(baa
, adv
);
438 /* Fetch next advertise candidate. */
441 /* Unintern BGP advertise attribute. */
442 bgp_advertise_unintern(subgrp
->hash
, baa
);
444 fhead
= &subgrp
->sync
->withdraw
;
447 /* Unlink myself from advertisement FIFO. */
448 bgp_adv_fifo_del(fhead
, adv
);
451 bgp_advertise_free(adj
->adv
);
457 void bgp_adj_out_set_subgroup(struct bgp_dest
*dest
,
458 struct update_subgroup
*subgrp
, struct attr
*attr
,
459 struct bgp_path_info
*path
)
461 struct bgp_adj_out
*adj
= NULL
;
462 struct bgp_advertise
*adv
;
466 struct peer
*adv_peer
;
469 uint32_t attr_hash
= attrhash_key_make(attr
);
471 peer
= SUBGRP_PEER(subgrp
);
472 afi
= SUBGRP_AFI(subgrp
);
473 safi
= SUBGRP_SAFI(subgrp
);
474 bgp
= SUBGRP_INST(subgrp
);
476 if (DISABLE_BGP_ANNOUNCE
)
479 /* Look for adjacency information. */
482 bgp_addpath_id_for_peer(peer
, afi
, safi
, &path
->tx_addpath
));
485 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_TABLE_REPARSING
))
488 adj
= bgp_adj_out_alloc(
490 bgp_addpath_id_for_peer(peer
, afi
, safi
,
498 /* Check if we are sending the same route. This is needed to
499 * avoid duplicate UPDATES. For instance, filtering communities
500 * at egress, neighbors will see duplicate UPDATES despite
501 * the route wasn't changed actually.
502 * Do not suppress BGP UPDATES for route-refresh.
504 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_SUPPRESS_DUPLICATES
)
505 && !CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_FORCE_UPDATES
)
506 && adj
->attr_hash
== attr_hash
) {
507 if (BGP_DEBUG(update
, UPDATE_OUT
)) {
508 char attr_str
[BUFSIZ
] = {0};
510 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
512 zlog_debug("%s suppress UPDATE w/ attr: %s", peer
->host
,
519 bgp_advertise_clean_subgroup(subgrp
, adj
);
520 adj
->adv
= bgp_advertise_new();
524 assert(adv
->pathi
== NULL
);
525 /* bgp_path_info adj_out reference */
526 adv
->pathi
= bgp_path_info_lock(path
);
528 adv
->baa
= bgp_advertise_intern(subgrp
->hash
, attr
);
530 adj
->attr_hash
= attr_hash
;
532 /* Add new advertisement to advertisement attribute list. */
533 bgp_advertise_add(adv
->baa
, adv
);
536 * If the update adv list is empty, trigger the member peers'
537 * mrai timers so the socket writes can happen.
539 if (!bgp_adv_fifo_count(&subgrp
->sync
->update
)) {
540 SUBGRP_FOREACH_PEER (subgrp
, paf
) {
541 /* If there are no routes in the withdraw list, set
542 * the flag PEER_STATUS_ADV_DELAY which will allow
543 * more routes to be sent in the update message
545 if (BGP_SUPPRESS_FIB_ENABLED(bgp
)) {
546 adv_peer
= PAF_PEER(paf
);
547 if (!bgp_adv_fifo_count(
548 &subgrp
->sync
->withdraw
))
549 SET_FLAG(adv_peer
->thread_flags
,
550 PEER_THREAD_SUBGRP_ADV_DELAY
);
552 UNSET_FLAG(adv_peer
->thread_flags
,
553 PEER_THREAD_SUBGRP_ADV_DELAY
);
555 bgp_adjust_routeadv(PAF_PEER(paf
));
559 bgp_adv_fifo_add_tail(&subgrp
->sync
->update
, adv
);
561 subgrp
->version
= MAX(subgrp
->version
, dest
->version
);
564 /* The only time 'withdraw' will be false is if we are sending
565 * the "neighbor x.x.x.x default-originate" default and need to clear
566 * bgp_adj_out for the 0.0.0.0/0 route in the BGP table.
568 void bgp_adj_out_unset_subgroup(struct bgp_dest
*dest
,
569 struct update_subgroup
*subgrp
, char withdraw
,
570 uint32_t addpath_tx_id
)
572 struct bgp_adj_out
*adj
;
573 struct bgp_advertise
*adv
;
576 if (DISABLE_BGP_ANNOUNCE
)
579 /* Lookup existing adjacency */
580 adj
= adj_lookup(dest
, subgrp
, addpath_tx_id
);
582 /* Clean up previous advertisement. */
584 bgp_advertise_clean_subgroup(subgrp
, adj
);
586 /* If default originate is enabled and the route is default
587 * route, do not send withdraw. This will prevent deletion of
588 * the default route at the peer.
590 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
)
591 && is_default_prefix(bgp_dest_get_prefix(dest
)))
594 if (adj
->attr
&& withdraw
) {
595 /* We need advertisement structure. */
596 adj
->adv
= bgp_advertise_new();
601 /* Note if we need to trigger a packet write */
603 !bgp_adv_fifo_count(&subgrp
->sync
->withdraw
);
605 /* Add to synchronization entry for withdraw
607 bgp_adv_fifo_add_tail(&subgrp
->sync
->withdraw
, adv
);
610 subgroup_trigger_write(subgrp
);
612 /* Free allocated information. */
615 if (!CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_TABLE_REPARSING
))
619 subgrp
->version
= MAX(subgrp
->version
, dest
->version
);
622 void bgp_adj_out_remove_subgroup(struct bgp_dest
*dest
, struct bgp_adj_out
*adj
,
623 struct update_subgroup
*subgrp
)
626 bgp_attr_unintern(&adj
->attr
);
629 bgp_advertise_clean_subgroup(subgrp
, adj
);
635 * Go through all the routes and clean up the adj/adv structures corresponding
638 void subgroup_clear_table(struct update_subgroup
*subgrp
)
640 struct bgp_adj_out
*aout
, *taout
;
642 SUBGRP_FOREACH_ADJ_SAFE (subgrp
, aout
, taout
)
643 bgp_adj_out_remove_subgroup(aout
->dest
, aout
, subgrp
);
647 * subgroup_announce_table
649 void subgroup_announce_table(struct update_subgroup
*subgrp
,
650 struct bgp_table
*table
)
652 struct bgp_dest
*dest
;
653 struct bgp_path_info
*ri
;
658 bool addpath_capable
;
662 peer
= SUBGRP_PEER(subgrp
);
663 afi
= SUBGRP_AFI(subgrp
);
664 safi
= SUBGRP_SAFI(subgrp
);
665 bgp
= SUBGRP_INST(subgrp
);
666 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
668 if (safi
== SAFI_LABELED_UNICAST
)
672 table
= peer
->bgp
->rib
[afi
][safi
];
674 if (safi
!= SAFI_MPLS_VPN
&& safi
!= SAFI_ENCAP
&& safi
!= SAFI_EVPN
675 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
676 PEER_FLAG_DEFAULT_ORIGINATE
))
677 subgroup_default_originate(subgrp
, 0);
680 SET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_TABLE_REPARSING
);
682 for (dest
= bgp_table_top(table
); dest
; dest
= bgp_route_next(dest
)) {
683 const struct prefix
*dest_p
= bgp_dest_get_prefix(dest
);
685 /* Check if the route can be advertised */
686 advertise
= bgp_check_advertise(bgp
, dest
);
688 for (ri
= bgp_dest_get_bgp_path_info(dest
); ri
; ri
= ri
->next
)
690 if (bgp_check_selected(ri
, peer
, addpath_capable
, afi
,
692 if (subgroup_announce_check(dest
, ri
, subgrp
,
695 /* Check if route can be advertised */
697 if (!bgp_check_withdrawal(bgp
,
699 bgp_adj_out_set_subgroup(
703 bgp_adj_out_unset_subgroup(
705 bgp_addpath_id_for_peer(
712 /* If default originate is enabled for
713 * the peer, do not send explicit
714 * withdraw. This will prevent deletion
715 * of default route advertised through
719 peer
->af_flags
[afi
][safi
],
720 PEER_FLAG_DEFAULT_ORIGINATE
)
721 && is_default_prefix(bgp_dest_get_prefix(dest
)))
724 bgp_adj_out_unset_subgroup(
726 bgp_addpath_id_for_peer(
732 UNSET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_TABLE_REPARSING
);
735 * We walked through the whole table -- make sure our version number
736 * is consistent with the one on the table. This should allow
737 * subgroups to merge sooner if a peer comes up when the route node
738 * with the largest version is no longer in the table. This also
739 * covers the pathological case where all routes in the table have
742 subgrp
->version
= MAX(subgrp
->version
, table
->version
);
745 * Start a task to merge the subgroup if necessary.
747 update_subgroup_trigger_merge_check(subgrp
, 0);
751 * subgroup_announce_route
753 * Refresh all routes out to a subgroup.
755 void subgroup_announce_route(struct update_subgroup
*subgrp
)
757 struct bgp_dest
*dest
;
758 struct bgp_table
*table
;
759 struct peer
*onlypeer
;
761 if (update_subgroup_needs_refresh(subgrp
)) {
762 update_subgroup_set_needs_refresh(subgrp
, 0);
766 * First update is deferred until ORF or ROUTE-REFRESH is received
768 onlypeer
= ((SUBGRP_PCOUNT(subgrp
) == 1) ? (SUBGRP_PFIRST(subgrp
))->peer
770 if (onlypeer
&& CHECK_FLAG(onlypeer
->af_sflags
[SUBGRP_AFI(subgrp
)]
771 [SUBGRP_SAFI(subgrp
)],
772 PEER_STATUS_ORF_WAIT_REFRESH
))
775 if (SUBGRP_SAFI(subgrp
) != SAFI_MPLS_VPN
776 && SUBGRP_SAFI(subgrp
) != SAFI_ENCAP
777 && SUBGRP_SAFI(subgrp
) != SAFI_EVPN
)
778 subgroup_announce_table(subgrp
, NULL
);
780 for (dest
= bgp_table_top(update_subgroup_rib(subgrp
)); dest
;
781 dest
= bgp_route_next(dest
)) {
782 table
= bgp_dest_get_bgp_table_info(dest
);
785 subgroup_announce_table(subgrp
, table
);
789 void subgroup_default_originate(struct update_subgroup
*subgrp
, int withdraw
)
793 struct attr
*new_attr
= &attr
;
796 struct bgp_dest
*dest
;
797 struct bgp_path_info
*pi
;
799 struct bgp_adj_out
*adj
;
800 route_map_result_t ret
= RMAP_DENYMATCH
;
807 peer
= SUBGRP_PEER(subgrp
);
808 afi
= SUBGRP_AFI(subgrp
);
809 safi
= SUBGRP_SAFI(subgrp
);
811 if (!(afi
== AFI_IP
|| afi
== AFI_IP6
))
815 from
= bgp
->peer_self
;
817 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
819 /* make coverity happy */
822 attr
.local_pref
= bgp
->default_local_pref
;
824 if ((afi
== AFI_IP6
) || peer_cap_enhe(peer
, afi
, safi
)) {
825 /* IPv6 global nexthop must be included. */
826 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
828 /* If the peer is on shared nextwork and we have link-local
830 if (peer
->shared_network
831 && !IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_local
))
832 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
;
835 if (peer
->default_rmap
[afi
][safi
].name
) {
836 struct bgp_path_info tmp_pi
= {0};
838 tmp_pi
.peer
= bgp
->peer_self
;
840 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_DEFAULT
);
842 /* Iterate over the RIB to see if we can announce
843 * the default route. We announce the default
844 * route only if route-map has a match.
846 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
847 dest
= bgp_route_next(dest
)) {
848 if (!bgp_dest_has_bgp_path_info_data(dest
))
851 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
;
853 struct attr tmp_attr
= attr
;
855 tmp_pi
.attr
= &tmp_attr
;
857 ret
= route_map_apply_ext(
858 peer
->default_rmap
[afi
][safi
].map
,
859 bgp_dest_get_prefix(dest
), pi
, &tmp_pi
);
861 if (ret
== RMAP_DENYMATCH
) {
862 bgp_attr_undup(&tmp_attr
, &attr
);
865 new_attr
= bgp_attr_intern(&tmp_attr
);
867 subgroup_announce_reset_nhop(
868 (peer_cap_enhe(peer
, afi
, safi
)
876 if (ret
== RMAP_PERMITMATCH
) {
877 bgp_dest_unlock_node(dest
);
881 bgp
->peer_self
->rmap_type
= 0;
883 if (ret
== RMAP_DENYMATCH
)
887 /* Check if the default route is in local BGP RIB which is
888 * installed through redistribute or network command
890 memset(&p
, 0, sizeof(p
));
891 p
.family
= afi2family(afi
);
893 dest
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
, &p
, NULL
);
896 /* Withdraw the default route advertised using default
899 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
900 subgroup_default_withdraw_packet(subgrp
);
901 UNSET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
903 /* If default route is present in the local RIB, advertise the
907 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
;
909 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
))
910 if (subgroup_announce_check(
912 bgp_dest_get_prefix(dest
),
914 bgp_adj_out_set_subgroup(
918 bgp_dest_unlock_node(dest
);
921 if (!CHECK_FLAG(subgrp
->sflags
,
922 SUBGRP_STATUS_DEFAULT_ORIGINATE
)) {
924 /* The 'neighbor x.x.x.x default-originate' default will
926 * implicit withdraw for any previous UPDATEs sent for
928 * clear adj_out for the 0.0.0.0/0 prefix in the BGP
932 /* Remove the adjacency for the previously
933 * advertised default route
937 BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
);
939 /* Clean up previous advertisement. */
941 bgp_advertise_clean_subgroup(
944 /* Free allocated information. */
947 bgp_dest_unlock_node(dest
);
950 /* Advertise the default route */
951 if (bgp_in_graceful_shutdown(bgp
))
952 bgp_attr_add_gshut_community(new_attr
);
954 SET_FLAG(subgrp
->sflags
,
955 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
956 subgroup_default_update_packet(subgrp
, new_attr
, from
);
960 aspath_unintern(&attr
.aspath
);
964 * Announce the BGP table to a subgroup.
966 * At startup, we try to optimize route announcement by coalescing the
967 * peer-up events. This is done only the first time - from then on,
968 * subgrp->v_coalesce will be set to zero and the normal logic
971 void subgroup_announce_all(struct update_subgroup
*subgrp
)
977 * If coalesce timer value is not set, announce routes immediately.
979 if (!subgrp
->v_coalesce
) {
980 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
981 zlog_debug("u%" PRIu64
":s%" PRIu64
" announcing all routes",
982 subgrp
->update_group
->id
, subgrp
->id
);
983 subgroup_announce_route(subgrp
);
988 * We should wait for the coalesce timer. Arm the timer if not done.
990 if (!subgrp
->t_coalesce
) {
991 thread_add_timer_msec(bm
->master
, subgroup_coalesce_timer
,
992 subgrp
, subgrp
->v_coalesce
,
993 &subgrp
->t_coalesce
);
998 * Go through all update subgroups and set up the adv queue for the
1001 void group_announce_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1002 struct bgp_dest
*dest
, struct bgp_path_info
*pi
)
1004 struct updwalk_context ctx
;
1008 /* If suppress fib is enabled, the route will be advertised when
1009 * FIB status is received
1011 if (!bgp_check_advertise(bgp
, dest
))
1014 update_group_af_walk(bgp
, afi
, safi
, group_announce_route_walkcb
, &ctx
);
1017 void update_group_show_adj_queue(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1018 struct vty
*vty
, uint64_t id
)
1020 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVQUEUE
);
1023 void update_group_show_advertised(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1024 struct vty
*vty
, uint64_t id
)
1026 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVERTISED
);
1029 void update_group_announce(struct bgp
*bgp
)
1031 update_group_walk(bgp
, update_group_announce_walkcb
, NULL
);
1034 void update_group_announce_rrclients(struct bgp
*bgp
)
1036 update_group_walk(bgp
, update_group_announce_rrc_walkcb
, NULL
);