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"
58 static inline struct bgp_adj_out
*adj_lookup(struct bgp_node
*rn
,
59 struct update_subgroup
*subgrp
,
60 u_int32_t addpath_tx_id
)
62 struct bgp_adj_out
*adj
;
71 peer
= SUBGRP_PEER(subgrp
);
72 afi
= SUBGRP_AFI(subgrp
);
73 safi
= SUBGRP_SAFI(subgrp
);
74 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
76 /* update-groups that do not support addpath will pass 0 for
77 * addpath_tx_id so do not both matching against it */
78 for (adj
= rn
->adj_out
; adj
; adj
= adj
->next
) {
79 if (adj
->subgroup
== subgrp
) {
80 if (addpath_capable
) {
81 if (adj
->addpath_tx_id
== addpath_tx_id
) {
93 static void adj_free(struct bgp_adj_out
*adj
)
95 TAILQ_REMOVE(&(adj
->subgroup
->adjq
), adj
, subgrp_adj_train
);
96 SUBGRP_DECR_STAT(adj
->subgroup
, adj_count
);
97 XFREE(MTYPE_BGP_ADJ_OUT
, adj
);
100 static int group_announce_route_walkcb(struct update_group
*updgrp
, void *arg
)
102 struct updwalk_context
*ctx
= arg
;
103 struct update_subgroup
*subgrp
;
108 struct bgp_adj_out
*adj
, *adj_next
;
111 afi
= UPDGRP_AFI(updgrp
);
112 safi
= UPDGRP_SAFI(updgrp
);
113 peer
= UPDGRP_PEER(updgrp
);
114 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
116 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
120 * Skip the subgroups that have coalesce timer running. We will
121 * walk the entire prefix table for those subgroups when the
122 * coalesce timer fires.
124 if (!subgrp
->t_coalesce
) {
125 /* An update-group that uses addpath */
126 if (addpath_capable
) {
127 /* Look through all of the paths we have
128 * advertised for this rn and
129 * send a withdraw for the ones that are no
131 for (adj
= ctx
->rn
->adj_out
; adj
;
133 adj_next
= adj
->next
;
135 if (adj
->subgroup
== subgrp
) {
136 for (ri
= ctx
->rn
->info
; ri
;
138 if (ri
->addpath_tx_id
139 == adj
->addpath_tx_id
) {
145 subgroup_process_announce_selected(
153 for (ri
= ctx
->rn
->info
; ri
; ri
= ri
->next
) {
154 /* Skip the bestpath for now */
158 subgroup_process_announce_selected(
163 /* Process the bestpath last so the "show [ip]
164 * bgp neighbor x.x.x.x advertised"
165 * output shows the attributes from the bestpath
168 subgroup_process_announce_selected(
169 subgrp
, ctx
->ri
, ctx
->rn
,
170 ctx
->ri
->addpath_tx_id
);
173 /* An update-group that does not use addpath */
176 subgroup_process_announce_selected(
177 subgrp
, ctx
->ri
, ctx
->rn
,
178 ctx
->ri
->addpath_tx_id
);
180 /* Find the addpath_tx_id of the path we
183 for (adj
= ctx
->rn
->adj_out
; adj
;
185 adj_next
= adj
->next
;
187 if (adj
->subgroup
== subgrp
) {
188 subgroup_process_announce_selected(
199 return UPDWALK_CONTINUE
;
202 static void subgrp_show_adjq_vty(struct update_subgroup
*subgrp
,
203 struct vty
*vty
, u_int8_t flags
)
205 struct bgp_table
*table
;
206 struct bgp_adj_out
*adj
;
207 unsigned long output_count
;
213 bgp
= SUBGRP_INST(subgrp
);
217 table
= bgp
->rib
[SUBGRP_AFI(subgrp
)][SUBGRP_SAFI(subgrp
)];
221 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
222 for (adj
= rn
->adj_out
; adj
; adj
= adj
->next
)
223 if (adj
->subgroup
== subgrp
) {
226 "BGP table version is %" PRIu64
227 ", local router ID is %s\n",
229 inet_ntoa(bgp
->router_id
));
230 vty_out(vty
, BGP_SHOW_SCODE_HEADER
);
231 vty_out(vty
, BGP_SHOW_OCODE_HEADER
);
235 vty_out(vty
, BGP_SHOW_HEADER
);
238 if ((flags
& UPDWALK_FLAGS_ADVQUEUE
) && adj
->adv
240 route_vty_out_tmp(vty
, &rn
->p
,
246 if ((flags
& UPDWALK_FLAGS_ADVERTISED
)
249 vty
, &rn
->p
, adj
->attr
,
250 SUBGRP_SAFI(subgrp
), 0, NULL
);
254 if (output_count
!= 0)
255 vty_out(vty
, "\nTotal number of prefixes %ld\n", output_count
);
258 static int updgrp_show_adj_walkcb(struct update_group
*updgrp
, void *arg
)
260 struct updwalk_context
*ctx
= arg
;
261 struct update_subgroup
*subgrp
;
265 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
267 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
269 vty_out(vty
, "update group %" PRIu64
", subgroup %" PRIu64
"\n",
270 updgrp
->id
, subgrp
->id
);
271 subgrp_show_adjq_vty(subgrp
, vty
, ctx
->flags
);
273 return UPDWALK_CONTINUE
;
276 static void updgrp_show_adj(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
277 struct vty
*vty
, uint64_t id
, u_int8_t flags
)
279 struct updwalk_context ctx
;
280 memset(&ctx
, 0, sizeof(ctx
));
285 update_group_af_walk(bgp
, afi
, safi
, updgrp_show_adj_walkcb
, &ctx
);
288 static int subgroup_coalesce_timer(struct thread
*thread
)
290 struct update_subgroup
*subgrp
;
292 subgrp
= THREAD_ARG(thread
);
293 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
294 zlog_debug("u%" PRIu64
":s%" PRIu64
295 " announcing routes upon coalesce timer expiry",
296 (SUBGRP_UPDGRP(subgrp
))->id
, subgrp
->id
);
297 subgrp
->t_coalesce
= NULL
;
298 subgrp
->v_coalesce
= 0;
299 subgroup_announce_route(subgrp
);
302 /* While the announce_route() may kick off the route advertisement timer
304 * the members of the subgroup, we'd like to send the initial updates
306 * faster (i.e., without enforcing MRAI). Also, if there were no routes
308 * announce, this is the method currently employed to trigger the EOR.
310 if (!bgp_update_delay_active(SUBGRP_INST(subgrp
))) {
314 SUBGRP_FOREACH_PEER(subgrp
, paf
)
316 peer
= PAF_PEER(paf
);
317 BGP_TIMER_OFF(peer
->t_routeadv
);
318 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
325 static int update_group_announce_walkcb(struct update_group
*updgrp
, void *arg
)
327 struct update_subgroup
*subgrp
;
329 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
331 subgroup_announce_all(subgrp
);
334 return UPDWALK_CONTINUE
;
337 static int update_group_announce_rrc_walkcb(struct update_group
*updgrp
,
340 struct update_subgroup
*subgrp
;
345 afi
= UPDGRP_AFI(updgrp
);
346 safi
= UPDGRP_SAFI(updgrp
);
347 peer
= UPDGRP_PEER(updgrp
);
349 /* Only announce if this is a group of route-reflector-clients */
350 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_REFLECTOR_CLIENT
)) {
351 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
353 subgroup_announce_all(subgrp
);
357 return UPDWALK_CONTINUE
;
360 /********************
362 ********************/
365 * Allocate an adj-out object. Do proper initialization of its fields,
366 * primarily its association with the subgroup and the prefix.
368 struct bgp_adj_out
*bgp_adj_out_alloc(struct update_subgroup
*subgrp
,
370 u_int32_t addpath_tx_id
)
372 struct bgp_adj_out
*adj
;
374 adj
= XCALLOC(MTYPE_BGP_ADJ_OUT
, sizeof(struct bgp_adj_out
));
375 adj
->subgroup
= subgrp
;
377 BGP_ADJ_OUT_ADD(rn
, adj
);
382 adj
->addpath_tx_id
= addpath_tx_id
;
383 TAILQ_INSERT_TAIL(&(subgrp
->adjq
), adj
, subgrp_adj_train
);
384 SUBGRP_INCR_STAT(subgrp
, adj_count
);
389 struct bgp_advertise
*
390 bgp_advertise_clean_subgroup(struct update_subgroup
*subgrp
,
391 struct bgp_adj_out
*adj
)
393 struct bgp_advertise
*adv
;
394 struct bgp_advertise_attr
*baa
;
395 struct bgp_advertise
*next
;
396 struct bgp_advertise_fifo
*fhead
;
403 fhead
= &subgrp
->sync
->update
;
405 /* Unlink myself from advertise attribute FIFO. */
406 bgp_advertise_delete(baa
, adv
);
408 /* Fetch next advertise candidate. */
411 /* Unintern BGP advertise attribute. */
412 bgp_advertise_unintern(subgrp
->hash
, baa
);
414 fhead
= &subgrp
->sync
->withdraw
;
417 /* Unlink myself from advertisement FIFO. */
418 BGP_ADV_FIFO_DEL(fhead
, adv
);
421 bgp_advertise_free(adj
->adv
);
427 void bgp_adj_out_set_subgroup(struct bgp_node
*rn
,
428 struct update_subgroup
*subgrp
, struct attr
*attr
,
429 struct bgp_info
*binfo
)
431 struct bgp_adj_out
*adj
= NULL
;
432 struct bgp_advertise
*adv
;
434 if (DISABLE_BGP_ANNOUNCE
)
437 /* Look for adjacency information. */
438 adj
= adj_lookup(rn
, subgrp
, binfo
->addpath_tx_id
);
441 adj
= bgp_adj_out_alloc(subgrp
, rn
, binfo
->addpath_tx_id
);
447 bgp_advertise_clean_subgroup(subgrp
, adj
);
448 adj
->adv
= bgp_advertise_new();
452 assert(adv
->binfo
== NULL
);
453 adv
->binfo
= bgp_info_lock(binfo
); /* bgp_info adj_out reference */
456 adv
->baa
= bgp_advertise_intern(subgrp
->hash
, attr
);
458 adv
->baa
= baa_new();
461 /* Add new advertisement to advertisement attribute list. */
462 bgp_advertise_add(adv
->baa
, adv
);
465 * If the update adv list is empty, trigger the member peers'
466 * mrai timers so the socket writes can happen.
468 if (BGP_ADV_FIFO_EMPTY(&subgrp
->sync
->update
)) {
471 SUBGRP_FOREACH_PEER(subgrp
, paf
)
473 bgp_adjust_routeadv(PAF_PEER(paf
));
477 BGP_ADV_FIFO_ADD(&subgrp
->sync
->update
, &adv
->fifo
);
479 subgrp
->version
= max(subgrp
->version
, rn
->version
);
482 /* The only time 'withdraw' will be false is if we are sending
483 * the "neighbor x.x.x.x default-originate" default and need to clear
484 * bgp_adj_out for the 0.0.0.0/0 route in the BGP table.
486 void bgp_adj_out_unset_subgroup(struct bgp_node
*rn
,
487 struct update_subgroup
*subgrp
, char withdraw
,
488 u_int32_t addpath_tx_id
)
490 struct bgp_adj_out
*adj
;
491 struct bgp_advertise
*adv
;
494 if (DISABLE_BGP_ANNOUNCE
)
497 /* Lookup existing adjacency */
498 if ((adj
= adj_lookup(rn
, subgrp
, addpath_tx_id
)) != NULL
) {
499 /* Clean up previous advertisement. */
501 bgp_advertise_clean_subgroup(subgrp
, adj
);
503 if (adj
->attr
&& withdraw
) {
504 /* We need advertisement structure. */
505 adj
->adv
= bgp_advertise_new();
510 /* Note if we need to trigger a packet write */
511 if (BGP_ADV_FIFO_EMPTY(&subgrp
->sync
->withdraw
))
516 /* Add to synchronization entry for withdraw
518 BGP_ADV_FIFO_ADD(&subgrp
->sync
->withdraw
, &adv
->fifo
);
520 /* Schedule packet write, if FIFO is getting its first
523 subgroup_trigger_write(subgrp
);
525 /* Remove myself from adjacency. */
526 BGP_ADJ_OUT_DEL(rn
, adj
);
528 /* Free allocated information. */
535 subgrp
->version
= max(subgrp
->version
, rn
->version
);
538 void bgp_adj_out_remove_subgroup(struct bgp_node
*rn
, struct bgp_adj_out
*adj
,
539 struct update_subgroup
*subgrp
)
542 bgp_attr_unintern(&adj
->attr
);
545 bgp_advertise_clean_subgroup(subgrp
, adj
);
547 BGP_ADJ_OUT_DEL(rn
, adj
);
552 * Go through all the routes and clean up the adj/adv structures corresponding
555 void subgroup_clear_table(struct update_subgroup
*subgrp
)
557 struct bgp_adj_out
*aout
, *taout
;
559 SUBGRP_FOREACH_ADJ_SAFE(subgrp
, aout
, taout
)
561 struct bgp_node
*rn
= aout
->rn
;
562 bgp_adj_out_remove_subgroup(rn
, aout
, subgrp
);
568 * subgroup_announce_table
570 void subgroup_announce_table(struct update_subgroup
*subgrp
,
571 struct bgp_table
*table
)
581 peer
= SUBGRP_PEER(subgrp
);
582 afi
= SUBGRP_AFI(subgrp
);
583 safi
= SUBGRP_SAFI(subgrp
);
584 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
586 if (safi
== SAFI_LABELED_UNICAST
)
590 table
= peer
->bgp
->rib
[afi
][safi
];
592 if (safi
!= SAFI_MPLS_VPN
&& safi
!= SAFI_ENCAP
&& safi
!= SAFI_EVPN
593 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
594 PEER_FLAG_DEFAULT_ORIGINATE
))
595 subgroup_default_originate(subgrp
, 0);
597 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
598 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
600 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
602 && bgp_addpath_tx_path(peer
, afi
, safi
, ri
))) {
603 if (subgroup_announce_check(rn
, ri
, subgrp
,
605 bgp_adj_out_set_subgroup(rn
, subgrp
,
608 bgp_adj_out_unset_subgroup(
614 * We walked through the whole table -- make sure our version number
615 * is consistent with the one on the table. This should allow
616 * subgroups to merge sooner if a peer comes up when the route node
617 * with the largest version is no longer in the table. This also
618 * covers the pathological case where all routes in the table have
621 subgrp
->version
= max(subgrp
->version
, table
->version
);
624 * Start a task to merge the subgroup if necessary.
626 update_subgroup_trigger_merge_check(subgrp
, 0);
630 * subgroup_announce_route
632 * Refresh all routes out to a subgroup.
634 void subgroup_announce_route(struct update_subgroup
*subgrp
)
637 struct bgp_table
*table
;
638 struct peer
*onlypeer
;
640 if (update_subgroup_needs_refresh(subgrp
)) {
641 update_subgroup_set_needs_refresh(subgrp
, 0);
645 * First update is deferred until ORF or ROUTE-REFRESH is received
647 onlypeer
= ((SUBGRP_PCOUNT(subgrp
) == 1) ? (SUBGRP_PFIRST(subgrp
))->peer
649 if (onlypeer
&& CHECK_FLAG(onlypeer
->af_sflags
[SUBGRP_AFI(subgrp
)]
650 [SUBGRP_SAFI(subgrp
)],
651 PEER_STATUS_ORF_WAIT_REFRESH
))
654 if (SUBGRP_SAFI(subgrp
) != SAFI_MPLS_VPN
655 && SUBGRP_SAFI(subgrp
) != SAFI_ENCAP
656 && SUBGRP_SAFI(subgrp
) != SAFI_EVPN
)
657 subgroup_announce_table(subgrp
, NULL
);
659 for (rn
= bgp_table_top(update_subgroup_rib(subgrp
)); rn
;
660 rn
= bgp_route_next(rn
))
661 if ((table
= (rn
->info
)) != NULL
)
662 subgroup_announce_table(subgrp
, table
);
665 void subgroup_default_originate(struct update_subgroup
*subgrp
, int withdraw
)
669 struct aspath
*aspath
;
675 int ret
= RMAP_DENYMATCH
;
682 peer
= SUBGRP_PEER(subgrp
);
683 afi
= SUBGRP_AFI(subgrp
);
684 safi
= SUBGRP_SAFI(subgrp
);
686 if (!(afi
== AFI_IP
|| afi
== AFI_IP6
))
690 from
= bgp
->peer_self
;
692 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
693 aspath
= attr
.aspath
;
694 attr
.local_pref
= bgp
->default_local_pref
;
697 str2prefix("0.0.0.0/0", &p
);
698 else if (afi
== AFI_IP6
) {
699 str2prefix("::/0", &p
);
701 /* IPv6 global nexthop must be included. */
702 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
704 /* If the peer is on shared nextwork and we have link-local
706 if (peer
->shared_network
707 && !IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_local
))
708 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
;
711 if (peer
->default_rmap
[afi
][safi
].name
) {
712 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_DEFAULT
);
713 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
714 rn
= bgp_route_next(rn
)) {
715 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
716 struct attr dummy_attr
;
717 struct bgp_info info
;
719 /* Provide dummy so the route-map can't modify
721 bgp_attr_dup(&dummy_attr
, ri
->attr
);
722 info
.peer
= ri
->peer
;
723 info
.attr
= &dummy_attr
;
725 ret
= route_map_apply(
726 peer
->default_rmap
[afi
][safi
].map
,
727 &rn
->p
, RMAP_BGP
, &info
);
729 /* The route map might have set attributes. If
730 * we don't flush them
731 * here, they will be leaked. */
732 bgp_attr_flush(&dummy_attr
);
733 if (ret
!= RMAP_DENYMATCH
)
736 if (ret
!= RMAP_DENYMATCH
)
739 bgp
->peer_self
->rmap_type
= 0;
741 if (ret
== RMAP_DENYMATCH
)
746 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
747 subgroup_default_withdraw_packet(subgrp
);
748 UNSET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
750 if (!CHECK_FLAG(subgrp
->sflags
,
751 SUBGRP_STATUS_DEFAULT_ORIGINATE
)) {
752 SET_FLAG(subgrp
->sflags
,
753 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
754 subgroup_default_update_packet(subgrp
, &attr
, from
);
756 /* The 'neighbor x.x.x.x default-originate' default will
758 * implicit withdraw for any previous UPDATEs sent for
760 * clear adj_out for the 0.0.0.0/0 prefix in the BGP
764 str2prefix("0.0.0.0/0", &p
);
766 str2prefix("::/0", &p
);
768 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
770 bgp_adj_out_unset_subgroup(
772 BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
);
776 aspath_unintern(&aspath
);
780 * Announce the BGP table to a subgroup.
782 * At startup, we try to optimize route announcement by coalescing the
783 * peer-up events. This is done only the first time - from then on,
784 * subgrp->v_coalesce will be set to zero and the normal logic
787 void subgroup_announce_all(struct update_subgroup
*subgrp
)
793 * If coalesce timer value is not set, announce routes immediately.
795 if (!subgrp
->v_coalesce
) {
796 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
797 zlog_debug("u%" PRIu64
":s%" PRIu64
798 " announcing all routes",
799 subgrp
->update_group
->id
, subgrp
->id
);
800 subgroup_announce_route(subgrp
);
805 * We should wait for the coalesce timer. Arm the timer if not done.
807 if (!subgrp
->t_coalesce
) {
808 thread_add_timer_msec(bm
->master
, subgroup_coalesce_timer
,
809 subgrp
, subgrp
->v_coalesce
,
810 &subgrp
->t_coalesce
);
815 * Go through all update subgroups and set up the adv queue for the
818 void group_announce_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
819 struct bgp_node
*rn
, struct bgp_info
*ri
)
821 struct updwalk_context ctx
;
824 update_group_af_walk(bgp
, afi
, safi
, group_announce_route_walkcb
, &ctx
);
827 void update_group_show_adj_queue(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
828 struct vty
*vty
, uint64_t id
)
830 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVQUEUE
);
833 void update_group_show_advertised(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
834 struct vty
*vty
, uint64_t id
)
836 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVERTISED
);
839 void update_group_announce(struct bgp
*bgp
)
841 update_group_walk(bgp
, update_group_announce_walkcb
, NULL
);
844 void update_group_announce_rrclients(struct bgp
*bgp
)
846 update_group_walk(bgp
, update_group_announce_rrc_walkcb
, NULL
);