1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* BGP-4, BGP-4+ daemon program
3 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro
14 #include "sockunion.h"
23 #include "workqueue.h"
31 #include "lib/sockopt.h"
32 #include "frr_pthread.h"
35 #include "bgpd/bgpd.h"
36 #include "bgpd/bgp_table.h"
37 #include "bgpd/bgp_aspath.h"
38 #include "bgpd/bgp_route.h"
39 #include "bgpd/bgp_dump.h"
40 #include "bgpd/bgp_debug.h"
41 #include "bgpd/bgp_errors.h"
42 #include "bgpd/bgp_community.h"
43 #include "bgpd/bgp_community_alias.h"
44 #include "bgpd/bgp_conditional_adv.h"
45 #include "bgpd/bgp_attr.h"
46 #include "bgpd/bgp_regex.h"
47 #include "bgpd/bgp_clist.h"
48 #include "bgpd/bgp_fsm.h"
49 #include "bgpd/bgp_packet.h"
50 #include "bgpd/bgp_zebra.h"
51 #include "bgpd/bgp_open.h"
52 #include "bgpd/bgp_filter.h"
53 #include "bgpd/bgp_nexthop.h"
54 #include "bgpd/bgp_damp.h"
55 #include "bgpd/bgp_mplsvpn.h"
57 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
58 #include "bgpd/rfapi/rfapi_backend.h"
60 #include "bgpd/bgp_evpn.h"
61 #include "bgpd/bgp_advertise.h"
62 #include "bgpd/bgp_network.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_bfd.h"
68 #include "bgpd/bgp_memory.h"
69 #include "bgpd/bgp_evpn_vty.h"
70 #include "bgpd/bgp_keepalives.h"
71 #include "bgpd/bgp_io.h"
72 #include "bgpd/bgp_ecommunity.h"
73 #include "bgpd/bgp_flowspec.h"
74 #include "bgpd/bgp_labelpool.h"
75 #include "bgpd/bgp_pbr.h"
76 #include "bgpd/bgp_addpath.h"
77 #include "bgpd/bgp_evpn_private.h"
78 #include "bgpd/bgp_evpn_mh.h"
79 #include "bgpd/bgp_mac.h"
80 #include "bgp_trace.h"
82 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
83 DEFINE_MTYPE_STATIC(BGPD
, BGP_EVPN_INFO
, "BGP EVPN instance information");
84 DEFINE_QOBJ_TYPE(bgp_master
);
85 DEFINE_QOBJ_TYPE(bgp
);
86 DEFINE_QOBJ_TYPE(peer
);
87 DEFINE_HOOK(bgp_inst_delete
, (struct bgp
*bgp
), (bgp
));
89 /* BGP process wide configuration. */
90 static struct bgp_master bgp_master
;
92 /* BGP process wide configuration pointer to export. */
93 struct bgp_master
*bm
;
95 /* BGP community-list. */
96 struct community_list_handler
*bgp_clist
;
98 unsigned int multipath_num
= MULTIPATH_NUM
;
100 /* Number of bgp instances configured for suppress fib config */
101 unsigned int bgp_suppress_fib_count
;
103 static void bgp_if_finish(struct bgp
*bgp
);
104 static void peer_drop_dynamic_neighbor(struct peer
*peer
);
106 extern struct zclient
*zclient
;
108 /* handle main socket creation or deletion */
109 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
111 static int bgp_server_main_created
;
112 struct listnode
*node
;
116 if (bgp_server_main_created
)
118 if (list_isempty(bm
->addresses
)) {
119 if (bgp_socket(bgp
, bm
->port
, NULL
) < 0)
120 return BGP_ERR_INVALID_VALUE
;
122 for (ALL_LIST_ELEMENTS_RO(bm
->addresses
, node
, address
))
123 if (bgp_socket(bgp
, bm
->port
, address
) < 0)
124 return BGP_ERR_INVALID_VALUE
;
126 bgp_server_main_created
= 1;
129 if (!bgp_server_main_created
)
132 bgp_server_main_created
= 0;
136 void bgp_session_reset(struct peer
*peer
)
138 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
139 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
140 peer_delete(peer
->doppelganger
);
142 BGP_EVENT_ADD(peer
, BGP_Stop
);
146 * During session reset, we may delete the doppelganger peer, which would
147 * be the next node to the current node. If the session reset was invoked
148 * during walk of peer list, we would end up accessing the freed next
149 * node. This function moves the next node along.
151 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
156 n
= (nnode
) ? *nnode
: NULL
;
157 npeer
= (n
) ? listgetdata(n
) : NULL
;
159 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
160 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
161 PEER_FLAG_CONFIG_NODE
))) {
162 if (peer
->doppelganger
== npeer
)
163 /* nnode and *nnode are confirmed to be non-NULL here */
164 *nnode
= (*nnode
)->next
;
165 peer_delete(peer
->doppelganger
);
168 BGP_EVENT_ADD(peer
, BGP_Stop
);
171 /* BGP global flag manipulation. */
172 int bgp_option_set(int flag
)
176 case BGP_OPT_NO_LISTEN
:
177 case BGP_OPT_NO_ZEBRA
:
178 SET_FLAG(bm
->options
, flag
);
181 return BGP_ERR_INVALID_FLAG
;
186 int bgp_option_unset(int flag
)
190 case BGP_OPT_NO_ZEBRA
:
192 UNSET_FLAG(bm
->options
, flag
);
195 return BGP_ERR_INVALID_FLAG
;
200 int bgp_option_check(int flag
)
202 return CHECK_FLAG(bm
->options
, flag
);
205 /* set the bgp no-rib option during runtime and remove installed routes */
206 void bgp_option_norib_set_runtime(void)
209 struct listnode
*node
;
213 if (bgp_option_check(BGP_OPT_NO_FIB
))
216 bgp_option_set(BGP_OPT_NO_FIB
);
218 zlog_info("Disabled BGP route installation to RIB (Zebra)");
220 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp
)) {
221 FOREACH_AFI_SAFI (afi
, safi
) {
223 * Stop a crash, more work is needed
224 * here to properly add/remove these types of
227 if (!bgp_fibupd_safi(safi
))
230 bgp_zebra_withdraw_table_all_subtypes(bgp
, afi
, safi
);
234 zlog_info("All routes have been withdrawn from RIB (Zebra)");
237 /* unset the bgp no-rib option during runtime and announce routes to Zebra */
238 void bgp_option_norib_unset_runtime(void)
241 struct listnode
*node
;
245 if (!bgp_option_check(BGP_OPT_NO_FIB
))
248 bgp_option_unset(BGP_OPT_NO_FIB
);
250 zlog_info("Enabled BGP route installation to RIB (Zebra)");
252 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp
)) {
253 FOREACH_AFI_SAFI (afi
, safi
) {
255 * Stop a crash, more work is needed
256 * here to properly add/remove these types
257 * of routes from zebra
259 if (!bgp_fibupd_safi(safi
))
262 bgp_zebra_announce_table_all_subtypes(bgp
, afi
, safi
);
266 zlog_info("All routes have been installed in RIB (Zebra)");
269 /* Internal function to set BGP structure configureation flag. */
270 static void bgp_config_set(struct bgp
*bgp
, int config
)
272 SET_FLAG(bgp
->config
, config
);
275 static void bgp_config_unset(struct bgp
*bgp
, int config
)
277 UNSET_FLAG(bgp
->config
, config
);
280 static int bgp_config_check(struct bgp
*bgp
, int config
)
282 return CHECK_FLAG(bgp
->config
, config
);
285 /* Set BGP router identifier; distinguish between explicit config and other
288 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
,
292 struct listnode
*node
, *nnode
;
294 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
297 /* EVPN uses router id in RD, withdraw them */
298 if (is_evpn_enabled())
299 bgp_evpn_handle_router_id_update(bgp
, true);
301 vpn_handle_router_id_update(bgp
, true, is_config
);
303 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
305 /* Set all peer's local identifier with this value. */
306 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
307 IPV4_ADDR_COPY(&peer
->local_id
, id
);
309 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
310 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
311 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
312 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
316 /* EVPN uses router id in RD, update them */
317 if (is_evpn_enabled())
318 bgp_evpn_handle_router_id_update(bgp
, false);
320 vpn_handle_router_id_update(bgp
, false, is_config
);
325 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
327 struct listnode
*node
, *nnode
;
329 struct in_addr
*addr
= NULL
;
331 if (router_id
!= NULL
)
332 addr
= (struct in_addr
*)&(router_id
->u
.prefix4
);
334 if (vrf_id
== VRF_DEFAULT
) {
335 /* Router-id change for default VRF has to also update all
337 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
338 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
342 bgp
->router_id_zebra
= *addr
;
344 addr
= &bgp
->router_id_zebra
;
346 if (!bgp
->router_id_static
.s_addr
) {
347 /* Router ID is updated if there are no active
350 if (bgp
->established_peers
== 0) {
351 if (BGP_DEBUG(zebra
, ZEBRA
))
353 "RID change : vrf %s(%u), RTR ID %pI4",
357 * if old router-id was 0x0, set flag
358 * to use this new value
360 bgp_router_id_set(bgp
, addr
,
361 (bgp
->router_id
.s_addr
369 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
372 bgp
->router_id_zebra
= *addr
;
374 addr
= &bgp
->router_id_zebra
;
376 if (!bgp
->router_id_static
.s_addr
) {
377 /* Router ID is updated if there are no active
380 if (bgp
->established_peers
== 0) {
381 if (BGP_DEBUG(zebra
, ZEBRA
))
383 "RID change : vrf %s(%u), RTR ID %pI4",
387 * if old router-id was 0x0, set flag
388 * to use this new value
390 bgp_router_id_set(bgp
, addr
,
391 (bgp
->router_id
.s_addr
402 void bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
404 bgp
->router_id_static
= id
;
405 bgp_router_id_set(bgp
,
406 id
.s_addr
!= INADDR_ANY
? &id
: &bgp
->router_id_zebra
,
407 true /* is config */);
410 void bm_wait_for_fib_set(bool set
)
412 bool send_msg
= false;
414 if (bm
->wait_for_fib
== set
)
417 bm
->wait_for_fib
= set
;
419 if (bgp_suppress_fib_count
== 0)
421 bgp_suppress_fib_count
++;
423 bgp_suppress_fib_count
--;
424 if (bgp_suppress_fib_count
== 0)
428 if (send_msg
&& zclient
)
429 zebra_route_notify_send(ZEBRA_ROUTE_NOTIFY_REQUEST
,
433 /* Set the suppress fib pending for the bgp configuration */
434 void bgp_suppress_fib_pending_set(struct bgp
*bgp
, bool set
)
436 bool send_msg
= false;
438 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
442 SET_FLAG(bgp
->flags
, BGP_FLAG_SUPPRESS_FIB_PENDING
);
443 /* Send msg to zebra for the first instance of bgp enabled
446 if (bgp_suppress_fib_count
== 0)
448 bgp_suppress_fib_count
++;
450 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SUPPRESS_FIB_PENDING
);
451 bgp_suppress_fib_count
--;
453 /* Send msg to zebra if there are no instances enabled
456 if (bgp_suppress_fib_count
== 0)
459 /* Send route notify request to RIB */
461 if (BGP_DEBUG(zebra
, ZEBRA
))
462 zlog_debug("Sending ZEBRA_ROUTE_NOTIFY_REQUEST");
465 zebra_route_notify_send(ZEBRA_ROUTE_NOTIFY_REQUEST
,
470 /* BGP's cluster-id control. */
471 void bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
474 struct listnode
*node
, *nnode
;
476 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
477 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
480 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
481 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
483 /* Clear all IBGP peer. */
484 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
485 if (peer
->sort
!= BGP_PEER_IBGP
)
488 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
489 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
490 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
491 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
496 void bgp_cluster_id_unset(struct bgp
*bgp
)
499 struct listnode
*node
, *nnode
;
501 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
504 bgp
->cluster_id
.s_addr
= 0;
505 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
507 /* Clear all IBGP peer. */
508 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
509 if (peer
->sort
!= BGP_PEER_IBGP
)
512 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
513 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
514 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
515 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
520 /* BGP timer configuration. */
521 void bgp_timers_set(struct bgp
*bgp
, uint32_t keepalive
, uint32_t holdtime
,
522 uint32_t connect_retry
, uint32_t delayopen
)
524 bgp
->default_keepalive
=
525 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
526 bgp
->default_holdtime
= holdtime
;
527 bgp
->default_connect_retry
= connect_retry
;
528 bgp
->default_delayopen
= delayopen
;
531 /* mostly for completeness - CLI uses its own defaults */
532 void bgp_timers_unset(struct bgp
*bgp
)
534 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
535 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
536 bgp
->default_connect_retry
= BGP_DEFAULT_CONNECT_RETRY
;
537 bgp
->default_delayopen
= BGP_DEFAULT_DELAYOPEN
;
540 void bgp_tcp_keepalive_set(struct bgp
*bgp
, uint16_t keepalive_idle
,
541 uint16_t keepalive_intvl
, uint16_t keepalive_probes
)
543 bgp
->tcp_keepalive_idle
= keepalive_idle
;
544 bgp
->tcp_keepalive_intvl
= keepalive_intvl
;
545 bgp
->tcp_keepalive_probes
= keepalive_probes
;
548 void bgp_tcp_keepalive_unset(struct bgp
*bgp
)
550 bgp
->tcp_keepalive_idle
= 0;
551 bgp
->tcp_keepalive_intvl
= 0;
552 bgp
->tcp_keepalive_probes
= 0;
555 /* BGP confederation configuration. */
556 void bgp_confederation_id_set(struct bgp
*bgp
, as_t as
, const char *as_str
)
559 struct listnode
*node
, *nnode
;
565 /* Remember - were we doing confederation before? */
566 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
568 if (bgp
->confed_id_pretty
)
569 XFREE(MTYPE_BGP
, bgp
->confed_id_pretty
);
570 bgp
->confed_id_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
571 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
573 /* If we were doing confederation already, this is just an external
574 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
575 were not doing confederation before, reset all EBGP sessions. */
576 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
577 enum bgp_peer_sort ptype
= peer_sort(peer
);
579 /* We're looking for peers who's AS is not local or part of our
581 if (already_confed
) {
582 if (ptype
== BGP_PEER_EBGP
) {
584 if (BGP_IS_VALID_STATE_FOR_NOTIF(
587 PEER_DOWN_CONFED_ID_CHANGE
;
589 peer
, BGP_NOTIFY_CEASE
,
590 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
592 bgp_session_reset_safe(peer
, &nnode
);
595 /* Not doign confederation before, so reset every
598 if (ptype
!= BGP_PEER_IBGP
) {
599 /* Reset the local_as to be our EBGP one */
600 if (ptype
== BGP_PEER_EBGP
)
602 if (BGP_IS_VALID_STATE_FOR_NOTIF(
605 PEER_DOWN_CONFED_ID_CHANGE
;
607 peer
, BGP_NOTIFY_CEASE
,
608 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
610 bgp_session_reset_safe(peer
, &nnode
);
617 void bgp_confederation_id_unset(struct bgp
*bgp
)
620 struct listnode
*node
, *nnode
;
623 XFREE(MTYPE_BGP
, bgp
->confed_id_pretty
);
624 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
626 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
627 /* We're looking for peers who's AS is not local */
628 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
629 peer
->local_as
= bgp
->as
;
630 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
631 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
632 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
633 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
637 bgp_session_reset_safe(peer
, &nnode
);
642 /* Is an AS part of the confed or not? */
643 bool bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
650 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
651 if (bgp
->confed_peers
[i
].as
== as
)
657 /* Add an AS to the confederation set. */
658 void bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
, const char *as_str
)
661 struct listnode
*node
, *nnode
;
666 if (bgp_confederation_peers_check(bgp
, as
))
669 bgp
->confed_peers
= XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
670 (bgp
->confed_peers_cnt
+ 1) *
671 sizeof(struct as_confed
));
673 bgp
->confed_peers
[bgp
->confed_peers_cnt
].as
= as
;
674 bgp
->confed_peers
[bgp
->confed_peers_cnt
].as_pretty
=
675 XSTRDUP(MTYPE_BGP
, as_str
);
676 bgp
->confed_peers_cnt
++;
678 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
679 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
680 if (peer
->as
== as
) {
681 peer
->local_as
= bgp
->as
;
682 (void)peer_sort(peer
);
683 if (BGP_IS_VALID_STATE_FOR_NOTIF(
686 PEER_DOWN_CONFED_PEER_CHANGE
;
688 peer
, BGP_NOTIFY_CEASE
,
689 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
691 bgp_session_reset_safe(peer
, &nnode
);
697 /* Delete an AS from the confederation set. */
698 void bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
703 struct listnode
*node
, *nnode
;
708 if (!bgp_confederation_peers_check(bgp
, as
))
711 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
712 if (bgp
->confed_peers
[i
].as
== as
) {
713 XFREE(MTYPE_BGP
, bgp
->confed_peers
[i
].as_pretty
);
714 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++) {
715 bgp
->confed_peers
[j
- 1].as
=
716 bgp
->confed_peers
[j
].as
;
717 bgp
->confed_peers
[j
- 1].as_pretty
=
718 bgp
->confed_peers
[j
].as_pretty
;
722 bgp
->confed_peers_cnt
--;
724 if (bgp
->confed_peers_cnt
== 0) {
725 if (bgp
->confed_peers
)
726 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
727 bgp
->confed_peers
= NULL
;
729 bgp
->confed_peers
= XREALLOC(
730 MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
731 bgp
->confed_peers_cnt
* sizeof(struct as_confed
));
733 /* Now reset any peer who's remote AS has just been removed from the
735 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
736 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
737 if (peer
->as
== as
) {
738 peer
->local_as
= bgp
->confed_id
;
739 (void)peer_sort(peer
);
740 if (BGP_IS_VALID_STATE_FOR_NOTIF(
743 PEER_DOWN_CONFED_PEER_CHANGE
;
745 peer
, BGP_NOTIFY_CEASE
,
746 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
748 bgp_session_reset_safe(peer
, &nnode
);
754 /* Local preference configuration. */
755 void bgp_default_local_preference_set(struct bgp
*bgp
, uint32_t local_pref
)
760 bgp
->default_local_pref
= local_pref
;
763 void bgp_default_local_preference_unset(struct bgp
*bgp
)
768 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
771 /* Local preference configuration. */
772 void bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
,
778 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
781 void bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
785 bgp
->default_subgroup_pkt_queue_max
=
786 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
789 /* Listen limit configuration. */
790 void bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
795 bgp
->dynamic_neighbors_limit
= listen_limit
;
798 void bgp_listen_limit_unset(struct bgp
*bgp
)
803 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
806 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
807 afi_t
*afi
, safi_t
*safi
)
809 /* Map from IANA values to internal values, return error if
810 * values are unrecognized.
812 *afi
= afi_iana2int(pkt_afi
);
813 *safi
= safi_iana2int(pkt_safi
);
814 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
820 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
821 iana_safi_t
*pkt_safi
)
823 /* Map from internal values to IANA values, return error if
824 * internal values are bad (unexpected).
826 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
828 *pkt_afi
= afi_int2iana(afi
);
829 *pkt_safi
= safi_int2iana(safi
);
833 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
842 afid
= afindex(afi
, safi
);
843 if (afid
>= BGP_AF_MAX
)
847 assert(peer
->peer_af_array
[afid
] == NULL
);
849 /* Allocate new peer af */
850 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
852 peer
->peer_af_array
[afid
] = af
;
857 bgp
->af_peer_count
[afi
][safi
]++;
862 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
869 afid
= afindex(afi
, safi
);
870 if (afid
>= BGP_AF_MAX
)
873 return peer
->peer_af_array
[afid
];
876 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
885 afid
= afindex(afi
, safi
);
886 if (afid
>= BGP_AF_MAX
)
889 af
= peer
->peer_af_array
[afid
];
894 bgp_soft_reconfig_table_task_cancel(bgp
, bgp
->rib
[afi
][safi
], peer
);
896 bgp_stop_announce_route_timer(af
);
898 if (PAF_SUBGRP(af
)) {
899 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
900 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
901 af
->subgroup
->update_group
->id
,
902 af
->subgroup
->id
, peer
->host
);
906 update_subgroup_remove_peer(af
->subgroup
, af
);
908 if (bgp
->af_peer_count
[afi
][safi
])
909 bgp
->af_peer_count
[afi
][safi
]--;
911 peer
->peer_af_array
[afid
] = NULL
;
912 XFREE(MTYPE_BGP_PEER_AF
, af
);
916 /* Peer comparison function for sorting. */
917 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
919 if (p1
->group
&& !p2
->group
)
922 if (!p1
->group
&& p2
->group
)
925 if (p1
->group
== p2
->group
) {
926 if (p1
->conf_if
&& !p2
->conf_if
)
929 if (!p1
->conf_if
&& p2
->conf_if
)
932 if (p1
->conf_if
&& p2
->conf_if
)
933 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
935 return strcmp(p1
->group
->name
, p2
->group
->name
);
937 return sockunion_cmp(&p1
->su
, &p2
->su
);
940 static unsigned int peer_hash_key_make(const void *p
)
942 const struct peer
*peer
= p
;
943 return sockunion_hash(&peer
->su
);
946 static bool peer_hash_same(const void *p1
, const void *p2
)
948 const struct peer
*peer1
= p1
;
949 const struct peer
*peer2
= p2
;
951 return (sockunion_same(&peer1
->su
, &peer2
->su
)
952 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
953 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
956 void peer_flag_inherit(struct peer
*peer
, uint64_t flag
)
960 /* Skip if peer is not a peer-group member. */
961 if (!peer_group_active(peer
))
964 /* Unset override flag to signal inheritance from peer-group. */
965 UNSET_FLAG(peer
->flags_override
, flag
);
968 * Inherit flag state from peer-group. If the flag of the peer-group is
969 * not being inverted, the peer must inherit the inverse of the current
970 * peer-group flag state.
972 group_val
= CHECK_FLAG(peer
->group
->conf
->flags
, flag
);
973 if (!CHECK_FLAG(peer
->group
->conf
->flags_invert
, flag
)
974 && CHECK_FLAG(peer
->flags_invert
, flag
))
975 COND_FLAG(peer
->flags
, flag
, !group_val
);
977 COND_FLAG(peer
->flags
, flag
, group_val
);
980 bool peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
,
983 return !!CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
986 void peer_af_flag_inherit(struct peer
*peer
, afi_t afi
, safi_t safi
,
991 /* Skip if peer is not a peer-group member. */
992 if (!peer_group_active(peer
))
995 /* Unset override flag to signal inheritance from peer-group. */
996 UNSET_FLAG(peer
->af_flags_override
[afi
][safi
], flag
);
999 * Inherit flag state from peer-group. If the flag of the peer-group is
1000 * not being inverted, the peer must inherit the inverse of the current
1001 * peer-group flag state.
1003 group_val
= CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
], flag
);
1004 if (!CHECK_FLAG(peer
->group
->conf
->af_flags_invert
[afi
][safi
], flag
)
1005 && CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
1006 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, !group_val
);
1008 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, group_val
);
1011 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
1012 static inline enum bgp_peer_sort
peer_calc_sort(struct peer
*peer
)
1019 if (peer
->change_local_as
)
1020 local_as
= peer
->change_local_as
;
1022 local_as
= peer
->local_as
;
1025 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1026 if (peer
->as_type
== AS_INTERNAL
)
1027 return BGP_PEER_IBGP
;
1029 else if (peer
->as_type
== AS_EXTERNAL
)
1030 return BGP_PEER_EBGP
;
1032 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
) {
1034 return (local_as
== peer
->as
? BGP_PEER_IBGP
1041 assert(peer
->group
);
1042 peer1
= listnode_head(peer
->group
->peer
);
1047 return BGP_PEER_INTERNAL
;
1051 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
1053 return BGP_PEER_INTERNAL
;
1055 if (local_as
== peer
->as
) {
1056 if (bgp
->as
== bgp
->confed_id
) {
1057 if (local_as
== bgp
->as
)
1058 return BGP_PEER_IBGP
;
1060 return BGP_PEER_EBGP
;
1062 if (local_as
== bgp
->confed_id
)
1063 return BGP_PEER_EBGP
;
1065 return BGP_PEER_IBGP
;
1069 if (bgp_confederation_peers_check(bgp
, peer
->as
))
1070 return BGP_PEER_CONFED
;
1072 return BGP_PEER_EBGP
;
1074 if (peer
->as_type
== AS_UNSPECIFIED
) {
1075 /* check if in peer-group with AS information */
1077 && (peer
->group
->conf
->as_type
!= AS_UNSPECIFIED
)) {
1078 if (peer
->group
->conf
->as_type
1080 if (local_as
== peer
->group
->conf
->as
)
1081 return BGP_PEER_IBGP
;
1083 return BGP_PEER_EBGP
;
1084 } else if (peer
->group
->conf
->as_type
1086 return BGP_PEER_IBGP
;
1088 return BGP_PEER_EBGP
;
1090 /* no AS information anywhere, let caller know */
1091 return BGP_PEER_UNSPECIFIED
;
1092 } else if (peer
->as_type
!= AS_SPECIFIED
)
1093 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
1096 return (local_as
== 0 ? BGP_PEER_INTERNAL
1097 : local_as
== peer
->as
? BGP_PEER_IBGP
1102 /* Calculate and cache the peer "sort" */
1103 enum bgp_peer_sort
peer_sort(struct peer
*peer
)
1105 peer
->sort
= peer_calc_sort(peer
);
1109 enum bgp_peer_sort
peer_sort_lookup(struct peer
*peer
)
1114 static void peer_free(struct peer
*peer
)
1119 assert(peer
->status
== Deleted
);
1123 /* this /ought/ to have been done already through bgp_stop earlier,
1124 * but just to be sure..
1126 bgp_timer_set(peer
);
1127 bgp_reads_off(peer
);
1128 bgp_writes_off(peer
);
1129 event_cancel_event_ready(bm
->master
, peer
);
1130 FOREACH_AFI_SAFI (afi
, safi
)
1131 EVENT_OFF(peer
->t_revalidate_all
[afi
][safi
]);
1132 assert(!peer
->t_write
);
1133 assert(!peer
->t_read
);
1134 BGP_EVENT_FLUSH(peer
);
1136 pthread_mutex_destroy(&peer
->io_mtx
);
1138 /* Free connected nexthop, if present */
1139 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1140 && !peer_dynamic_neighbor(peer
))
1141 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
1144 FOREACH_AFI_SAFI (afi
, safi
) {
1145 if (peer
->filter
[afi
][safi
].advmap
.aname
)
1146 XFREE(MTYPE_BGP_FILTER_NAME
,
1147 peer
->filter
[afi
][safi
].advmap
.aname
);
1148 if (peer
->filter
[afi
][safi
].advmap
.cname
)
1149 XFREE(MTYPE_BGP_FILTER_NAME
,
1150 peer
->filter
[afi
][safi
].advmap
.cname
);
1153 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1155 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
1156 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1157 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
1158 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1159 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1161 /* Update source configuration. */
1162 if (peer
->update_source
) {
1163 sockunion_free(peer
->update_source
);
1164 peer
->update_source
= NULL
;
1167 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1169 XFREE(MTYPE_BGP_NOTIFICATION
, peer
->notify
.data
);
1170 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1172 if (peer
->clear_node_queue
)
1173 work_queue_free_and_null(&peer
->clear_node_queue
);
1175 bgp_sync_delete(peer
);
1177 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1179 XFREE(MTYPE_BGP_SOFT_VERSION
, peer
->soft_version
);
1181 /* Remove BFD configuration. */
1182 if (peer
->bfd_config
)
1183 bgp_peer_remove_bfd_config(peer
);
1185 FOREACH_AFI_SAFI (afi
, safi
)
1186 bgp_addpath_set_peer_type(peer
, afi
, safi
, BGP_ADDPATH_NONE
);
1188 if (peer
->change_local_as_pretty
)
1189 XFREE(MTYPE_BGP
, peer
->change_local_as_pretty
);
1190 if (peer
->as_pretty
)
1191 XFREE(MTYPE_BGP
, peer
->as_pretty
);
1193 bgp_unlock(peer
->bgp
);
1195 memset(peer
, 0, sizeof(struct peer
));
1197 XFREE(MTYPE_BGP_PEER
, peer
);
1200 /* increase reference count on a struct peer */
1201 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1203 frrtrace(2, frr_bgp
, bgp_peer_lock
, peer
, name
);
1204 assert(peer
&& (peer
->lock
>= 0));
1211 /* decrease reference count on a struct peer
1212 * struct peer is freed and NULL returned if last reference
1214 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1216 frrtrace(2, frr_bgp
, bgp_peer_unlock
, peer
, name
);
1217 assert(peer
&& (peer
->lock
> 0));
1221 if (peer
->lock
== 0) {
1228 /* BGP GR changes */
1230 int bgp_global_gr_init(struct bgp
*bgp
)
1232 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1233 zlog_debug("%s called ..", __func__
);
1235 int local_GLOBAL_GR_FSM
[BGP_GLOBAL_GR_MODE
][BGP_GLOBAL_GR_EVENT_CMD
] = {
1236 /* GLOBAL_HELPER Mode */
1239 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1240 GLOBAL_GR
, GLOBAL_INVALID
,
1241 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1242 GLOBAL_DISABLE
, GLOBAL_INVALID
1244 /* GLOBAL_GR Mode */
1247 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1248 GLOBAL_GR
, GLOBAL_HELPER
,
1249 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1250 GLOBAL_DISABLE
, GLOBAL_INVALID
1252 /* GLOBAL_DISABLE Mode */
1255 /*GLOBAL_GR_cmd */ /*no_Global_GR_cmd*/
1256 GLOBAL_GR
, GLOBAL_INVALID
,
1257 /*GLOBAL_DISABLE_cmd*//*no_Global_Disable_cmd*/
1258 GLOBAL_INVALID
, GLOBAL_HELPER
1260 /* GLOBAL_INVALID Mode */
1263 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1264 GLOBAL_INVALID
, GLOBAL_INVALID
,
1265 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1266 GLOBAL_INVALID
, GLOBAL_INVALID
1269 memcpy(bgp
->GLOBAL_GR_FSM
, local_GLOBAL_GR_FSM
,
1270 sizeof(local_GLOBAL_GR_FSM
));
1272 bgp
->global_gr_present_state
= GLOBAL_HELPER
;
1273 bgp
->present_zebra_gr_state
= ZEBRA_GR_DISABLE
;
1275 return BGP_GR_SUCCESS
;
1278 int bgp_peer_gr_init(struct peer
*peer
)
1280 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1281 zlog_debug("%s called ..", __func__
);
1283 struct bgp_peer_gr local_Peer_GR_FSM
[BGP_PEER_GR_MODE
]
1284 [BGP_PEER_GR_EVENT_CMD
] = {
1286 /* PEER_HELPER Mode */
1287 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1288 { PEER_GR
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1289 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1290 {PEER_DISABLE
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1291 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1292 { PEER_INVALID
, NULL
}, {PEER_GLOBAL_INHERIT
,
1293 bgp_peer_gr_action
}
1297 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1298 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1299 bgp_peer_gr_action
},
1300 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1301 {PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1302 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1303 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1306 /* PEER_DISABLE Mode */
1307 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1308 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1309 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1310 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1311 bgp_peer_gr_action
},
1312 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1313 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1316 /* PEER_INVALID Mode */
1317 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1318 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1319 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1320 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1321 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1322 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1325 /* PEER_GLOBAL_INHERIT Mode */
1326 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1327 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1328 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1329 { PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1330 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1331 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1334 memcpy(&peer
->PEER_GR_FSM
, local_Peer_GR_FSM
,
1335 sizeof(local_Peer_GR_FSM
));
1336 peer
->peer_gr_present_state
= PEER_GLOBAL_INHERIT
;
1337 bgp_peer_move_to_gr_mode(peer
, PEER_GLOBAL_INHERIT
);
1339 return BGP_GR_SUCCESS
;
1342 static void bgp_srv6_init(struct bgp
*bgp
)
1344 bgp
->srv6_enabled
= false;
1345 memset(bgp
->srv6_locator_name
, 0, sizeof(bgp
->srv6_locator_name
));
1346 bgp
->srv6_locator_chunks
= list_new();
1347 bgp
->srv6_functions
= list_new();
1350 static void bgp_srv6_cleanup(struct bgp
*bgp
)
1352 if (bgp
->srv6_locator_chunks
)
1353 list_delete(&bgp
->srv6_locator_chunks
);
1354 if (bgp
->srv6_functions
)
1355 list_delete(&bgp
->srv6_functions
);
1358 /* Allocate new peer object, implicitely locked. */
1359 struct peer
*peer_new(struct bgp
*bgp
)
1366 /* bgp argument is absolutely required */
1369 /* Allocate new peer. */
1370 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1372 /* Set default value. */
1374 peer
->v_start
= BGP_INIT_START_TIMER
;
1375 peer
->v_connect
= bgp
->default_connect_retry
;
1376 peer
->status
= Idle
;
1377 peer
->ostatus
= Idle
;
1378 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1379 peer
->bgp
= bgp_lock(bgp
);
1380 peer
= peer_lock(peer
); /* initial reference */
1381 peer
->local_role
= ROLE_UNDEFINED
;
1382 peer
->remote_role
= ROLE_UNDEFINED
;
1383 peer
->password
= NULL
;
1384 peer
->max_packet_size
= BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1386 /* Set default flags. */
1387 FOREACH_AFI_SAFI (afi
, safi
) {
1388 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1389 SET_FLAG(peer
->af_flags
[afi
][safi
],
1390 PEER_FLAG_SEND_EXT_COMMUNITY
);
1391 SET_FLAG(peer
->af_flags
[afi
][safi
],
1392 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1394 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1395 PEER_FLAG_SEND_COMMUNITY
);
1396 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1397 PEER_FLAG_SEND_EXT_COMMUNITY
);
1398 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1399 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1400 peer
->addpath_type
[afi
][safi
] = BGP_ADDPATH_NONE
;
1401 peer
->soo
[afi
][safi
] = NULL
;
1404 /* set nexthop-unchanged for l2vpn evpn by default */
1405 SET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1406 PEER_FLAG_NEXTHOP_UNCHANGED
);
1408 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1410 /* Initialize per peer bgp GR FSM */
1411 bgp_peer_gr_init(peer
);
1413 /* Create buffers. */
1414 peer
->ibuf
= stream_fifo_new();
1415 peer
->obuf
= stream_fifo_new();
1416 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1418 /* We use a larger buffer for peer->obuf_work in the event that:
1419 * - We RX a BGP_UPDATE where the attributes alone are just
1420 * under BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE.
1421 * - The user configures an outbound route-map that does many as-path
1422 * prepends or adds many communities. At most they can have
1423 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1424 * large they can make the attributes.
1426 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1427 * bounds checking for every single attribute as we construct an
1431 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1433 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1435 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1437 bgp_sync_init(peer
);
1439 /* Get service port number. */
1440 sp
= getservbyname("bgp", "tcp");
1441 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1443 QOBJ_REG(peer
, peer
);
1448 * This function is invoked when a duplicate peer structure associated with
1449 * a neighbor is being deleted. If this about-to-be-deleted structure is
1450 * the one with all the config, then we have to copy over the info.
1452 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1454 struct peer_af
*paf
;
1462 /* The following function is used by both peer group config copy to
1463 * individual peer and when we transfer config
1465 if (peer_src
->change_local_as
)
1466 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1468 /* peer flags apply */
1469 peer_dst
->flags
= peer_src
->flags
;
1471 * The doppelganger *must* not have a config node stored
1473 UNSET_FLAG(peer_dst
->flags
, PEER_FLAG_CONFIG_NODE
);
1474 peer_dst
->peer_gr_present_state
= peer_src
->peer_gr_present_state
;
1475 peer_dst
->peer_gr_new_status_flag
= peer_src
->peer_gr_new_status_flag
;
1477 peer_dst
->local_as
= peer_src
->local_as
;
1478 peer_dst
->port
= peer_src
->port
;
1479 /* copy tcp_mss value */
1480 peer_dst
->tcp_mss
= peer_src
->tcp_mss
;
1481 (void)peer_sort(peer_dst
);
1482 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1483 peer_dst
->local_role
= peer_src
->local_role
;
1485 peer_dst
->max_packet_size
= peer_src
->max_packet_size
;
1488 peer_dst
->holdtime
= peer_src
->holdtime
;
1489 peer_dst
->keepalive
= peer_src
->keepalive
;
1490 peer_dst
->connect
= peer_src
->connect
;
1491 peer_dst
->delayopen
= peer_src
->delayopen
;
1492 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1493 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1494 peer_dst
->routeadv
= peer_src
->routeadv
;
1495 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1496 peer_dst
->v_delayopen
= peer_src
->v_delayopen
;
1498 /* password apply */
1499 if (peer_src
->password
) {
1500 XFREE(MTYPE_PEER_PASSWORD
, peer_dst
->password
);
1501 peer_dst
->password
=
1502 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1505 FOREACH_AFI_SAFI (afi
, safi
) {
1506 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1507 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1508 peer_dst
->allowas_in
[afi
][safi
] =
1509 peer_src
->allowas_in
[afi
][safi
];
1510 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1511 peer_dst
->addpath_type
[afi
][safi
] =
1512 peer_src
->addpath_type
[afi
][safi
];
1515 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1516 paf
= peer_src
->peer_af_array
[afidx
];
1518 if (!peer_af_find(peer_dst
, paf
->afi
, paf
->safi
))
1519 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1523 /* update-source apply */
1524 if (peer_src
->update_source
) {
1525 if (peer_dst
->update_source
)
1526 sockunion_free(peer_dst
->update_source
);
1527 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1528 peer_dst
->update_source
=
1529 sockunion_dup(peer_src
->update_source
);
1530 } else if (peer_src
->update_if
) {
1531 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1532 if (peer_dst
->update_source
) {
1533 sockunion_free(peer_dst
->update_source
);
1534 peer_dst
->update_source
= NULL
;
1536 peer_dst
->update_if
=
1537 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1540 if (peer_src
->ifname
) {
1541 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1544 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1548 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1549 struct interface
*ifp
)
1551 struct connected
*ifc
;
1554 struct listnode
*node
;
1556 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1557 * IPv4 address of the other end.
1559 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1560 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1561 prefix_copy(&p
, CONNECTED_PREFIX(ifc
));
1562 if (p
.prefixlen
== 30) {
1563 peer
->su
.sa
.sa_family
= AF_INET
;
1564 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1566 peer
->su
.sin
.sin_addr
.s_addr
=
1568 else if (addr
% 4 == 2)
1569 peer
->su
.sin
.sin_addr
.s_addr
=
1571 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1572 peer
->su
.sin
.sin_len
=
1573 sizeof(struct sockaddr_in
);
1574 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1576 } else if (p
.prefixlen
== 31) {
1577 peer
->su
.sa
.sa_family
= AF_INET
;
1578 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1580 peer
->su
.sin
.sin_addr
.s_addr
=
1583 peer
->su
.sin
.sin_addr
.s_addr
=
1585 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1586 peer
->su
.sin
.sin_len
=
1587 sizeof(struct sockaddr_in
);
1588 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1590 } else if (bgp_debug_neighbor_events(peer
))
1592 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1600 static bool bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1601 struct interface
*ifp
)
1603 struct nbr_connected
*ifc_nbr
;
1605 /* Have we learnt the peer's IPv6 link-local address? */
1606 if (ifp
->nbr_connected
1607 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1608 peer
->su
.sa
.sa_family
= AF_INET6
;
1609 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1610 sizeof(struct in6_addr
));
1612 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1614 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1622 * Set or reset the peer address socketunion structure based on the
1623 * learnt/derived peer address. If the address has changed, update the
1624 * password on the listen socket, if needed.
1626 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1628 struct interface
*ifp
;
1630 int peer_addr_updated
= 0;
1631 struct listnode
*node
;
1632 union sockunion old_su
;
1635 * This function is only ever needed when FRR an interface
1636 * based peering, so this simple test will tell us if
1637 * we are in an interface based configuration or not
1644 prev_family
= peer
->su
.sa
.sa_family
;
1645 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1647 /* If BGP unnumbered is not "v6only", we first see if we can
1649 * peer's IPv4 address.
1651 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1653 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1655 /* If "v6only" or we can't derive peer's IPv4 address, see if
1657 * learnt the peer's IPv6 link-local address. This is from the
1659 * IPv6 address in router advertisement.
1661 if (!peer_addr_updated
)
1663 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1665 /* If we could derive the peer address, we may need to install the
1667 * configured for the peer, if any, on the listen socket. Otherwise,
1669 * that peer's address is not available and uninstall the password, if
1672 if (peer_addr_updated
) {
1673 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1674 && prev_family
== AF_UNSPEC
)
1677 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1678 && prev_family
!= AF_UNSPEC
)
1679 bgp_md5_unset(peer
);
1680 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1681 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1685 * If they are the same, nothing to do here, move along
1687 if (!sockunion_same(&old_su
, &peer
->su
)) {
1688 union sockunion new_su
= peer
->su
;
1689 struct bgp
*bgp
= peer
->bgp
;
1692 * Our peer structure is stored in the bgp->peerhash
1693 * release it before we modify anything in both the
1694 * hash and the list. But *only* if the peer
1695 * is in the bgp->peerhash as that on deletion
1696 * we call bgp_stop which calls this function :(
1697 * so on deletion let's remove from the list first
1698 * and then do the deletion preventing this from
1699 * being added back on the list below when we
1700 * fail to remove it up here.
1704 * listnode_lookup just scans the list
1705 * for the peer structure so it's safe
1706 * to use without modifying the su
1708 node
= listnode_lookup(bgp
->peer
, peer
);
1711 * Let's reset the peer->su release and
1712 * reset it and put it back. We have to
1713 * do this because hash_release will
1714 * scan through looking for a matching
1718 hash_release(peer
->bgp
->peerhash
, peer
);
1719 listnode_delete(peer
->bgp
->peer
, peer
);
1722 (void)hash_get(peer
->bgp
->peerhash
, peer
,
1724 listnode_add_sort(peer
->bgp
->peer
, peer
);
1729 void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1731 struct bgp_dest
*dest
, *ndest
;
1732 struct bgp_table
*table
;
1734 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
1735 dest
= bgp_route_next(dest
)) {
1736 table
= bgp_dest_get_bgp_table_info(dest
);
1737 if (table
!= NULL
) {
1738 /* Special handling for 2-level routing
1740 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1741 || safi
== SAFI_EVPN
) {
1742 for (ndest
= bgp_table_top(table
); ndest
;
1743 ndest
= bgp_route_next(ndest
))
1744 bgp_process(bgp
, ndest
, afi
, safi
);
1746 bgp_process(bgp
, dest
, afi
, safi
);
1751 /* Force a bestpath recalculation for all prefixes. This is used
1752 * when 'bgp bestpath' commands are entered.
1754 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1759 FOREACH_AFI_SAFI (afi
, safi
) {
1760 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1765 * Create new BGP peer.
1767 * conf_if and su are mutually exclusive if configuring from the cli.
1768 * If we are handing a doppelganger, then we *must* pass in both
1769 * the original peer's su and conf_if, so that we can appropriately
1770 * track the bgp->peerhash( ie we don't want to remove the current
1771 * one from the config ).
1773 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1774 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1775 int as_type
, struct peer_group
*group
,
1776 bool config_node
, const char *as_str
)
1780 char buf
[SU_ADDRSTRLEN
];
1784 peer
= peer_new(bgp
);
1786 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1790 bgp_peer_conf_if_to_su_update(peer
);
1791 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1792 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1795 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1796 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1797 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1799 peer
->local_as
= local_as
;
1800 peer
->as
= remote_as
;
1801 /* internal and external values do not use as_pretty */
1802 if (as_str
&& asn_str2asn(as_str
, NULL
))
1803 peer
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
1804 peer
->as_type
= as_type
;
1805 peer
->local_id
= bgp
->router_id
;
1806 peer
->v_holdtime
= bgp
->default_holdtime
;
1807 peer
->v_keepalive
= bgp
->default_keepalive
;
1808 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1809 ? BGP_DEFAULT_IBGP_ROUTEADV
1810 : BGP_DEFAULT_EBGP_ROUTEADV
;
1811 if (bgp_config_inprocess())
1812 peer
->shut_during_cfg
= true;
1814 peer
= peer_lock(peer
); /* bgp peer list reference */
1815 peer
->group
= group
;
1816 listnode_add_sort(bgp
->peer
, peer
);
1819 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1821 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1823 /* Adjust update-group coalesce timer heuristics for # peers. */
1824 if (bgp
->heuristic_coalesce
) {
1825 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1827 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1828 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1831 active
= peer_active(peer
);
1833 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
)
1834 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1836 peer
->last_reset
= PEER_DOWN_NOAFI_ACTIVATED
;
1839 /* Last read and reset time set */
1840 peer
->readtime
= peer
->resettime
= monotime(NULL
);
1842 /* Default TTL set. */
1843 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: BGP_DEFAULT_TTL
;
1845 /* Default configured keepalives count for shutdown rtt command */
1846 peer
->rtt_keepalive_conf
= 1;
1848 /* If 'bgp default <afi>-<safi>' is configured, then activate the
1849 * neighbor for the corresponding address family. IPv4 Unicast is
1850 * the only address family enabled by default without expliict
1853 FOREACH_AFI_SAFI (afi
, safi
) {
1854 if (bgp
->default_af
[afi
][safi
]) {
1855 peer
->afc
[afi
][safi
] = 1;
1856 peer_af_create(peer
, afi
, safi
);
1860 /* auto shutdown if configured */
1861 if (bgp
->autoshutdown
)
1862 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1863 /* Set up peer's events and timers. */
1864 else if (!active
&& peer_active(peer
))
1865 bgp_timer_set(peer
);
1867 bgp_peer_gr_flags_update(peer
);
1868 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp
, bgp
->peer
);
1873 /* Make accept BGP peer. This function is only called from the test code */
1874 struct peer
*peer_create_accept(struct bgp
*bgp
)
1878 peer
= peer_new(bgp
);
1880 peer
= peer_lock(peer
); /* bgp peer list reference */
1881 listnode_add_sort(bgp
->peer
, peer
);
1882 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1888 * Return true if we have a peer configured to use this afi/safi
1890 bool bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1892 struct listnode
*node
;
1895 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1896 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1899 if (peer
->afc
[afi
][safi
])
1906 /* Change peer's AS number. */
1907 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
,
1910 enum bgp_peer_sort origtype
, newtype
;
1913 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1914 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1915 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1916 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1917 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1919 bgp_session_reset(peer
);
1921 origtype
= peer_sort_lookup(peer
);
1923 if (as_specified
== AS_SPECIFIED
&& as_str
) {
1924 if (peer
->as_pretty
)
1925 XFREE(MTYPE_BGP
, peer
->as_pretty
);
1926 peer
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
1927 } else if (peer
->as_type
== AS_UNSPECIFIED
&& peer
->as_pretty
)
1928 XFREE(MTYPE_BGP
, peer
->as_pretty
);
1929 peer
->as_type
= as_specified
;
1931 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1932 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1933 && peer
->bgp
->as
!= as
)
1934 peer
->local_as
= peer
->bgp
->confed_id
;
1936 peer
->local_as
= peer
->bgp
->as
;
1938 newtype
= peer_sort(peer
);
1939 /* Advertisement-interval reset */
1940 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1941 peer
->v_routeadv
= (newtype
== BGP_PEER_IBGP
)
1942 ? BGP_DEFAULT_IBGP_ROUTEADV
1943 : BGP_DEFAULT_EBGP_ROUTEADV
;
1947 if (newtype
== BGP_PEER_IBGP
)
1949 else if (origtype
== BGP_PEER_IBGP
)
1950 peer
->ttl
= BGP_DEFAULT_TTL
;
1952 /* reflector-client reset */
1953 if (newtype
!= BGP_PEER_IBGP
) {
1954 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1955 PEER_FLAG_REFLECTOR_CLIENT
);
1956 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1957 PEER_FLAG_REFLECTOR_CLIENT
);
1958 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1959 PEER_FLAG_REFLECTOR_CLIENT
);
1960 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1961 PEER_FLAG_REFLECTOR_CLIENT
);
1962 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1963 PEER_FLAG_REFLECTOR_CLIENT
);
1964 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1965 PEER_FLAG_REFLECTOR_CLIENT
);
1966 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1967 PEER_FLAG_REFLECTOR_CLIENT
);
1968 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1969 PEER_FLAG_REFLECTOR_CLIENT
);
1970 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1971 PEER_FLAG_REFLECTOR_CLIENT
);
1972 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1973 PEER_FLAG_REFLECTOR_CLIENT
);
1974 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1975 PEER_FLAG_REFLECTOR_CLIENT
);
1976 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1977 PEER_FLAG_REFLECTOR_CLIENT
);
1978 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1979 PEER_FLAG_REFLECTOR_CLIENT
);
1983 /* If peer does not exist, create new one. If peer already exists,
1984 set AS number to the peer. */
1985 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1986 as_t
*as
, int as_type
, const char *as_str
)
1992 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1994 peer
= peer_lookup(bgp
, su
);
1997 /* Not allowed for a dynamic peer. */
1998 if (peer_dynamic_neighbor(peer
)) {
2000 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
2003 /* When this peer is a member of peer-group. */
2005 /* peer-group already has AS number/internal/external */
2006 if (peer
->group
->conf
->as
2007 || peer
->group
->conf
->as_type
) {
2008 /* Return peer group's AS number. */
2009 *as
= peer
->group
->conf
->as
;
2010 return BGP_ERR_PEER_GROUP_MEMBER
;
2013 enum bgp_peer_sort peer_sort_type
=
2014 peer_sort(peer
->group
->conf
);
2016 /* Explicit AS numbers used, compare AS numbers */
2017 if (as_type
== AS_SPECIFIED
) {
2018 if (((peer_sort_type
== BGP_PEER_IBGP
)
2019 && (bgp
->as
!= *as
))
2020 || ((peer_sort_type
== BGP_PEER_EBGP
)
2021 && (bgp
->as
== *as
))) {
2023 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2026 /* internal/external used, compare as-types */
2027 if (((peer_sort_type
== BGP_PEER_IBGP
)
2028 && (as_type
!= AS_INTERNAL
))
2029 || ((peer_sort_type
== BGP_PEER_EBGP
)
2030 && (as_type
!= AS_EXTERNAL
))) {
2032 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2037 /* Existing peer's AS number change. */
2038 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2039 || (peer
->as_type
!= as_type
))
2040 peer_as_change(peer
, *as
, as_type
, as_str
);
2043 return BGP_ERR_NO_INTERFACE_CONFIG
;
2045 /* If the peer is not part of our confederation, and its not an
2046 iBGP peer then spoof the source AS */
2047 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
) &&
2048 !bgp_confederation_peers_check(bgp
, *as
) && *as
&&
2050 local_as
= bgp
->confed_id
;
2054 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, NULL
,
2061 const char *bgp_get_name_by_role(uint8_t role
)
2066 case ROLE_RS_SERVER
:
2068 case ROLE_RS_CLIENT
:
2074 case ROLE_UNDEFINED
:
2080 enum asnotation_mode
bgp_get_asnotation(struct bgp
*bgp
)
2083 return ASNOTATION_PLAIN
;
2084 return bgp
->asnotation
;
2087 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
2088 struct peer
*peer
, afi_t afi
,
2092 int out
= FILTER_OUT
;
2094 uint64_t pflags_ovrd
;
2095 uint8_t *pfilter_ovrd
;
2099 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
2100 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
2102 /* peer af_flags apply */
2103 flags_tmp
= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
2104 flags_tmp
^= conf
->af_flags_invert
[afi
][safi
]
2105 ^ peer
->af_flags_invert
[afi
][safi
];
2106 flags_tmp
&= ~pflags_ovrd
;
2108 UNSET_FLAG(peer
->af_flags
[afi
][safi
], ~pflags_ovrd
);
2109 SET_FLAG(peer
->af_flags
[afi
][safi
], flags_tmp
);
2110 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
2111 conf
->af_flags_invert
[afi
][safi
]);
2113 /* maximum-prefix */
2114 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
2115 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
2116 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
2117 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
2120 /* maximum-prefix-out */
2121 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX_OUT
))
2122 PEER_ATTR_INHERIT(peer
, group
, pmax_out
[afi
][safi
]);
2125 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
2126 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
2129 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_SOO
))
2130 PEER_ATTR_INHERIT(peer
, group
, soo
[afi
][safi
]);
2133 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
2134 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
2136 /* default-originate route-map */
2137 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
2138 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
2139 MTYPE_ROUTE_MAP_NAME
);
2140 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
2143 /* inbound filter apply */
2144 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
2145 PEER_STR_ATTR_INHERIT(peer
, group
,
2146 filter
[afi
][safi
].dlist
[in
].name
,
2147 MTYPE_BGP_FILTER_NAME
);
2148 PEER_ATTR_INHERIT(peer
, group
,
2149 filter
[afi
][safi
].dlist
[in
].alist
);
2152 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
2153 PEER_STR_ATTR_INHERIT(peer
, group
,
2154 filter
[afi
][safi
].plist
[in
].name
,
2155 MTYPE_BGP_FILTER_NAME
);
2156 PEER_ATTR_INHERIT(peer
, group
,
2157 filter
[afi
][safi
].plist
[in
].plist
);
2160 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
2161 PEER_STR_ATTR_INHERIT(peer
, group
,
2162 filter
[afi
][safi
].aslist
[in
].name
,
2163 MTYPE_BGP_FILTER_NAME
);
2164 PEER_ATTR_INHERIT(peer
, group
,
2165 filter
[afi
][safi
].aslist
[in
].aslist
);
2168 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
2169 PEER_STR_ATTR_INHERIT(peer
, group
,
2170 filter
[afi
][safi
].map
[in
].name
,
2171 MTYPE_BGP_FILTER_NAME
);
2172 PEER_ATTR_INHERIT(peer
, group
,
2173 filter
[afi
][safi
].map
[RMAP_IN
].map
);
2176 /* outbound filter apply */
2177 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
2178 PEER_STR_ATTR_INHERIT(peer
, group
,
2179 filter
[afi
][safi
].dlist
[out
].name
,
2180 MTYPE_BGP_FILTER_NAME
);
2181 PEER_ATTR_INHERIT(peer
, group
,
2182 filter
[afi
][safi
].dlist
[out
].alist
);
2185 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
2186 PEER_STR_ATTR_INHERIT(peer
, group
,
2187 filter
[afi
][safi
].plist
[out
].name
,
2188 MTYPE_BGP_FILTER_NAME
);
2189 PEER_ATTR_INHERIT(peer
, group
,
2190 filter
[afi
][safi
].plist
[out
].plist
);
2193 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
2194 PEER_STR_ATTR_INHERIT(peer
, group
,
2195 filter
[afi
][safi
].aslist
[out
].name
,
2196 MTYPE_BGP_FILTER_NAME
);
2197 PEER_ATTR_INHERIT(peer
, group
,
2198 filter
[afi
][safi
].aslist
[out
].aslist
);
2201 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
2202 PEER_STR_ATTR_INHERIT(peer
, group
,
2203 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
2204 MTYPE_BGP_FILTER_NAME
);
2205 PEER_ATTR_INHERIT(peer
, group
,
2206 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
2209 /* nondirectional filter apply */
2210 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
2211 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
2212 MTYPE_BGP_FILTER_NAME
);
2213 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
2216 /* Conditional Advertisements */
2217 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ADVERTISE_MAP
)) {
2218 PEER_STR_ATTR_INHERIT(peer
, group
,
2219 filter
[afi
][safi
].advmap
.aname
,
2220 MTYPE_BGP_FILTER_NAME
);
2221 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.amap
);
2222 PEER_STR_ATTR_INHERIT(peer
, group
,
2223 filter
[afi
][safi
].advmap
.cname
,
2224 MTYPE_BGP_FILTER_NAME
);
2225 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.cmap
);
2226 PEER_ATTR_INHERIT(peer
, group
,
2227 filter
[afi
][safi
].advmap
.condition
);
2230 if (peer
->addpath_type
[afi
][safi
] == BGP_ADDPATH_NONE
) {
2231 peer
->addpath_type
[afi
][safi
] = conf
->addpath_type
[afi
][safi
];
2232 bgp_addpath_type_changed(conf
->bgp
);
2236 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
2241 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2242 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2243 __func__
, peer
->host
);
2247 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
2249 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2250 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
2251 return BGP_ERR_PEER_SAFI_CONFLICT
;
2253 /* Nothing to do if we've already activated this peer */
2254 if (peer
->afc
[afi
][safi
])
2257 if (peer_af_create(peer
, afi
, safi
) == NULL
)
2260 active
= peer_active(peer
);
2261 peer
->afc
[afi
][safi
] = 1;
2264 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
2266 if (!active
&& peer_active(peer
)) {
2267 bgp_timer_set(peer
);
2269 if (peer_established(peer
)) {
2270 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2271 peer
->afc_adv
[afi
][safi
] = 1;
2272 bgp_capability_send(peer
, afi
, safi
,
2274 CAPABILITY_ACTION_SET
);
2275 if (peer
->afc_recv
[afi
][safi
]) {
2276 peer
->afc_nego
[afi
][safi
] = 1;
2277 bgp_announce_route(peer
, afi
, safi
,
2281 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2282 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2283 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2286 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
2287 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2288 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2289 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2292 * If we are turning on a AFI/SAFI locally and we've
2293 * started bringing a peer up, we need to tell
2294 * the other peer to restart because we might loose
2295 * configuration here because when the doppelganger
2296 * gets to a established state due to how
2297 * we resolve we could just overwrite the afi/safi
2300 other
= peer
->doppelganger
;
2302 && (other
->status
== OpenSent
2303 || other
->status
== OpenConfirm
)) {
2304 other
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2305 bgp_notify_send(other
, BGP_NOTIFY_CEASE
,
2306 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2313 /* Activate the peer or peer group for specified AFI and SAFI. */
2314 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2317 struct peer_group
*group
;
2318 struct listnode
*node
, *nnode
;
2319 struct peer
*tmp_peer
;
2322 /* Nothing to do if we've already activated this peer */
2323 if (peer
->afc
[afi
][safi
])
2328 /* This is a peer-group so activate all of the members of the
2329 * peer-group as well */
2330 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2332 /* Do not activate a peer for both SAFI_UNICAST and
2333 * SAFI_LABELED_UNICAST */
2334 if ((safi
== SAFI_UNICAST
2335 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2336 || (safi
== SAFI_LABELED_UNICAST
2337 && peer
->afc
[afi
][SAFI_UNICAST
]))
2338 return BGP_ERR_PEER_SAFI_CONFLICT
;
2340 peer
->afc
[afi
][safi
] = 1;
2341 group
= peer
->group
;
2343 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2344 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2347 ret
|= peer_activate_af(peer
, afi
, safi
);
2350 /* If this is the first peer to be activated for this
2351 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2352 if (ret
!= BGP_ERR_PEER_SAFI_CONFLICT
&& safi
== SAFI_LABELED_UNICAST
2353 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2355 if (BGP_DEBUG(zebra
, ZEBRA
))
2357 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2359 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2360 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2363 if (safi
== SAFI_FLOWSPEC
) {
2364 /* connect to table manager */
2365 bgp_zebra_init_tm_connect(bgp
);
2370 static bool non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2373 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2374 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2375 __func__
, peer
->host
);
2379 /* Nothing to do if we've already deactivated this peer */
2380 if (!peer
->afc
[afi
][safi
])
2383 /* De-activate the address family configuration. */
2384 peer
->afc
[afi
][safi
] = 0;
2386 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2387 flog_err(EC_BGP_PEER_DELETE
,
2388 "couldn't delete af structure for peer %s(%s, %s)",
2389 peer
->host
, afi2str(afi
), safi2str(safi
));
2393 if (peer_established(peer
)) {
2394 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2395 peer
->afc_adv
[afi
][safi
] = 0;
2396 peer
->afc_nego
[afi
][safi
] = 0;
2398 if (peer_active_nego(peer
)) {
2399 bgp_capability_send(peer
, afi
, safi
,
2401 CAPABILITY_ACTION_UNSET
);
2402 bgp_clear_route(peer
, afi
, safi
);
2403 peer
->pcount
[afi
][safi
] = 0;
2405 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2406 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2407 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2410 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2411 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2412 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2419 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2422 struct peer_group
*group
;
2423 struct peer
*tmp_peer
;
2424 struct listnode
*node
, *nnode
;
2427 /* Nothing to do if we've already de-activated this peer */
2428 if (!peer
->afc
[afi
][safi
])
2431 /* This is a peer-group so de-activate all of the members of the
2432 * peer-group as well */
2433 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2434 peer
->afc
[afi
][safi
] = 0;
2435 group
= peer
->group
;
2437 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2438 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2441 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2446 /* If this is the last peer to be deactivated for this
2447 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2448 if (safi
== SAFI_LABELED_UNICAST
2449 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2450 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2452 if (BGP_DEBUG(zebra
, ZEBRA
))
2454 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2456 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2457 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2462 void peer_nsf_stop(struct peer
*peer
)
2467 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2468 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2470 FOREACH_AFI_SAFI_NSF (afi
, safi
) {
2471 peer
->nsf
[afi
][safi
] = 0;
2472 EVENT_OFF(peer
->t_llgr_stale
[afi
][safi
]);
2475 if (peer
->t_gr_restart
) {
2476 EVENT_OFF(peer
->t_gr_restart
);
2477 if (bgp_debug_neighbor_events(peer
))
2478 zlog_debug("%pBP graceful restart timer stopped", peer
);
2480 if (peer
->t_gr_stale
) {
2481 EVENT_OFF(peer
->t_gr_stale
);
2482 if (bgp_debug_neighbor_events(peer
))
2484 "%pBP graceful restart stalepath timer stopped",
2487 bgp_clear_route_all(peer
);
2490 /* Delete peer from confguration.
2492 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2493 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2495 * This function /should/ take care to be idempotent, to guard against
2496 * it being called multiple times through stray events that come in
2497 * that happen to result in this function being called again. That
2498 * said, getting here for a "Deleted" peer is a bug in the neighbour
2501 int peer_delete(struct peer
*peer
)
2507 struct bgp_filter
*filter
;
2508 struct listnode
*pn
;
2511 assert(peer
->status
!= Deleted
);
2514 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2516 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, peer
);
2518 bgp_keepalives_off(peer
);
2519 bgp_reads_off(peer
);
2520 bgp_writes_off(peer
);
2521 event_cancel_event_ready(bm
->master
, peer
);
2522 FOREACH_AFI_SAFI (afi
, safi
)
2523 EVENT_OFF(peer
->t_revalidate_all
[afi
][safi
]);
2524 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2525 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2526 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_KEEPALIVES_ON
));
2528 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2529 peer_nsf_stop(peer
);
2531 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2533 /* Remove BFD settings. */
2534 if (peer
->bfd_config
)
2535 bgp_peer_remove_bfd_config(peer
);
2537 /* If this peer belongs to peer group, clear up the
2540 if (peer_dynamic_neighbor(peer
))
2541 peer_drop_dynamic_neighbor(peer
);
2543 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2545 peer
); /* group->peer list reference */
2546 list_delete_node(peer
->group
->peer
, pn
);
2551 /* Withdraw all information from routing table. We can not use
2552 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2553 * executed after peer structure is deleted.
2555 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2557 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2559 if (peer
->doppelganger
) {
2560 peer
->doppelganger
->doppelganger
= NULL
;
2561 peer
->doppelganger
= NULL
;
2564 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2565 bgp_fsm_change_status(peer
, Deleted
);
2567 /* Remove from NHT */
2568 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2569 bgp_unlink_nexthop_by_peer(peer
);
2571 /* Password configuration */
2572 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)) {
2573 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2574 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2575 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2576 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
))
2577 bgp_md5_unset(peer
);
2580 bgp_timer_set(peer
); /* stops all timers for Deleted */
2582 /* Delete from all peer list. */
2583 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2584 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2586 * Removing from the list node first because
2587 * peer_unlock *can* call peer_delete( I know,
2588 * I know ). So let's remove it and in
2589 * the su recalculate function we'll ensure
2590 * it's in there or not.
2592 list_delete_node(bgp
->peer
, pn
);
2593 hash_release(bgp
->peerhash
, peer
);
2594 peer_unlock(peer
); /* bgp peer list reference */
2599 stream_fifo_free(peer
->ibuf
);
2604 stream_fifo_free(peer
->obuf
);
2608 if (peer
->ibuf_work
) {
2609 ringbuf_del(peer
->ibuf_work
);
2610 peer
->ibuf_work
= NULL
;
2613 if (peer
->obuf_work
) {
2614 stream_free(peer
->obuf_work
);
2615 peer
->obuf_work
= NULL
;
2618 if (peer
->scratch
) {
2619 stream_free(peer
->scratch
);
2620 peer
->scratch
= NULL
;
2623 /* Local and remote addresses. */
2624 if (peer
->su_local
) {
2625 sockunion_free(peer
->su_local
);
2626 peer
->su_local
= NULL
;
2629 if (peer
->su_remote
) {
2630 sockunion_free(peer
->su_remote
);
2631 peer
->su_remote
= NULL
;
2634 /* Free filter related memory. */
2635 FOREACH_AFI_SAFI (afi
, safi
) {
2636 filter
= &peer
->filter
[afi
][safi
];
2638 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2639 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2640 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2641 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2644 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2645 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2648 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2649 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2650 ecommunity_free(&peer
->soo
[afi
][safi
]);
2653 FOREACH_AFI_SAFI (afi
, safi
)
2654 peer_af_delete(peer
, afi
, safi
);
2656 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2657 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2658 XFREE(MTYPE_BGP_SOFT_VERSION
, peer
->soft_version
);
2660 peer_unlock(peer
); /* initial reference */
2665 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2667 return strcmp(g1
->name
, g2
->name
);
2670 /* Peer group cofiguration. */
2671 static struct peer_group
*peer_group_new(void)
2673 return XCALLOC(MTYPE_PEER_GROUP
, sizeof(struct peer_group
));
2676 static void peer_group_free(struct peer_group
*group
)
2678 XFREE(MTYPE_PEER_GROUP
, group
);
2681 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2683 struct peer_group
*group
;
2684 struct listnode
*node
, *nnode
;
2686 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2687 if (strcmp(group
->name
, name
) == 0)
2693 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2695 struct peer_group
*group
;
2699 group
= peer_group_lookup(bgp
, name
);
2703 group
= peer_group_new();
2705 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2706 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2707 group
->peer
= list_new();
2708 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2709 group
->listen_range
[afi
] = list_new();
2710 group
->conf
= peer_new(bgp
);
2711 FOREACH_AFI_SAFI (afi
, safi
) {
2712 if (bgp
->default_af
[afi
][safi
])
2713 group
->conf
->afc
[afi
][safi
] = 1;
2715 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2716 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2717 group
->conf
->group
= group
;
2718 group
->conf
->as
= 0;
2719 group
->conf
->ttl
= BGP_DEFAULT_TTL
;
2720 group
->conf
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
2721 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2722 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2723 listnode_add_sort(bgp
->group
, group
);
2728 static void peer_group2peer_config_copy(struct peer_group
*group
,
2733 bool config_node
= !!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2739 peer
->as
= conf
->as
;
2742 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_LOCAL_AS
))
2743 peer
->change_local_as
= conf
->change_local_as
;
2745 /* If peer-group has configured TTL then override it */
2746 if (conf
->ttl
!= BGP_DEFAULT_TTL
)
2747 peer
->ttl
= conf
->ttl
;
2750 peer
->gtsm_hops
= conf
->gtsm_hops
;
2752 /* peer flags apply */
2753 flags_tmp
= conf
->flags
& ~peer
->flags_override
;
2754 flags_tmp
^= conf
->flags_invert
^ peer
->flags_invert
;
2755 flags_tmp
&= ~peer
->flags_override
;
2757 UNSET_FLAG(peer
->flags
, ~peer
->flags_override
);
2758 SET_FLAG(peer
->flags
, flags_tmp
);
2759 SET_FLAG(peer
->flags_invert
, conf
->flags_invert
);
2762 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2764 /* peer timers apply */
2765 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2766 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2767 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2770 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2771 PEER_ATTR_INHERIT(peer
, group
, connect
);
2772 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2773 peer
->v_connect
= conf
->connect
;
2775 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
2778 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_DELAYOPEN
)) {
2779 PEER_ATTR_INHERIT(peer
, group
, delayopen
);
2780 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
2781 peer
->v_delayopen
= conf
->delayopen
;
2783 peer
->v_delayopen
= peer
->bgp
->default_delayopen
;
2786 /* advertisement-interval apply */
2787 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2788 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2789 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2790 peer
->v_routeadv
= conf
->routeadv
;
2792 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2793 ? BGP_DEFAULT_IBGP_ROUTEADV
2794 : BGP_DEFAULT_EBGP_ROUTEADV
;
2797 /* capability extended-nexthop apply */
2798 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_CAPABILITY_ENHE
))
2799 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2800 SET_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
);
2802 /* capability software-version apply */
2803 if (!CHECK_FLAG(peer
->flags_override
,
2804 PEER_FLAG_CAPABILITY_SOFT_VERSION
))
2805 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_SOFT_VERSION
))
2806 SET_FLAG(peer
->flags
,
2807 PEER_FLAG_CAPABILITY_SOFT_VERSION
);
2809 /* password apply */
2810 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_PASSWORD
))
2811 PEER_STR_ATTR_INHERIT(peer
, group
, password
,
2812 MTYPE_PEER_PASSWORD
);
2814 if (!BGP_PEER_SU_UNSPEC(peer
))
2817 /* update-source apply */
2818 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_UPDATE_SOURCE
)) {
2819 if (conf
->update_source
) {
2820 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2821 PEER_SU_ATTR_INHERIT(peer
, group
, update_source
);
2822 } else if (conf
->update_if
) {
2823 sockunion_free(peer
->update_source
);
2824 PEER_STR_ATTR_INHERIT(peer
, group
, update_if
,
2825 MTYPE_PEER_UPDATE_SOURCE
);
2830 PEER_ATTR_INHERIT(peer
, group
, local_role
);
2832 /* Update GR flags for the peer. */
2833 bgp_peer_gr_flags_update(peer
);
2835 /* Apply BFD settings from group to peer if it exists. */
2836 if (conf
->bfd_config
) {
2837 bgp_peer_configure_bfd(peer
, false);
2838 bgp_peer_config_apply(peer
, group
);
2842 /* Peer group's remote AS configuration. */
2843 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2844 int as_type
, const char *as_str
)
2846 struct peer_group
*group
;
2848 struct listnode
*node
, *nnode
;
2850 group
= peer_group_lookup(bgp
, group_name
);
2854 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2858 /* When we setup peer-group AS number all peer group member's AS
2859 number must be updated to same number. */
2860 peer_as_change(group
->conf
, *as
, as_type
, as_str
);
2862 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2863 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2864 || (peer
->as_type
!= as_type
))
2865 peer_as_change(peer
, *as
, as_type
, as_str
);
2871 void peer_notify_unconfig(struct peer
*peer
)
2873 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2874 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2875 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
2878 static void peer_notify_shutdown(struct peer
*peer
)
2880 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
2881 if (bgp_debug_neighbor_events(peer
))
2883 "%pBP configured Graceful-Restart, skipping shutdown notification",
2888 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2889 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2890 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
2893 void peer_group_notify_unconfig(struct peer_group
*group
)
2895 struct peer
*peer
, *other
;
2896 struct listnode
*node
, *nnode
;
2898 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2899 other
= peer
->doppelganger
;
2900 if (other
&& other
->status
!= Deleted
) {
2901 other
->group
= NULL
;
2902 peer_notify_unconfig(other
);
2904 peer_notify_unconfig(peer
);
2908 int peer_group_delete(struct peer_group
*group
)
2912 struct prefix
*prefix
;
2914 struct listnode
*node
, *nnode
;
2919 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2920 other
= peer
->doppelganger
;
2922 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2923 bgp_zebra_terminate_radv(bgp
, peer
);
2926 if (other
&& other
->status
!= Deleted
) {
2927 other
->group
= NULL
;
2931 list_delete(&group
->peer
);
2933 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2934 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2936 prefix_free(&prefix
);
2938 list_delete(&group
->listen_range
[afi
]);
2941 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2944 if (group
->conf
->bfd_config
)
2945 bgp_peer_remove_bfd_config(group
->conf
);
2947 group
->conf
->group
= NULL
;
2948 peer_delete(group
->conf
);
2950 /* Delete from all peer_group list. */
2951 listnode_delete(bgp
->group
, group
);
2953 peer_group_free(group
);
2958 int peer_group_remote_as_delete(struct peer_group
*group
)
2960 struct peer
*peer
, *other
;
2961 struct listnode
*node
, *nnode
;
2963 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2964 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2967 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2968 other
= peer
->doppelganger
;
2970 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2971 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
2975 if (other
&& other
->status
!= Deleted
) {
2976 other
->group
= NULL
;
2980 list_delete_all_node(group
->peer
);
2982 group
->conf
->as
= 0;
2983 group
->conf
->as_type
= AS_UNSPECIFIED
;
2988 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2990 struct prefix
*prefix
;
2991 struct listnode
*node
, *nnode
;
2994 afi
= family2afi(range
->family
);
2996 /* Group needs remote AS configured. */
2997 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2998 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
3000 /* Ensure no duplicates. Currently we don't care about overlaps. */
3001 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
3002 if (prefix_same(range
, prefix
))
3006 prefix
= prefix_new();
3007 prefix_copy(prefix
, range
);
3008 listnode_add(group
->listen_range
[afi
], prefix
);
3010 /* Update passwords for new ranges */
3011 if (group
->conf
->password
)
3012 bgp_md5_set_prefix(group
->bgp
, prefix
, group
->conf
->password
);
3017 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
3019 struct prefix
*prefix
, prefix2
;
3020 struct listnode
*node
, *nnode
;
3024 afi
= family2afi(range
->family
);
3026 /* Identify the listen range. */
3027 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
3028 if (prefix_same(range
, prefix
))
3033 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
3035 /* Dispose off any dynamic neighbors that exist due to this listen range
3037 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
3038 if (!peer_dynamic_neighbor(peer
))
3041 if (sockunion2hostprefix(&peer
->su
, &prefix2
)
3042 && prefix_match(prefix
, &prefix2
)) {
3043 if (bgp_debug_neighbor_events(peer
))
3045 "Deleting dynamic neighbor %s group %s upon delete of listen range %pFX",
3046 peer
->host
, group
->name
, prefix
);
3051 /* Get rid of the listen range */
3052 listnode_delete(group
->listen_range
[afi
], prefix
);
3054 /* Remove passwords for deleted ranges */
3055 if (group
->conf
->password
)
3056 bgp_md5_unset_prefix(group
->bgp
, prefix
);
3061 /* Bind specified peer to peer group. */
3062 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
3063 struct peer_group
*group
, as_t
*as
)
3065 int first_member
= 0;
3068 enum bgp_peer_sort ptype
, gtype
;
3070 /* Lookup the peer. */
3072 peer
= peer_lookup(bgp
, su
);
3074 /* The peer exist, bind it to the peer-group */
3076 /* When the peer already belongs to a peer-group, check the
3078 if (peer_group_active(peer
)) {
3080 /* The peer is already bound to the peer-group,
3083 if (strcmp(peer
->group
->name
, group
->name
) == 0)
3086 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
3089 /* The peer has not specified a remote-as, inherit it from the
3091 if (peer
->as_type
== AS_UNSPECIFIED
) {
3092 peer
->as_type
= group
->conf
->as_type
;
3093 peer
->as
= group
->conf
->as
;
3094 peer
->sort
= group
->conf
->sort
;
3097 ptype
= peer_sort(peer
);
3098 if (!group
->conf
->as
&& ptype
!= BGP_PEER_UNSPECIFIED
) {
3099 gtype
= peer_sort(group
->conf
);
3100 if ((gtype
!= BGP_PEER_INTERNAL
) && (gtype
!= ptype
)) {
3103 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
3106 if (gtype
== BGP_PEER_INTERNAL
)
3110 peer_group2peer_config_copy(group
, peer
);
3112 FOREACH_AFI_SAFI (afi
, safi
) {
3113 if (group
->conf
->afc
[afi
][safi
]) {
3114 peer
->afc
[afi
][safi
] = 1;
3116 if (peer_af_find(peer
, afi
, safi
)
3117 || peer_af_create(peer
, afi
, safi
)) {
3118 peer_group2peer_config_copy_af(
3119 group
, peer
, afi
, safi
);
3121 } else if (peer
->afc
[afi
][safi
])
3122 peer_deactivate(peer
, afi
, safi
);
3126 assert(group
&& peer
->group
== group
);
3128 listnode_delete(bgp
->peer
, peer
);
3130 peer
->group
= group
;
3131 listnode_add_sort(bgp
->peer
, peer
);
3133 peer
= peer_lock(peer
); /* group->peer list reference */
3134 listnode_add(group
->peer
, peer
);
3138 gtype
= peer_sort(group
->conf
);
3139 /* Advertisement-interval reset */
3140 if (!CHECK_FLAG(group
->conf
->flags
,
3141 PEER_FLAG_ROUTEADV
)) {
3142 group
->conf
->v_routeadv
=
3143 (gtype
== BGP_PEER_IBGP
)
3144 ? BGP_DEFAULT_IBGP_ROUTEADV
3145 : BGP_DEFAULT_EBGP_ROUTEADV
;
3148 /* ebgp-multihop reset */
3149 if (gtype
== BGP_PEER_IBGP
)
3150 group
->conf
->ttl
= MAXTTL
;
3153 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3155 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3156 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
3157 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3158 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3160 bgp_session_reset(peer
);
3164 /* Create a new peer. */
3166 if ((group
->conf
->as_type
== AS_SPECIFIED
)
3167 && (!group
->conf
->as
)) {
3168 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
3171 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3172 group
->conf
->as_type
, group
, true, NULL
);
3174 peer
= peer_lock(peer
); /* group->peer list reference */
3175 listnode_add(group
->peer
, peer
);
3177 peer_group2peer_config_copy(group
, peer
);
3179 /* If the peer-group is active for this afi/safi then activate
3181 FOREACH_AFI_SAFI (afi
, safi
) {
3182 if (group
->conf
->afc
[afi
][safi
]) {
3183 peer
->afc
[afi
][safi
] = 1;
3185 if (!peer_af_find(peer
, afi
, safi
))
3186 peer_af_create(peer
, afi
, safi
);
3188 peer_group2peer_config_copy_af(group
, peer
, afi
,
3190 } else if (peer
->afc
[afi
][safi
])
3191 peer_deactivate(peer
, afi
, safi
);
3194 /* Set up peer's events and timers. */
3195 if (peer_active(peer
))
3196 bgp_timer_set(peer
);
3202 static void bgp_startup_timer_expire(struct event
*thread
)
3206 bgp
= EVENT_ARG(thread
);
3207 bgp
->t_startup
= NULL
;
3211 * On shutdown we call the cleanup function which
3212 * does a free of the link list nodes, free up
3213 * the data we are pointing at too.
3215 static void bgp_vrf_string_name_delete(void *data
)
3219 XFREE(MTYPE_TMP
, vname
);
3222 /* BGP instance creation by `router bgp' commands. */
3223 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
3224 enum bgp_instance_type inst_type
,
3225 const char *as_pretty
,
3226 enum asnotation_mode asnotation
)
3232 bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
));
3235 bgp
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_pretty
);
3237 bgp
->as_pretty
= XSTRDUP(MTYPE_BGP
, asn_asn2asplain(*as
));
3239 if (asnotation
!= ASNOTATION_UNDEFINED
) {
3240 bgp
->asnotation
= asnotation
;
3241 SET_FLAG(bgp
->config
, BGP_CONFIG_ASNOTATION
);
3243 asn_str2asn_notation(bgp
->as_pretty
, NULL
, &bgp
->asnotation
);
3245 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3246 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3247 zlog_debug("Creating Default VRF, AS %s",
3250 zlog_debug("Creating %s %s, AS %s",
3251 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
3254 name
, bgp
->as_pretty
);
3257 /* Default the EVPN VRF to the default one */
3258 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
&& !bgp_master
.bgp_evpn
) {
3265 bgp
->allow_martian
= false;
3266 bgp_process_queue_init(bgp
);
3267 bgp
->heuristic_coalesce
= true;
3268 bgp
->inst_type
= inst_type
;
3269 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
3271 bgp
->peer_self
= peer_new(bgp
);
3272 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
3273 bgp
->peer_self
->host
=
3274 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
3275 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
3276 if (cmd_hostname_get())
3277 bgp
->peer_self
->hostname
=
3278 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
3280 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
3281 if (cmd_domainname_get())
3282 bgp
->peer_self
->domainname
=
3283 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
3284 bgp
->peer
= list_new();
3285 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
3286 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
3288 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
3290 bgp
->group
= list_new();
3291 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
3293 FOREACH_AFI_SAFI (afi
, safi
) {
3294 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3295 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3296 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3298 /* Enable maximum-paths */
3299 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
3301 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
3303 /* Initialize graceful restart info */
3304 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
3305 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
3306 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
3307 bgp
->gr_info
[afi
][safi
].t_route_select
= NULL
;
3308 bgp
->gr_info
[afi
][safi
].gr_deferred
= 0;
3311 bgp
->v_update_delay
= bm
->v_update_delay
;
3312 bgp
->v_establish_wait
= bm
->v_establish_wait
;
3313 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
3314 bgp
->default_subgroup_pkt_queue_max
=
3315 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
3316 bgp_tcp_keepalive_unset(bgp
);
3317 bgp_timers_unset(bgp
);
3318 bgp
->default_min_holdtime
= 0;
3319 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
3320 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
3321 bgp
->select_defer_time
= BGP_DEFAULT_SELECT_DEFERRAL_TIME
;
3322 bgp
->rib_stale_time
= BGP_DEFAULT_RIB_STALE_TIME
;
3323 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
3324 bgp
->dynamic_neighbors_count
= 0;
3325 bgp
->lb_ref_bw
= BGP_LINK_BW_REF_BW
;
3326 bgp
->lb_handling
= BGP_LINK_BW_ECMP
;
3327 bgp
->reject_as_sets
= false;
3328 bgp
->condition_check_period
= DEFAULT_CONDITIONAL_ROUTES_POLL_TIME
;
3329 bgp_addpath_init_bgp_data(&bgp
->tx_addpath
);
3330 bgp
->fast_convergence
= false;
3331 bgp
->llgr_stale_time
= BGP_DEFAULT_LLGR_STALE_TIME
;
3333 #ifdef ENABLE_BGP_VNC
3334 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
3335 bgp
->rfapi
= bgp_rfapi_new(bgp
);
3337 assert(bgp
->rfapi_cfg
);
3339 #endif /* ENABLE_BGP_VNC */
3341 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3342 bgp
->vpn_policy
[afi
].bgp
= bgp
;
3343 bgp
->vpn_policy
[afi
].afi
= afi
;
3344 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
3345 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
3348 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
3349 bgp
->vpn_policy
[afi
].import_vrf
->del
=
3350 bgp_vrf_string_name_delete
;
3351 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
3352 bgp
->vpn_policy
[afi
].export_vrf
->del
=
3353 bgp_vrf_string_name_delete
;
3354 SET_FLAG(bgp
->af_flags
[afi
][SAFI_MPLS_VPN
],
3355 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL
);
3358 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
3360 event_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
3361 bgp
->restart_time
, &bgp
->t_startup
);
3363 /* printable name we can use in debug messages */
3364 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3365 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3375 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3377 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3378 snprintf(bgp
->name_pretty
, len
, "%s %s",
3379 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3385 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3386 memory_order_relaxed
);
3387 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3388 memory_order_relaxed
);
3389 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3390 bgp
->default_af
[AFI_IP
][SAFI_UNICAST
] = true;
3394 update_bgp_group_init(bgp
);
3396 /* assign a unique rd id for auto derivation of vrf's RD */
3397 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3399 bgp
->evpn_info
= XCALLOC(MTYPE_BGP_EVPN_INFO
,
3400 sizeof(struct bgp_evpn_info
));
3402 bgp_evpn_vrf_es_init(bgp
);
3406 /*initilize global GR FSM */
3407 bgp_global_gr_init(bgp
);
3409 memset(&bgp
->ebgprequirespolicywarning
, 0,
3410 sizeof(bgp
->ebgprequirespolicywarning
));
3415 /* Return the "default VRF" instance of BGP. */
3416 struct bgp
*bgp_get_default(void)
3419 struct listnode
*node
, *nnode
;
3421 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3422 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3427 /* Lookup BGP entry. */
3428 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3431 struct listnode
*node
, *nnode
;
3433 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3435 && ((bgp
->name
== NULL
&& name
== NULL
)
3436 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3441 /* Lookup BGP structure by view name. */
3442 struct bgp
*bgp_lookup_by_name(const char *name
)
3445 struct listnode
*node
, *nnode
;
3447 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3448 if ((bgp
->name
== NULL
&& name
== NULL
)
3449 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3454 /* Lookup BGP instance based on VRF id. */
3455 /* Note: Only to be used for incoming messages from Zebra. */
3456 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3460 /* Lookup VRF (in tree) and follow link. */
3461 vrf
= vrf_lookup_by_id(vrf_id
);
3464 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3467 /* Sets the BGP instance where EVPN is enabled */
3468 void bgp_set_evpn(struct bgp
*bgp
)
3470 if (bm
->bgp_evpn
== bgp
)
3473 /* First, release the reference count we hold on the instance */
3475 bgp_unlock(bm
->bgp_evpn
);
3479 /* Increase the reference count on this new VRF */
3481 bgp_lock(bm
->bgp_evpn
);
3484 /* Returns the BGP instance where EVPN is enabled, if any */
3485 struct bgp
*bgp_get_evpn(void)
3487 return bm
->bgp_evpn
;
3490 /* handle socket creation or deletion, if necessary
3491 * this is called for all new BGP instances
3493 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3496 struct listnode
*node
;
3499 /* Create BGP server socket, if listen mode not disabled */
3500 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3502 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3504 * suppress vrf socket
3507 bgp_close_vrf_socket(bgp
);
3511 return BGP_ERR_INVALID_VALUE
;
3513 * if vrf_id did not change
3515 if (vrf
->vrf_id
== old_vrf_id
)
3517 if (old_vrf_id
!= VRF_UNKNOWN
) {
3518 /* look for old socket. close it. */
3519 bgp_close_vrf_socket(bgp
);
3521 /* if backend is not yet identified ( VRF_UNKNOWN) then
3522 * creation will be done later
3524 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3526 if (list_isempty(bm
->addresses
)) {
3527 if (bgp_socket(bgp
, bm
->port
, NULL
) < 0)
3528 return BGP_ERR_INVALID_VALUE
;
3530 for (ALL_LIST_ELEMENTS_RO(bm
->addresses
, node
, address
))
3531 if (bgp_socket(bgp
, bm
->port
, address
) < 0)
3532 return BGP_ERR_INVALID_VALUE
;
3536 return bgp_check_main_socket(create
, bgp
);
3539 int bgp_lookup_by_as_name_type(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3540 enum bgp_instance_type inst_type
)
3544 /* Multiple instance check. */
3546 bgp
= bgp_lookup_by_name(name
);
3548 bgp
= bgp_get_default();
3552 if (bgp
->as
!= *as
) {
3554 return BGP_ERR_AS_MISMATCH
;
3556 if (bgp
->inst_type
!= inst_type
)
3557 return BGP_ERR_INSTANCE_MISMATCH
;
3565 /* Called from VTY commands. */
3566 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3567 enum bgp_instance_type inst_type
, const char *as_pretty
,
3568 enum asnotation_mode asnotation
)
3571 struct vrf
*vrf
= NULL
;
3574 ret
= bgp_lookup_by_as_name_type(bgp_val
, as
, name
, inst_type
);
3575 if (ret
|| *bgp_val
)
3578 bgp
= bgp_create(as
, name
, inst_type
, as_pretty
, asnotation
);
3581 * view instances will never work inside of a vrf
3582 * as such they must always be in the VRF_DEFAULT
3583 * Also we must set this to something useful because
3584 * of the vrf socket code needing an actual useful
3585 * default value to send to the underlying OS.
3587 * This code is currently ignoring vrf based
3588 * code using the -Z option( and that is probably
3589 * best addressed elsewhere in the code )
3591 if (inst_type
== BGP_INSTANCE_TYPE_VIEW
)
3592 bgp
->vrf_id
= VRF_DEFAULT
;
3594 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
, true);
3595 bgp_address_init(bgp
);
3596 bgp_tip_hash_init(bgp
);
3600 bgp
->t_rmap_def_originate_eval
= NULL
;
3602 /* If Default instance or VRF, link to the VRF structure, if present. */
3603 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3604 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3605 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3607 bgp_vrf_link(bgp
, vrf
);
3609 /* BGP server socket already processed if BGP instance
3610 * already part of the list
3612 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3613 listnode_add(bm
->bgp
, bgp
);
3615 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3616 if (BGP_DEBUG(zebra
, ZEBRA
))
3617 zlog_debug("%s: Registering BGP instance %s to zebra",
3618 __func__
, bgp
->name_pretty
);
3619 bgp_zebra_instance_register(bgp
);
3625 static void bgp_zclient_set_redist(afi_t afi
, int type
, unsigned short instance
,
3626 vrf_id_t vrf_id
, bool set
)
3630 redist_add_instance(&zclient
->mi_redist
[afi
][type
],
3633 redist_del_instance(&zclient
->mi_redist
[afi
][type
],
3637 vrf_bitmap_set(zclient
->redist
[afi
][type
], vrf_id
);
3639 vrf_bitmap_unset(zclient
->redist
[afi
][type
], vrf_id
);
3643 static void bgp_set_redist_vrf_bitmaps(struct bgp
*bgp
, bool set
)
3647 struct list
*red_list
;
3648 struct listnode
*node
;
3649 struct bgp_redist
*red
;
3651 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3652 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3654 red_list
= bgp
->redist
[afi
][i
];
3658 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
3659 bgp_zclient_set_redist(afi
, i
, red
->instance
,
3666 * Make BGP instance "up". Applies only to VRFs (non-default) and
3667 * implies the VRF has been learnt from Zebra.
3669 void bgp_instance_up(struct bgp
*bgp
)
3672 struct listnode
*node
, *next
;
3674 bgp_set_redist_vrf_bitmaps(bgp
, true);
3676 /* Register with zebra. */
3677 bgp_zebra_instance_register(bgp
);
3679 /* Kick off any peers that may have been configured. */
3680 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3681 if (!BGP_PEER_START_SUPPRESSED(peer
))
3682 BGP_EVENT_ADD(peer
, BGP_Start
);
3685 /* Process any networks that have been configured. */
3686 bgp_static_add(bgp
);
3690 * Make BGP instance "down". Applies only to VRFs (non-default) and
3691 * implies the VRF has been deleted by Zebra.
3693 void bgp_instance_down(struct bgp
*bgp
)
3696 struct listnode
*node
;
3697 struct listnode
*next
;
3700 if (bgp
->t_rmap_def_originate_eval
) {
3701 EVENT_OFF(bgp
->t_rmap_def_originate_eval
);
3702 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3706 /* Bring down peers, so corresponding routes are purged. */
3707 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3708 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3709 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3710 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3712 bgp_session_reset(peer
);
3715 /* Purge network and redistributed routes. */
3716 bgp_purge_static_redist_routes(bgp
);
3718 /* Cleanup registered nexthops (flags) */
3719 bgp_cleanup_nexthops(bgp
);
3721 bgp_zebra_instance_deregister(bgp
);
3723 bgp_set_redist_vrf_bitmaps(bgp
, false);
3726 /* Delete BGP instance. */
3727 int bgp_delete(struct bgp
*bgp
)
3730 struct peer_group
*group
;
3731 struct listnode
*node
, *next
;
3736 struct graceful_restart_info
*gr_info
;
3740 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, NULL
);
3742 /* make sure we withdraw any exported routes */
3743 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP
, bgp_get_default(),
3745 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP6
, bgp_get_default(),
3748 bgp_vpn_leak_unimport(bgp
);
3750 hook_call(bgp_inst_delete
, bgp
);
3752 FOREACH_AFI_SAFI (afi
, safi
)
3753 EVENT_OFF(bgp
->t_revalidate
[afi
][safi
]);
3755 EVENT_OFF(bgp
->t_condition_check
);
3756 EVENT_OFF(bgp
->t_startup
);
3757 EVENT_OFF(bgp
->t_maxmed_onstartup
);
3758 EVENT_OFF(bgp
->t_update_delay
);
3759 EVENT_OFF(bgp
->t_establish_wait
);
3761 /* Set flag indicating bgp instance delete in progress */
3762 SET_FLAG(bgp
->flags
, BGP_FLAG_DELETE_IN_PROGRESS
);
3764 /* Delete the graceful restart info */
3765 FOREACH_AFI_SAFI (afi
, safi
) {
3768 gr_info
= &bgp
->gr_info
[afi
][safi
];
3771 t
= gr_info
->t_select_deferral
;
3773 void *info
= EVENT_ARG(t
);
3775 XFREE(MTYPE_TMP
, info
);
3777 EVENT_OFF(gr_info
->t_select_deferral
);
3779 t
= gr_info
->t_route_select
;
3781 void *info
= EVENT_ARG(t
);
3783 XFREE(MTYPE_TMP
, info
);
3785 EVENT_OFF(gr_info
->t_route_select
);
3788 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3789 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3790 zlog_debug("Deleting Default VRF");
3792 zlog_debug("Deleting %s %s",
3793 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3799 /* unmap from RT list */
3800 bgp_evpn_vrf_delete(bgp
);
3802 /* unmap bgp vrf label */
3803 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP
);
3804 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP6
);
3807 if (bgp
->t_rmap_def_originate_eval
) {
3808 EVENT_OFF(bgp
->t_rmap_def_originate_eval
);
3809 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3813 /* Inform peers we're going down. */
3814 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3815 peer_notify_shutdown(peer
);
3817 /* Delete static routes (networks). */
3818 bgp_static_delete(bgp
);
3820 /* Unset redistribution. */
3821 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3822 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3823 if (i
!= ZEBRA_ROUTE_BGP
)
3824 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3826 /* Free peers and peer-groups. */
3827 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3828 peer_group_delete(group
);
3830 while (listcount(bgp
->peer
)) {
3831 peer
= listnode_head(bgp
->peer
);
3835 if (bgp
->peer_self
) {
3836 peer_delete(bgp
->peer_self
);
3837 bgp
->peer_self
= NULL
;
3840 update_bgp_group_free(bgp
);
3842 /* TODO - Other memory may need to be freed - e.g., NHT */
3844 #ifdef ENABLE_BGP_VNC
3848 /* Free memory allocated with aggregate address configuration. */
3849 FOREACH_AFI_SAFI (afi
, safi
) {
3850 struct bgp_aggregate
*aggregate
= NULL
;
3852 for (struct bgp_dest
*dest
=
3853 bgp_table_top(bgp
->aggregate
[afi
][safi
]);
3854 dest
; dest
= bgp_route_next(dest
)) {
3855 aggregate
= bgp_dest_get_bgp_aggregate_info(dest
);
3856 if (aggregate
== NULL
)
3859 bgp_dest_set_bgp_aggregate_info(dest
, NULL
);
3860 bgp_free_aggregate_info(aggregate
);
3864 bgp_cleanup_routes(bgp
);
3866 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3867 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3870 &bgp
->vpn_policy
[afi
]
3871 .import_redirect_rtlist
);
3872 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3875 /* Free any memory allocated to holding routemap references */
3876 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3877 for (enum vpn_policy_direction dir
= 0;
3878 dir
< BGP_VPN_POLICY_DIR_MAX
; ++dir
) {
3879 if (bgp
->vpn_policy
[afi
].rmap_name
[dir
])
3880 XFREE(MTYPE_ROUTE_MAP_NAME
,
3881 bgp
->vpn_policy
[afi
].rmap_name
[dir
]);
3882 bgp
->vpn_policy
[afi
].rmap
[dir
] = NULL
;
3886 /* Deregister from Zebra, if needed */
3887 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3888 if (BGP_DEBUG(zebra
, ZEBRA
))
3890 "%s: deregistering this bgp %s instance from zebra",
3891 __func__
, bgp
->name
);
3892 bgp_zebra_instance_deregister(bgp
);
3895 /* Remove visibility via the master list - there may however still be
3896 * routes to be processed still referencing the struct bgp.
3898 listnode_delete(bm
->bgp
, bgp
);
3900 /* Free interfaces in this instance. */
3903 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3904 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3906 bgp_vrf_unlink(bgp
, vrf
);
3908 /* Update EVPN VRF pointer */
3909 if (bm
->bgp_evpn
== bgp
) {
3910 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3913 bgp_set_evpn(bgp_get_default());
3916 if (bgp
->process_queue
)
3917 work_queue_free_and_null(&bgp
->process_queue
);
3919 event_master_free_unused(bm
->master
);
3920 bgp_unlock(bgp
); /* initial reference */
3925 void bgp_free(struct bgp
*bgp
)
3929 struct bgp_table
*table
;
3930 struct bgp_dest
*dest
;
3931 struct bgp_rmap
*rmap
;
3935 list_delete(&bgp
->group
);
3936 list_delete(&bgp
->peer
);
3938 if (bgp
->peerhash
) {
3939 hash_free(bgp
->peerhash
);
3940 bgp
->peerhash
= NULL
;
3943 FOREACH_AFI_SAFI (afi
, safi
) {
3944 /* Special handling for 2-level routing tables. */
3945 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3946 || safi
== SAFI_EVPN
) {
3947 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
3948 dest
= bgp_route_next(dest
)) {
3949 table
= bgp_dest_get_bgp_table_info(dest
);
3950 bgp_table_finish(&table
);
3953 if (bgp
->route
[afi
][safi
])
3954 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3955 if (bgp
->aggregate
[afi
][safi
])
3956 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3957 if (bgp
->rib
[afi
][safi
])
3958 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3959 rmap
= &bgp
->table_map
[afi
][safi
];
3960 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3963 bgp_scan_finish(bgp
);
3964 bgp_address_destroy(bgp
);
3965 bgp_tip_hash_destroy(bgp
);
3967 /* release the auto RD id */
3968 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3970 bgp_evpn_cleanup(bgp
);
3971 bgp_pbr_cleanup(bgp
);
3972 bgp_srv6_cleanup(bgp
);
3973 XFREE(MTYPE_BGP_EVPN_INFO
, bgp
->evpn_info
);
3975 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3976 enum vpn_policy_direction dir
;
3978 if (bgp
->vpn_policy
[afi
].import_vrf
)
3979 list_delete(&bgp
->vpn_policy
[afi
].import_vrf
);
3980 if (bgp
->vpn_policy
[afi
].export_vrf
)
3981 list_delete(&bgp
->vpn_policy
[afi
].export_vrf
);
3983 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3984 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3985 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3986 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3987 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3988 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3989 if (bgp
->vpn_policy
[afi
].tovpn_rd_pretty
)
3990 XFREE(MTYPE_BGP
, bgp
->vpn_policy
[afi
].tovpn_rd_pretty
);
3993 bgp_confederation_id_unset(bgp
);
3995 XFREE(MTYPE_BGP
, bgp
->as_pretty
);
3996 XFREE(MTYPE_BGP
, bgp
->name
);
3997 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3998 XFREE(MTYPE_BGP
, bgp
->snmp_stats
);
4000 XFREE(MTYPE_BGP
, bgp
);
4003 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
4006 struct listnode
*node
, *nnode
;
4012 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4013 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
4014 && !CHECK_FLAG(peer
->sflags
,
4015 PEER_STATUS_ACCEPT_PEER
))
4017 } else if (bm
->bgp
!= NULL
) {
4018 struct listnode
*bgpnode
, *nbgpnode
;
4020 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4021 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4023 && !strcmp(peer
->conf_if
, conf_if
)
4024 && !CHECK_FLAG(peer
->sflags
,
4025 PEER_STATUS_ACCEPT_PEER
))
4031 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
4034 struct listnode
*node
, *nnode
;
4040 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4041 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
4042 && !CHECK_FLAG(peer
->sflags
,
4043 PEER_STATUS_ACCEPT_PEER
))
4045 } else if (bm
->bgp
!= NULL
) {
4046 struct listnode
*bgpnode
, *nbgpnode
;
4048 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4049 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4051 && !strcmp(peer
->hostname
, hostname
)
4052 && !CHECK_FLAG(peer
->sflags
,
4053 PEER_STATUS_ACCEPT_PEER
))
4059 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
4061 struct peer
*peer
= NULL
;
4062 struct peer tmp_peer
;
4064 memset(&tmp_peer
, 0, sizeof(struct peer
));
4067 * We do not want to find the doppelganger peer so search for the peer
4069 * the hash that has PEER_FLAG_CONFIG_NODE
4071 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
4076 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4077 } else if (bm
->bgp
!= NULL
) {
4078 struct listnode
*bgpnode
, *nbgpnode
;
4080 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
4081 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4090 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
4091 union sockunion
*su
,
4092 struct peer_group
*group
)
4098 /* Create peer first; we've already checked group config is valid. */
4099 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
4100 group
->conf
->as_type
, group
, true, NULL
);
4105 peer
= peer_lock(peer
);
4106 listnode_add(group
->peer
, peer
);
4108 peer_group2peer_config_copy(group
, peer
);
4111 * Bind peer for all AFs configured for the group. We don't call
4112 * peer_group_bind as that is sub-optimal and does some stuff we don't
4115 FOREACH_AFI_SAFI (afi
, safi
) {
4116 if (!group
->conf
->afc
[afi
][safi
])
4118 peer
->afc
[afi
][safi
] = 1;
4120 if (!peer_af_find(peer
, afi
, safi
))
4121 peer_af_create(peer
, afi
, safi
);
4123 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
4126 /* Mark as dynamic, but also as a "config node" for other things to
4128 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
4134 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
4135 struct prefix
*prefix
)
4137 struct listnode
*node
, *nnode
;
4138 struct prefix
*range
;
4141 afi
= family2afi(prefix
->family
);
4143 if (group
->listen_range
[afi
])
4144 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
4146 if (prefix_match(range
, prefix
))
4153 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
4154 struct prefix
**listen_range
)
4156 struct prefix
*range
= NULL
;
4157 struct peer_group
*group
= NULL
;
4158 struct listnode
*node
, *nnode
;
4160 *listen_range
= NULL
;
4162 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4163 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4166 } else if (bm
->bgp
!= NULL
) {
4167 struct listnode
*bgpnode
, *nbgpnode
;
4169 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4170 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4171 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4177 *listen_range
= range
;
4178 return (group
&& range
) ? group
: NULL
;
4181 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
4183 struct peer_group
*group
;
4186 struct prefix prefix
;
4187 struct prefix
*listen_range
;
4190 if (!sockunion2hostprefix(su
, &prefix
))
4193 /* See if incoming connection matches a configured listen range. */
4194 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
4205 if (bgp_debug_neighbor_events(NULL
))
4207 "Dynamic Neighbor %pFX matches group %s listen range %pFX",
4208 &prefix
, group
->name
, listen_range
);
4210 /* Are we within the listen limit? */
4211 dncount
= gbgp
->dynamic_neighbors_count
;
4213 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
4214 if (bgp_debug_neighbor_events(NULL
))
4216 "Dynamic Neighbor %pFX rejected - at limit %d",
4217 &prefix
, gbgp
->dynamic_neighbors_limit
);
4221 /* Ensure group is not disabled. */
4222 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
4223 if (bgp_debug_neighbor_events(NULL
))
4225 "Dynamic Neighbor %pFX rejected - group %s disabled",
4226 &prefix
, group
->name
);
4230 /* Check that at least one AF is activated for the group. */
4231 if (!peer_group_af_configured(group
)) {
4232 if (bgp_debug_neighbor_events(NULL
))
4234 "Dynamic Neighbor %pFX rejected - no AF activated for group %s",
4235 &prefix
, group
->name
);
4239 /* Create dynamic peer and bind to associated group. */
4240 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
4243 gbgp
->dynamic_neighbors_count
= ++dncount
;
4245 if (bgp_debug_neighbor_events(peer
))
4246 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
4247 peer
->host
, group
->name
, dncount
);
4252 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
4255 if (peer
->group
->bgp
) {
4256 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
4258 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
4260 if (bgp_debug_neighbor_events(peer
))
4261 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
4262 peer
->group
->name
, dncount
);
4265 bool bgp_path_attribute_discard(struct peer
*peer
, char *buf
, size_t size
)
4272 for (unsigned int i
= 0; i
< BGP_ATTR_MAX
; i
++) {
4273 if (peer
->discard_attrs
[i
])
4274 snprintf(buf
+ strlen(buf
), size
- strlen(buf
), "%s%d",
4275 (strlen(buf
) > 0) ? " " : "", i
);
4278 if (strlen(buf
) > 0)
4284 bool bgp_path_attribute_treat_as_withdraw(struct peer
*peer
, char *buf
,
4292 for (unsigned int i
= 0; i
< BGP_ATTR_MAX
; i
++) {
4293 if (peer
->withdraw_attrs
[i
])
4294 snprintf(buf
+ strlen(buf
), size
- strlen(buf
), "%s%d",
4295 (strlen(buf
) > 0) ? " " : "", i
);
4298 if (strlen(buf
) > 0)
4304 /* If peer is configured at least one address family return 1. */
4305 bool peer_active(struct peer
*peer
)
4307 if (BGP_PEER_SU_UNSPEC(peer
))
4309 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
4310 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
4311 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
4312 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
4313 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
4314 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
4315 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4316 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
4317 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
4318 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
4319 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
4324 /* If peer is negotiated at least one address family return 1. */
4325 bool peer_active_nego(struct peer
*peer
)
4327 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
4328 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
4329 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
4330 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
4331 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
4332 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
4333 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
4334 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
4335 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4336 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
4337 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
4338 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
4339 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
4344 /* If peer received at least one address family MP, return true */
4345 bool peer_afc_received(struct peer
*peer
)
4350 FOREACH_AFI_SAFI (afi
, safi
)
4351 if (peer
->afc_recv
[afi
][safi
])
4357 /* If peer advertised at least one address family MP, return true */
4358 bool peer_afc_advertised(struct peer
*peer
)
4363 FOREACH_AFI_SAFI (afi
, safi
)
4364 if (peer
->afc_adv
[afi
][safi
])
4370 void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
4371 enum peer_change_type type
)
4373 struct peer_af
*paf
;
4375 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4378 if (!peer_established(peer
))
4381 if (type
== peer_change_reset
) {
4382 /* If we're resetting session, we've to delete both peer struct
4384 if ((peer
->doppelganger
)
4385 && (peer
->doppelganger
->status
!= Deleted
)
4386 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4387 PEER_FLAG_CONFIG_NODE
)))
4388 peer_delete(peer
->doppelganger
);
4390 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4391 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4392 } else if (type
== peer_change_reset_in
) {
4393 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4394 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4395 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0,
4396 BGP_ROUTE_REFRESH_NORMAL
);
4398 if ((peer
->doppelganger
)
4399 && (peer
->doppelganger
->status
!= Deleted
)
4400 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4401 PEER_FLAG_CONFIG_NODE
)))
4402 peer_delete(peer
->doppelganger
);
4404 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4405 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4407 } else if (type
== peer_change_reset_out
) {
4408 paf
= peer_af_find(peer
, afi
, safi
);
4409 if (paf
&& paf
->subgroup
)
4410 SET_FLAG(paf
->subgroup
->sflags
,
4411 SUBGRP_STATUS_FORCE_UPDATES
);
4413 update_group_adjust_peer(paf
);
4414 bgp_announce_route(peer
, afi
, safi
, false);
4418 struct peer_flag_action
{
4422 /* This flag can be set for peer-group member. */
4423 uint8_t not_for_member
;
4425 /* Action when the flag is changed. */
4426 enum peer_change_type type
;
4429 static const struct peer_flag_action peer_flag_action_list
[] = {
4430 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
4431 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
4432 {PEER_FLAG_RTT_SHUTDOWN
, 0, peer_change_none
},
4433 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
4434 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
4435 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
4436 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
4437 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
4438 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
4439 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
4440 {PEER_FLAG_IFPEER_V6ONLY
, 0, peer_change_reset
},
4441 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
4442 {PEER_FLAG_TIMER
, 0, peer_change_none
},
4443 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
4444 {PEER_FLAG_TIMER_DELAYOPEN
, 0, peer_change_none
},
4445 {PEER_FLAG_PASSWORD
, 0, peer_change_none
},
4446 {PEER_FLAG_LOCAL_AS
, 0, peer_change_reset
},
4447 {PEER_FLAG_LOCAL_AS_NO_PREPEND
, 0, peer_change_reset
},
4448 {PEER_FLAG_LOCAL_AS_REPLACE_AS
, 0, peer_change_reset
},
4449 {PEER_FLAG_UPDATE_SOURCE
, 0, peer_change_none
},
4450 {PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
, 0, peer_change_none
},
4451 {PEER_FLAG_EXTENDED_OPT_PARAMS
, 0, peer_change_reset
},
4452 {PEER_FLAG_ROLE_STRICT_MODE
, 0, peer_change_reset
},
4453 {PEER_FLAG_ROLE
, 0, peer_change_reset
},
4454 {PEER_FLAG_PORT
, 0, peer_change_reset
},
4455 {PEER_FLAG_AIGP
, 0, peer_change_none
},
4456 {PEER_FLAG_GRACEFUL_SHUTDOWN
, 0, peer_change_none
},
4457 {PEER_FLAG_CAPABILITY_SOFT_VERSION
, 0, peer_change_reset
},
4460 static const struct peer_flag_action peer_af_flag_action_list
[] = {
4461 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
4462 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
4463 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
4464 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4465 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
4466 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
4467 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
4468 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
4469 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
4470 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
4471 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
4472 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
4473 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
4474 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
4475 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
4476 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
4477 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
4478 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
4479 {PEER_FLAG_MAX_PREFIX_FORCE
, 0, peer_change_none
},
4480 {PEER_FLAG_MAX_PREFIX_OUT
, 0, peer_change_none
},
4481 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
4482 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4483 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
4484 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
4485 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
4486 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
4487 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
4488 {PEER_FLAG_DISABLE_ADDPATH_RX
, 0, peer_change_reset
},
4489 {PEER_FLAG_SOO
, 0, peer_change_reset
},
4490 {PEER_FLAG_ACCEPT_OWN
, 0, peer_change_reset
},
4493 /* Proper action set. */
4494 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
4495 int size
, struct peer_flag_action
*action
,
4502 const struct peer_flag_action
*match
= NULL
;
4504 /* Check peer's frag action. */
4505 for (i
= 0; i
< size
; i
++) {
4506 match
= &action_list
[i
];
4508 if (match
->flag
== 0)
4511 if (match
->flag
& flag
) {
4514 if (match
->type
== peer_change_reset_in
)
4516 if (match
->type
== peer_change_reset_out
)
4518 if (match
->type
== peer_change_reset
) {
4522 if (match
->not_for_member
)
4523 action
->not_for_member
= 1;
4527 /* Set peer clear type. */
4528 if (reset_in
&& reset_out
)
4529 action
->type
= peer_change_reset
;
4531 action
->type
= peer_change_reset_in
;
4533 action
->type
= peer_change_reset_out
;
4535 action
->type
= peer_change_none
;
4540 static void peer_flag_modify_action(struct peer
*peer
, uint64_t flag
)
4542 if (flag
== PEER_FLAG_SHUTDOWN
) {
4543 if (CHECK_FLAG(peer
->flags
, flag
)) {
4544 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
4545 peer_nsf_stop(peer
);
4547 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
4549 if (peer
->t_pmax_restart
) {
4550 EVENT_OFF(peer
->t_pmax_restart
);
4551 if (bgp_debug_neighbor_events(peer
))
4553 "%pBP Maximum-prefix restart timer canceled",
4557 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4558 char *msg
= peer
->tx_shutdown_message
;
4560 uint8_t msgbuf
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4562 if (!msg
&& peer_group_active(peer
))
4563 msg
= peer
->group
->conf
4564 ->tx_shutdown_message
;
4565 msglen
= msg
? strlen(msg
) : 0;
4566 if (msglen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4567 msglen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4571 memcpy(msgbuf
+ 1, msg
, msglen
);
4573 bgp_notify_send_with_data(
4574 peer
, BGP_NOTIFY_CEASE
,
4575 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
4576 msgbuf
, msglen
+ 1);
4579 peer
, BGP_NOTIFY_CEASE
,
4580 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4582 bgp_session_reset(peer
);
4584 peer
->v_start
= BGP_INIT_START_TIMER
;
4585 BGP_EVENT_ADD(peer
, BGP_Stop
);
4587 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4588 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
4589 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4590 else if (flag
== PEER_FLAG_PASSIVE
)
4591 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
4592 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
4593 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
4595 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4596 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4598 bgp_session_reset(peer
);
4601 /* Enable global administrative shutdown of all peers of BGP instance */
4602 void bgp_shutdown_enable(struct bgp
*bgp
, const char *msg
)
4605 struct listnode
*node
;
4606 /* length(1) + message(N) */
4607 uint8_t data
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4609 /* do nothing if already shut down */
4610 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4613 /* informational log message */
4614 zlog_info("Enabled administrative shutdown on BGP instance AS %u",
4617 /* iterate through peers of BGP instance */
4618 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
4619 /* continue, if peer is already in administrative shutdown. */
4620 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
))
4623 /* send a RFC 4486 notification message if necessary */
4624 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4626 size_t datalen
= strlen(msg
);
4628 if (datalen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4629 datalen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4632 memcpy(data
+ 1, msg
, datalen
);
4634 bgp_notify_send_with_data(
4635 peer
, BGP_NOTIFY_CEASE
,
4636 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
, data
,
4640 peer
, BGP_NOTIFY_CEASE
,
4641 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4645 /* reset start timer to initial value */
4646 peer
->v_start
= BGP_INIT_START_TIMER
;
4648 /* trigger a RFC 4271 ManualStop event */
4649 BGP_EVENT_ADD(peer
, BGP_Stop
);
4652 /* set the BGP instances shutdown flag */
4653 SET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4656 /* Disable global administrative shutdown of all peers of BGP instance */
4657 void bgp_shutdown_disable(struct bgp
*bgp
)
4659 const struct listnode
*node
;
4662 /* do nothing if not shut down. */
4663 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4666 /* informational log message */
4667 zlog_info("Disabled administrative shutdown on BGP instance AS %u",
4670 /* clear the BGP instances shutdown flag */
4671 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4673 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
))
4674 bgp_timer_set(peer
);
4677 /* Change specified peer flag. */
4678 static int peer_flag_modify(struct peer
*peer
, uint64_t flag
, int set
)
4682 bool invert
, member_invert
;
4683 struct peer
*member
;
4684 struct listnode
*node
, *nnode
;
4685 struct peer_flag_action action
;
4687 memset(&action
, 0, sizeof(struct peer_flag_action
));
4688 size
= sizeof(peer_flag_action_list
) / sizeof(struct peer_flag_action
);
4690 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4691 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4694 /* Abort if no flag action exists. */
4696 return BGP_ERR_INVALID_FLAG
;
4698 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4699 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4700 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4701 return BGP_ERR_PEER_FLAG_CONFLICT
;
4703 /* Handle flag updates where desired state matches current state. */
4704 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4705 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4706 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4710 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4711 COND_FLAG(peer
->flags_override
, flag
, invert
);
4716 /* Inherit from peer-group or set/unset flags accordingly. */
4717 if (peer_group_active(peer
) && set
== invert
)
4718 peer_flag_inherit(peer
, flag
);
4720 COND_FLAG(peer
->flags
, flag
, set
);
4722 /* Check if handling a regular peer. */
4723 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4724 /* Update flag override state accordingly. */
4725 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4728 * For the extended next-hop encoding flag we need to turn RAs
4729 * on if flag is being set, but only turn RAs off if the flag
4730 * is being unset on this peer and if this peer is a member of a
4731 * peer-group, the peer-group also doesn't have the flag set.
4733 if (flag
== PEER_FLAG_CAPABILITY_ENHE
) {
4735 bgp_zebra_initiate_radv(peer
->bgp
, peer
);
4736 } else if (peer_group_active(peer
)) {
4737 if (!CHECK_FLAG(peer
->group
->conf
->flags
,
4740 bgp_zebra_terminate_radv(peer
->bgp
,
4743 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
4746 /* Execute flag action on peer. */
4747 if (action
.type
== peer_change_reset
)
4748 peer_flag_modify_action(peer
, flag
);
4750 /* Skip peer-group mechanics for regular peers. */
4755 * Update peer-group members, unless they are explicitly overriding
4756 * peer-group configuration.
4758 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4759 /* Skip peers with overridden configuration. */
4760 if (CHECK_FLAG(member
->flags_override
, flag
))
4763 /* Check if only member without group is inverted. */
4765 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4767 /* Skip peers with equivalent configuration. */
4768 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4771 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4774 /* Update flag on peer-group member. */
4775 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4777 if (flag
== PEER_FLAG_CAPABILITY_ENHE
&& !member
->conf_if
)
4778 set
? bgp_zebra_initiate_radv(member
->bgp
, member
)
4779 : bgp_zebra_terminate_radv(member
->bgp
, member
);
4781 /* Execute flag action on peer-group member. */
4782 if (action
.type
== peer_change_reset
)
4783 peer_flag_modify_action(member
, flag
);
4789 int peer_flag_set(struct peer
*peer
, uint64_t flag
)
4791 return peer_flag_modify(peer
, flag
, 1);
4794 int peer_flag_unset(struct peer
*peer
, uint64_t flag
)
4796 return peer_flag_modify(peer
, flag
, 0);
4799 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4800 uint64_t flag
, bool set
)
4804 bool invert
, member_invert
;
4805 struct peer
*member
;
4806 struct listnode
*node
, *nnode
;
4807 struct peer_flag_action action
;
4808 enum bgp_peer_sort ptype
;
4810 memset(&action
, 0, sizeof(struct peer_flag_action
));
4811 size
= sizeof(peer_af_flag_action_list
)
4812 / sizeof(struct peer_flag_action
);
4814 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4815 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4818 /* Abort if flag action exists. */
4820 return BGP_ERR_INVALID_FLAG
;
4822 ptype
= peer_sort(peer
);
4823 /* Special check for reflector client. */
4824 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
&& ptype
!= BGP_PEER_IBGP
)
4825 return BGP_ERR_NOT_INTERNAL_PEER
;
4827 /* Special check for remove-private-AS. */
4828 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
&& ptype
== BGP_PEER_IBGP
)
4829 return BGP_ERR_REMOVE_PRIVATE_AS
;
4831 /* as-override is not allowed for IBGP peers */
4832 if (flag
& PEER_FLAG_AS_OVERRIDE
&& ptype
== BGP_PEER_IBGP
)
4833 return BGP_ERR_AS_OVERRIDE
;
4835 /* Handle flag updates where desired state matches current state. */
4836 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4837 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4838 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4843 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4844 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4851 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4852 * if we are setting/unsetting flags which conflict with this flag
4853 * handle accordingly
4855 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4859 * if we are setting NEXTHOP_SELF, we need to unset the
4860 * NEXTHOP_UNCHANGED flag
4862 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4863 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4864 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4865 PEER_FLAG_NEXTHOP_UNCHANGED
);
4869 * if we are unsetting NEXTHOP_SELF, we need to set the
4870 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4872 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4873 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4874 SET_FLAG(peer
->af_flags
[afi
][safi
],
4875 PEER_FLAG_NEXTHOP_UNCHANGED
);
4880 * If the peer is a route server client let's not
4881 * muck with the nexthop on the way out the door
4883 if (flag
& PEER_FLAG_RSERVER_CLIENT
) {
4885 SET_FLAG(peer
->af_flags
[afi
][safi
],
4886 PEER_FLAG_NEXTHOP_UNCHANGED
);
4888 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4889 PEER_FLAG_NEXTHOP_UNCHANGED
);
4892 /* Inherit from peer-group or set/unset flags accordingly. */
4893 if (peer_group_active(peer
) && set
== invert
)
4894 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4896 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4898 /* Execute action when peer is established. */
4899 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4900 && peer_established(peer
)) {
4901 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4902 bgp_clear_adj_in(peer
, afi
, safi
);
4904 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4905 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4906 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4907 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4908 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4909 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4910 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4911 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4913 peer_change_action(peer
, afi
, safi
, action
.type
);
4917 /* Check if handling a regular peer. */
4918 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4919 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4923 * Update peer-group members, unless they are explicitly
4924 * overriding peer-group configuration.
4926 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4928 /* Skip peers with overridden configuration. */
4929 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4933 /* Check if only member without group is inverted. */
4935 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4939 /* Skip peers with equivalent configuration. */
4940 if (set
!= member_invert
4941 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4944 if (set
== member_invert
4945 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4948 /* Update flag on peer-group member. */
4949 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4950 set
!= member_invert
);
4952 /* Execute flag action on peer-group member. */
4953 if (peer_established(member
)) {
4954 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4955 bgp_clear_adj_in(member
, afi
, safi
);
4957 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4958 member
->last_reset
=
4959 PEER_DOWN_RR_CLIENT_CHANGE
;
4961 == PEER_FLAG_RSERVER_CLIENT
)
4962 member
->last_reset
=
4963 PEER_DOWN_RS_CLIENT_CHANGE
;
4965 == PEER_FLAG_ORF_PREFIX_SM
)
4966 member
->last_reset
=
4967 PEER_DOWN_CAPABILITY_CHANGE
;
4969 == PEER_FLAG_ORF_PREFIX_RM
)
4970 member
->last_reset
=
4971 PEER_DOWN_CAPABILITY_CHANGE
;
4973 peer_change_action(member
, afi
, safi
,
4983 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4985 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4988 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4990 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4994 void peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4996 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4997 peer
->tx_shutdown_message
=
4998 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
5001 void peer_tx_shutdown_message_unset(struct peer
*peer
)
5003 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
5007 /* EBGP multihop configuration. */
5008 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
5010 struct peer_group
*group
;
5011 struct listnode
*node
, *nnode
;
5014 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
5017 /* is there anything to do? */
5018 if (peer
->ttl
== ttl
)
5021 /* see comment in peer_ttl_security_hops_set() */
5022 if (ttl
!= MAXTTL
) {
5023 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5024 group
= peer
->group
;
5025 if (group
->conf
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5026 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5028 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
5030 if (peer1
->sort
== BGP_PEER_IBGP
)
5033 if (peer1
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5034 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5037 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5038 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5044 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5045 if (peer
->sort
!= BGP_PEER_IBGP
) {
5046 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5047 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5048 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5050 bgp_session_reset(peer
);
5052 /* Reconfigure BFD peer with new TTL. */
5053 if (peer
->bfd_config
)
5054 bgp_peer_bfd_update_source(peer
);
5057 group
= peer
->group
;
5058 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5059 if (peer
->sort
== BGP_PEER_IBGP
)
5062 peer
->ttl
= group
->conf
->ttl
;
5064 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5065 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5066 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5068 bgp_session_reset(peer
);
5070 /* Reconfigure BFD peer with new TTL. */
5071 if (peer
->bfd_config
)
5072 bgp_peer_bfd_update_source(peer
);
5078 int peer_ebgp_multihop_unset(struct peer
*peer
)
5080 struct peer_group
*group
;
5081 struct listnode
*node
, *nnode
;
5084 if (peer
->sort
== BGP_PEER_IBGP
)
5087 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
&& peer
->ttl
!= MAXTTL
)
5088 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5090 if (peer_group_active(peer
))
5091 ttl
= peer
->group
->conf
->ttl
;
5093 ttl
= BGP_DEFAULT_TTL
;
5095 if (ttl
== peer
->ttl
)
5100 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5101 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5102 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5103 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5105 bgp_session_reset(peer
);
5107 /* Reconfigure BFD peer with new TTL. */
5108 if (peer
->bfd_config
)
5109 bgp_peer_bfd_update_source(peer
);
5111 group
= peer
->group
;
5112 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5113 if (peer
->sort
== BGP_PEER_IBGP
)
5116 peer
->ttl
= BGP_DEFAULT_TTL
;
5118 if (peer
->fd
>= 0) {
5119 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5121 peer
, BGP_NOTIFY_CEASE
,
5122 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5124 bgp_session_reset(peer
);
5127 /* Reconfigure BFD peer with new TTL. */
5128 if (peer
->bfd_config
)
5129 bgp_peer_bfd_update_source(peer
);
5135 /* Set Open Policy Role and check its correctness */
5136 int peer_role_set(struct peer
*peer
, uint8_t role
, bool strict_mode
)
5138 struct peer
*member
;
5139 struct listnode
*node
, *nnode
;
5141 peer_flag_set(peer
, PEER_FLAG_ROLE
);
5143 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5144 if (peer
->sort
!= BGP_PEER_EBGP
)
5145 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5147 if (peer
->local_role
== role
) {
5148 if (CHECK_FLAG(peer
->flags
,
5149 PEER_FLAG_ROLE_STRICT_MODE
) &&
5151 /* TODO: Is session restart needed if it was
5154 UNSET_FLAG(peer
->flags
,
5155 PEER_FLAG_ROLE_STRICT_MODE
);
5156 if (!CHECK_FLAG(peer
->flags
,
5157 PEER_FLAG_ROLE_STRICT_MODE
) &&
5159 SET_FLAG(peer
->flags
,
5160 PEER_FLAG_ROLE_STRICT_MODE
);
5161 /* Restart session to throw Role Mismatch
5164 if (peer
->remote_role
== ROLE_UNDEFINED
)
5165 bgp_session_reset(peer
);
5168 peer
->local_role
= role
;
5170 SET_FLAG(peer
->flags
,
5171 PEER_FLAG_ROLE_STRICT_MODE
);
5173 UNSET_FLAG(peer
->flags
,
5174 PEER_FLAG_ROLE_STRICT_MODE
);
5175 bgp_session_reset(peer
);
5181 peer
->local_role
= role
;
5182 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5183 if (member
->sort
!= BGP_PEER_EBGP
)
5184 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5186 if (member
->local_role
== role
) {
5187 if (CHECK_FLAG(member
->flags
,
5188 PEER_FLAG_ROLE_STRICT_MODE
) &&
5190 /* TODO: Is session restart needed if it was
5193 UNSET_FLAG(member
->flags
,
5194 PEER_FLAG_ROLE_STRICT_MODE
);
5195 if (!CHECK_FLAG(member
->flags
,
5196 PEER_FLAG_ROLE_STRICT_MODE
) &&
5198 SET_FLAG(peer
->flags
,
5199 PEER_FLAG_ROLE_STRICT_MODE
);
5200 SET_FLAG(member
->flags
,
5201 PEER_FLAG_ROLE_STRICT_MODE
);
5202 /* Restart session to throw Role Mismatch
5205 if (member
->remote_role
== ROLE_UNDEFINED
)
5206 bgp_session_reset(member
);
5209 member
->local_role
= role
;
5212 SET_FLAG(peer
->flags
,
5213 PEER_FLAG_ROLE_STRICT_MODE
);
5214 SET_FLAG(member
->flags
,
5215 PEER_FLAG_ROLE_STRICT_MODE
);
5217 UNSET_FLAG(member
->flags
,
5218 PEER_FLAG_ROLE_STRICT_MODE
);
5220 bgp_session_reset(member
);
5227 int peer_role_unset(struct peer
*peer
)
5229 struct peer
*member
;
5230 struct listnode
*node
, *nnode
;
5232 peer_flag_unset(peer
, PEER_FLAG_ROLE
);
5234 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5235 return peer_role_set(peer
, ROLE_UNDEFINED
, 0);
5237 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
))
5238 peer_role_set(member
, ROLE_UNDEFINED
, 0);
5243 /* Neighbor description. */
5244 void peer_description_set(struct peer
*peer
, const char *desc
)
5246 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5248 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
5251 void peer_description_unset(struct peer
*peer
)
5253 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5256 /* Neighbor update-source. */
5257 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
5259 struct peer
*member
;
5260 struct listnode
*node
, *nnode
;
5262 /* Set flag and configuration on peer. */
5263 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5264 if (peer
->update_if
) {
5265 if (strcmp(peer
->update_if
, ifname
) == 0)
5267 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5269 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5270 sockunion_free(peer
->update_source
);
5271 peer
->update_source
= NULL
;
5273 /* Check if handling a regular peer. */
5274 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5275 /* Send notification or reset peer depending on state. */
5276 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5277 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5278 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5279 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5281 bgp_session_reset(peer
);
5283 /* Apply new source configuration to BFD session. */
5284 if (peer
->bfd_config
)
5285 bgp_peer_bfd_update_source(peer
);
5287 /* Skip peer-group mechanics for regular peers. */
5292 * Set flag and configuration on all peer-group members, unless they are
5293 * explicitly overriding peer-group configuration.
5295 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5296 /* Skip peers with overridden configuration. */
5297 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5300 /* Skip peers with the same configuration. */
5301 if (member
->update_if
) {
5302 if (strcmp(member
->update_if
, ifname
) == 0)
5304 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5307 /* Set flag and configuration on peer-group member. */
5308 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5309 member
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5310 sockunion_free(member
->update_source
);
5311 member
->update_source
= NULL
;
5313 /* Send notification or reset peer depending on state. */
5314 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5315 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5316 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5317 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5319 bgp_session_reset(member
);
5321 /* Apply new source configuration to BFD session. */
5322 if (member
->bfd_config
)
5323 bgp_peer_bfd_update_source(member
);
5329 void peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
5331 struct peer
*member
;
5332 struct listnode
*node
, *nnode
;
5334 /* Set flag and configuration on peer. */
5335 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5336 if (peer
->update_source
) {
5337 if (sockunion_cmp(peer
->update_source
, su
) == 0)
5339 sockunion_free(peer
->update_source
);
5341 peer
->update_source
= sockunion_dup(su
);
5342 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5344 /* Check if handling a regular peer. */
5345 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5346 /* Send notification or reset peer depending on state. */
5347 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5348 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5349 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5350 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5352 bgp_session_reset(peer
);
5354 /* Apply new source configuration to BFD session. */
5355 if (peer
->bfd_config
)
5356 bgp_peer_bfd_update_source(peer
);
5358 /* Skip peer-group mechanics for regular peers. */
5363 * Set flag and configuration on all peer-group members, unless they are
5364 * explicitly overriding peer-group configuration.
5366 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5367 /* Skip peers with overridden configuration. */
5368 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5371 /* Skip peers with the same configuration. */
5372 if (member
->update_source
) {
5373 if (sockunion_cmp(member
->update_source
, su
) == 0)
5375 sockunion_free(member
->update_source
);
5378 /* Set flag and configuration on peer-group member. */
5379 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5380 member
->update_source
= sockunion_dup(su
);
5381 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5383 /* Send notification or reset peer depending on state. */
5384 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5385 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5386 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5387 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5389 bgp_session_reset(member
);
5391 /* Apply new source configuration to BFD session. */
5392 if (member
->bfd_config
)
5393 bgp_peer_bfd_update_source(member
);
5397 void peer_update_source_unset(struct peer
*peer
)
5399 struct peer
*member
;
5400 struct listnode
*node
, *nnode
;
5402 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_UPDATE_SOURCE
))
5405 /* Inherit configuration from peer-group if peer is member. */
5406 if (peer_group_active(peer
)) {
5407 peer_flag_inherit(peer
, PEER_FLAG_UPDATE_SOURCE
);
5408 PEER_SU_ATTR_INHERIT(peer
, peer
->group
, update_source
);
5409 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, update_if
,
5410 MTYPE_PEER_UPDATE_SOURCE
);
5412 /* Otherwise remove flag and configuration from peer. */
5413 peer_flag_unset(peer
, PEER_FLAG_UPDATE_SOURCE
);
5414 sockunion_free(peer
->update_source
);
5415 peer
->update_source
= NULL
;
5416 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5419 /* Check if handling a regular peer. */
5420 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5421 /* Send notification or reset peer depending on state. */
5422 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5423 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5424 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5425 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5427 bgp_session_reset(peer
);
5429 /* Apply new source configuration to BFD session. */
5430 if (peer
->bfd_config
)
5431 bgp_peer_bfd_update_source(peer
);
5433 /* Skip peer-group mechanics for regular peers. */
5438 * Set flag and configuration on all peer-group members, unless they are
5439 * explicitly overriding peer-group configuration.
5441 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5442 /* Skip peers with overridden configuration. */
5443 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5446 /* Skip peers with the same configuration. */
5447 if (!CHECK_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
)
5448 && !member
->update_source
&& !member
->update_if
)
5451 /* Remove flag and configuration on peer-group member. */
5452 UNSET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5453 sockunion_free(member
->update_source
);
5454 member
->update_source
= NULL
;
5455 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5457 /* Send notification or reset peer depending on state. */
5458 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5459 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5460 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5461 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5463 bgp_session_reset(member
);
5465 /* Apply new source configuration to BFD session. */
5466 if (member
->bfd_config
)
5467 bgp_peer_bfd_update_source(member
);
5471 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5472 const char *rmap
, struct route_map
*route_map
)
5474 struct peer
*member
;
5475 struct listnode
*node
, *nnode
;
5476 struct update_subgroup
*subgrp
;
5478 /* Set flag and configuration on peer. */
5479 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
5481 subgrp
= peer_subgroup(peer
, afi
, safi
);
5484 if (!peer
->default_rmap
[afi
][safi
].name
5485 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
5486 if (peer
->default_rmap
[afi
][safi
].name
)
5487 XFREE(MTYPE_ROUTE_MAP_NAME
,
5488 peer
->default_rmap
[afi
][safi
].name
);
5491 * When there is a change in route-map policy,
5492 * this flow gets triggered. Since, the default
5493 * route is already originated, the flag is set.
5494 * The flag should be unset here,
5495 * to trigger the flow of sending update message.
5498 UNSET_FLAG(subgrp
->sflags
,
5499 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5501 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5502 peer
->default_rmap
[afi
][safi
].name
=
5503 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5504 peer
->default_rmap
[afi
][safi
].map
= route_map
;
5505 route_map_counter_increment(route_map
);
5508 if (peer
->default_rmap
[afi
][safi
].name
)
5509 XFREE(MTYPE_ROUTE_MAP_NAME
,
5510 peer
->default_rmap
[afi
][safi
].name
);
5513 * This is triggered in case of route-map deletion.
5514 * The flag needs to be unset, to trigger the flow
5515 * of sending an update message.
5518 UNSET_FLAG(subgrp
->sflags
,
5519 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5521 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5522 peer
->default_rmap
[afi
][safi
].name
= NULL
;
5523 peer
->default_rmap
[afi
][safi
].map
= NULL
;
5526 /* Check if handling a regular peer. */
5527 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5528 /* Update peer route announcements. */
5529 if (peer_established(peer
) && peer
->afc_nego
[afi
][safi
]) {
5530 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5531 bgp_default_originate(peer
, afi
, safi
, 0);
5532 bgp_announce_route(peer
, afi
, safi
, false);
5535 /* Skip peer-group mechanics for regular peers. */
5540 * Set flag and configuration on all peer-group members, unless they are
5541 * explicitly overriding peer-group configuration.
5543 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5544 /* Skip peers with overridden configuration. */
5545 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5546 PEER_FLAG_DEFAULT_ORIGINATE
))
5549 /* Set flag and configuration on peer-group member. */
5550 SET_FLAG(member
->af_flags
[afi
][safi
],
5551 PEER_FLAG_DEFAULT_ORIGINATE
);
5553 if (member
->default_rmap
[afi
][safi
].name
)
5554 XFREE(MTYPE_ROUTE_MAP_NAME
,
5555 member
->default_rmap
[afi
][safi
].name
);
5556 route_map_counter_decrement(
5557 member
->default_rmap
[afi
][safi
].map
);
5558 member
->default_rmap
[afi
][safi
].name
=
5559 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5560 member
->default_rmap
[afi
][safi
].map
= route_map
;
5561 route_map_counter_increment(route_map
);
5564 /* Update peer route announcements. */
5565 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5566 update_group_adjust_peer(
5567 peer_af_find(member
, afi
, safi
));
5568 bgp_default_originate(member
, afi
, safi
, 0);
5569 bgp_announce_route(member
, afi
, safi
, false);
5576 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5578 struct peer
*member
;
5579 struct listnode
*node
, *nnode
;
5581 /* Inherit configuration from peer-group if peer is member. */
5582 if (peer_group_active(peer
)) {
5583 peer_af_flag_inherit(peer
, afi
, safi
,
5584 PEER_FLAG_DEFAULT_ORIGINATE
);
5585 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5586 default_rmap
[afi
][safi
].name
,
5587 MTYPE_ROUTE_MAP_NAME
);
5588 PEER_ATTR_INHERIT(peer
, peer
->group
,
5589 default_rmap
[afi
][safi
].map
);
5591 /* Otherwise remove flag and configuration from peer. */
5592 peer_af_flag_unset(peer
, afi
, safi
,
5593 PEER_FLAG_DEFAULT_ORIGINATE
);
5594 if (peer
->default_rmap
[afi
][safi
].name
)
5595 XFREE(MTYPE_ROUTE_MAP_NAME
,
5596 peer
->default_rmap
[afi
][safi
].name
);
5597 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5598 peer
->default_rmap
[afi
][safi
].name
= NULL
;
5599 peer
->default_rmap
[afi
][safi
].map
= NULL
;
5602 /* Check if handling a regular peer. */
5603 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5604 /* Update peer route announcements. */
5605 if (peer_established(peer
) && peer
->afc_nego
[afi
][safi
]) {
5606 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5607 bgp_default_originate(peer
, afi
, safi
, 1);
5608 bgp_announce_route(peer
, afi
, safi
, false);
5611 /* Skip peer-group mechanics for regular peers. */
5616 * Remove flag and configuration from all peer-group members, unless
5617 * they are explicitly overriding peer-group configuration.
5619 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5620 /* Skip peers with overridden configuration. */
5621 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5622 PEER_FLAG_DEFAULT_ORIGINATE
))
5625 /* Remove flag and configuration on peer-group member. */
5626 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5627 PEER_FLAG_DEFAULT_ORIGINATE
);
5628 if (member
->default_rmap
[afi
][safi
].name
)
5629 XFREE(MTYPE_ROUTE_MAP_NAME
,
5630 member
->default_rmap
[afi
][safi
].name
);
5631 route_map_counter_decrement(member
->default_rmap
[afi
][safi
].map
);
5632 member
->default_rmap
[afi
][safi
].name
= NULL
;
5633 member
->default_rmap
[afi
][safi
].map
= NULL
;
5635 /* Update peer route announcements. */
5636 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5637 update_group_adjust_peer(peer_af_find(member
, afi
, safi
));
5638 bgp_default_originate(member
, afi
, safi
, 1);
5639 bgp_announce_route(member
, afi
, safi
, false);
5646 void peer_port_set(struct peer
*peer
, uint16_t port
)
5649 peer_flag_set(peer
, PEER_FLAG_PORT
);
5652 void peer_port_unset(struct peer
*peer
)
5654 peer
->port
= BGP_PORT_DEFAULT
;
5655 peer_flag_unset(peer
, PEER_FLAG_PORT
);
5658 /* Set the TCP-MSS value in the peer structure,
5659 * This gets applied only after connection reset
5660 * So this value will be used in bgp_connect.
5662 void peer_tcp_mss_set(struct peer
*peer
, uint32_t tcp_mss
)
5664 peer
->tcp_mss
= tcp_mss
;
5665 SET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5668 /* Reset the TCP-MSS value in the peer structure,
5669 * This gets applied only after connection reset
5670 * So this value will be used in bgp_connect.
5672 void peer_tcp_mss_unset(struct peer
*peer
)
5674 UNSET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5679 * Helper function that is called after the name of the policy
5680 * being used by a peer has changed (AF specific). Automatically
5681 * initiates inbound or outbound processing as needed.
5683 void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
5687 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5688 if (peer_established(peer
))
5689 bgp_announce_route(peer
, afi
, safi
, false);
5691 if (!peer_established(peer
))
5694 if (bgp_soft_reconfig_in(peer
, afi
, safi
))
5697 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
) ||
5698 CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
5699 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0,
5700 BGP_ROUTE_REFRESH_NORMAL
);
5705 /* neighbor weight. */
5706 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
5708 struct peer
*member
;
5709 struct listnode
*node
, *nnode
;
5711 /* Set flag and configuration on peer. */
5712 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5713 if (peer
->weight
[afi
][safi
] != weight
) {
5714 peer
->weight
[afi
][safi
] = weight
;
5715 peer_on_policy_change(peer
, afi
, safi
, 0);
5718 /* Skip peer-group mechanics for regular peers. */
5719 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5723 * Set flag and configuration on all peer-group members, unless they are
5724 * explicitly overriding peer-group configuration.
5726 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5727 /* Skip peers with overridden configuration. */
5728 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5732 /* Set flag and configuration on peer-group member. */
5733 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5734 if (member
->weight
[afi
][safi
] != weight
) {
5735 member
->weight
[afi
][safi
] = weight
;
5736 peer_on_policy_change(member
, afi
, safi
, 0);
5743 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5745 struct peer
*member
;
5746 struct listnode
*node
, *nnode
;
5748 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5751 /* Inherit configuration from peer-group if peer is member. */
5752 if (peer_group_active(peer
)) {
5753 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5754 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
5756 peer_on_policy_change(peer
, afi
, safi
, 0);
5760 /* Remove flag and configuration from peer. */
5761 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5762 peer
->weight
[afi
][safi
] = 0;
5763 peer_on_policy_change(peer
, afi
, safi
, 0);
5765 /* Skip peer-group mechanics for regular peers. */
5766 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5770 * Remove flag and configuration from all peer-group members, unless
5771 * they are explicitly overriding peer-group configuration.
5773 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5774 /* Skip peers with overridden configuration. */
5775 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5779 /* Skip peers where flag is already disabled. */
5780 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5783 /* Remove flag and configuration on peer-group member. */
5784 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5785 member
->weight
[afi
][safi
] = 0;
5786 peer_on_policy_change(member
, afi
, safi
, 0);
5792 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
5794 struct peer
*member
;
5795 struct listnode
*node
, *nnode
;
5797 if (keepalive
> UINT16_MAX
)
5798 return BGP_ERR_INVALID_VALUE
;
5800 if (holdtime
> UINT16_MAX
)
5801 return BGP_ERR_INVALID_VALUE
;
5803 if (holdtime
< 3 && holdtime
!= 0)
5804 return BGP_ERR_INVALID_VALUE
;
5806 /* Set flag and configuration on peer. */
5807 peer_flag_set(peer
, PEER_FLAG_TIMER
);
5808 peer
->holdtime
= holdtime
;
5809 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
5811 /* Skip peer-group mechanics for regular peers. */
5812 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5816 * Set flag and configuration on all peer-group members, unless they are
5817 * explicitly overriding peer-group configuration.
5819 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5820 /* Skip peers with overridden configuration. */
5821 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5824 /* Set flag and configuration on peer-group member. */
5825 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5826 PEER_ATTR_INHERIT(member
, peer
->group
, holdtime
);
5827 PEER_ATTR_INHERIT(member
, peer
->group
, keepalive
);
5833 int peer_timers_unset(struct peer
*peer
)
5835 struct peer
*member
;
5836 struct listnode
*node
, *nnode
;
5838 /* Inherit configuration from peer-group if peer is member. */
5839 if (peer_group_active(peer
)) {
5840 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
5841 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
5842 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
5844 /* Otherwise remove flag and configuration from peer. */
5845 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
5847 peer
->keepalive
= 0;
5850 /* Skip peer-group mechanics for regular peers. */
5851 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5855 * Remove flag and configuration from all peer-group members, unless
5856 * they are explicitly overriding peer-group configuration.
5858 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5859 /* Skip peers with overridden configuration. */
5860 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5863 /* Remove flag and configuration on peer-group member. */
5864 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5865 member
->holdtime
= 0;
5866 member
->keepalive
= 0;
5872 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
5874 struct peer
*member
;
5875 struct listnode
*node
, *nnode
;
5877 if (connect
> UINT16_MAX
)
5878 return BGP_ERR_INVALID_VALUE
;
5880 /* Set flag and configuration on peer. */
5881 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
5882 peer
->connect
= connect
;
5883 peer
->v_connect
= connect
;
5885 /* Skip peer-group mechanics for regular peers. */
5886 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5887 if (!peer_established(peer
)) {
5888 if (peer_active(peer
))
5889 BGP_EVENT_ADD(peer
, BGP_Stop
);
5890 BGP_EVENT_ADD(peer
, BGP_Start
);
5895 * Set flag and configuration on all peer-group members, unless they are
5896 * explicitly overriding peer-group configuration.
5898 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5899 /* Skip peers with overridden configuration. */
5900 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5903 /* Set flag and configuration on peer-group member. */
5904 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5905 member
->connect
= connect
;
5906 member
->v_connect
= connect
;
5908 if (!peer_established(member
)) {
5909 if (peer_active(member
))
5910 BGP_EVENT_ADD(member
, BGP_Stop
);
5911 BGP_EVENT_ADD(member
, BGP_Start
);
5918 int peer_timers_connect_unset(struct peer
*peer
)
5920 struct peer
*member
;
5921 struct listnode
*node
, *nnode
;
5923 /* Inherit configuration from peer-group if peer is member. */
5924 if (peer_group_active(peer
)) {
5925 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5926 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5928 /* Otherwise remove flag and configuration from peer. */
5929 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5933 /* Set timer with fallback to default value. */
5935 peer
->v_connect
= peer
->connect
;
5937 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
5939 /* Skip peer-group mechanics for regular peers. */
5940 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5941 if (!peer_established(peer
)) {
5942 if (peer_active(peer
))
5943 BGP_EVENT_ADD(peer
, BGP_Stop
);
5944 BGP_EVENT_ADD(peer
, BGP_Start
);
5949 * Remove flag and configuration from all peer-group members, unless
5950 * they are explicitly overriding peer-group configuration.
5952 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5953 /* Skip peers with overridden configuration. */
5954 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5957 /* Remove flag and configuration on peer-group member. */
5958 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5959 member
->connect
= 0;
5960 member
->v_connect
= peer
->bgp
->default_connect_retry
;
5962 if (!peer_established(member
)) {
5963 if (peer_active(member
))
5964 BGP_EVENT_ADD(member
, BGP_Stop
);
5965 BGP_EVENT_ADD(member
, BGP_Start
);
5972 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5974 struct peer
*member
;
5975 struct listnode
*node
, *nnode
;
5978 return BGP_ERR_INVALID_VALUE
;
5980 /* Set flag and configuration on peer. */
5981 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5982 peer
->routeadv
= routeadv
;
5983 peer
->v_routeadv
= routeadv
;
5985 /* Check if handling a regular peer. */
5986 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5987 /* Update peer route announcements. */
5988 update_group_adjust_peer_afs(peer
);
5989 if (peer_established(peer
))
5990 bgp_announce_route_all(peer
);
5992 /* Skip peer-group mechanics for regular peers. */
5997 * Set flag and configuration on all peer-group members, unless they are
5998 * explicitly overriding peer-group configuration.
6000 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6001 /* Skip peers with overridden configuration. */
6002 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
6005 /* Set flag and configuration on peer-group member. */
6006 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
6007 member
->routeadv
= routeadv
;
6008 member
->v_routeadv
= routeadv
;
6010 /* Update peer route announcements. */
6011 update_group_adjust_peer_afs(member
);
6012 if (peer_established(member
))
6013 bgp_announce_route_all(member
);
6019 int peer_advertise_interval_unset(struct peer
*peer
)
6021 struct peer
*member
;
6022 struct listnode
*node
, *nnode
;
6024 /* Inherit configuration from peer-group if peer is member. */
6025 if (peer_group_active(peer
)) {
6026 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
6027 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
6029 /* Otherwise remove flag and configuration from peer. */
6030 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
6034 /* Set timer with fallback to default value. */
6036 peer
->v_routeadv
= peer
->routeadv
;
6038 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
6039 ? BGP_DEFAULT_IBGP_ROUTEADV
6040 : BGP_DEFAULT_EBGP_ROUTEADV
;
6042 /* Check if handling a regular peer. */
6043 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6044 /* Update peer route announcements. */
6045 update_group_adjust_peer_afs(peer
);
6046 if (peer_established(peer
))
6047 bgp_announce_route_all(peer
);
6049 /* Skip peer-group mechanics for regular peers. */
6054 * Remove flag and configuration from all peer-group members, unless
6055 * they are explicitly overriding peer-group configuration.
6057 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6058 /* Skip peers with overridden configuration. */
6059 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
6062 /* Remove flag and configuration on peer-group member. */
6063 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
6064 member
->routeadv
= 0;
6065 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
6066 ? BGP_DEFAULT_IBGP_ROUTEADV
6067 : BGP_DEFAULT_EBGP_ROUTEADV
;
6069 /* Update peer route announcements. */
6070 update_group_adjust_peer_afs(member
);
6071 if (peer_established(member
))
6072 bgp_announce_route_all(member
);
6078 /* set the peers RFC 4271 DelayOpen session attribute flag and DelayOpenTimer
6081 int peer_timers_delayopen_set(struct peer
*peer
, uint32_t delayopen
)
6083 struct peer
*member
;
6084 struct listnode
*node
;
6086 /* Set peers session attribute flag and timer interval. */
6087 peer_flag_set(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6088 peer
->delayopen
= delayopen
;
6089 peer
->v_delayopen
= delayopen
;
6091 /* Skip group mechanics for regular peers. */
6092 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6095 /* Set flag and configuration on all peer-group members, unless they are
6096 * explicitly overriding peer-group configuration.
6098 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6099 /* Skip peers with overridden configuration. */
6100 if (CHECK_FLAG(member
->flags_override
,
6101 PEER_FLAG_TIMER_DELAYOPEN
))
6104 /* Set session attribute flag and timer intervals on peer-group
6107 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6108 member
->delayopen
= delayopen
;
6109 member
->v_delayopen
= delayopen
;
6115 /* unset the peers RFC 4271 DelayOpen session attribute flag and reset the
6116 * DelayOpenTimer interval to the default value.
6118 int peer_timers_delayopen_unset(struct peer
*peer
)
6120 struct peer
*member
;
6121 struct listnode
*node
;
6123 /* Inherit configuration from peer-group if peer is member. */
6124 if (peer_group_active(peer
)) {
6125 peer_flag_inherit(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6126 PEER_ATTR_INHERIT(peer
, peer
->group
, delayopen
);
6128 /* Otherwise remove session attribute flag and set timer
6129 * interval to default value.
6131 peer_flag_unset(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6132 peer
->delayopen
= peer
->bgp
->default_delayopen
;
6135 /* Set timer value to zero */
6136 peer
->v_delayopen
= 0;
6138 /* Skip peer-group mechanics for regular peers. */
6139 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6142 /* Remove flag and configuration from all peer-group members, unless
6143 * they are explicitly overriding peer-group configuration.
6145 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6146 /* Skip peers with overridden configuration. */
6147 if (CHECK_FLAG(member
->flags_override
,
6148 PEER_FLAG_TIMER_DELAYOPEN
))
6151 /* Remove session attribute flag, reset the timer interval to
6152 * the default value and set the timer value to zero.
6154 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6155 member
->delayopen
= peer
->bgp
->default_delayopen
;
6156 member
->v_delayopen
= 0;
6162 /* neighbor interface */
6163 void peer_interface_set(struct peer
*peer
, const char *str
)
6165 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6166 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
6169 void peer_interface_unset(struct peer
*peer
)
6171 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6175 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6176 int allow_num
, int origin
)
6178 struct peer
*member
;
6179 struct listnode
*node
, *nnode
;
6181 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
6182 return BGP_ERR_INVALID_VALUE
;
6184 /* Set flag and configuration on peer. */
6185 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6187 if (peer
->allowas_in
[afi
][safi
] != 0
6188 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6189 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6190 peer_af_flag_set(peer
, afi
, safi
,
6191 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6192 peer
->allowas_in
[afi
][safi
] = 0;
6193 peer_on_policy_change(peer
, afi
, safi
, 0);
6196 if (peer
->allowas_in
[afi
][safi
] != allow_num
6197 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6198 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6200 peer_af_flag_unset(peer
, afi
, safi
,
6201 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6202 peer
->allowas_in
[afi
][safi
] = allow_num
;
6203 peer_on_policy_change(peer
, afi
, safi
, 0);
6207 /* Skip peer-group mechanics for regular peers. */
6208 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6212 * Set flag and configuration on all peer-group members, unless
6213 * they are explicitly overriding peer-group configuration.
6215 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6216 /* Skip peers with overridden configuration. */
6217 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6218 PEER_FLAG_ALLOWAS_IN
))
6221 /* Set flag and configuration on peer-group member. */
6222 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6224 if (member
->allowas_in
[afi
][safi
] != 0
6225 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
6226 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6227 SET_FLAG(member
->af_flags
[afi
][safi
],
6228 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6229 member
->allowas_in
[afi
][safi
] = 0;
6230 peer_on_policy_change(peer
, afi
, safi
, 0);
6233 if (member
->allowas_in
[afi
][safi
] != allow_num
6234 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
6235 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6236 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6237 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6238 member
->allowas_in
[afi
][safi
] = allow_num
;
6239 peer_on_policy_change(peer
, afi
, safi
, 0);
6247 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6249 struct peer
*member
;
6250 struct listnode
*node
, *nnode
;
6252 /* Skip peer if flag is already disabled. */
6253 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
6256 /* Inherit configuration from peer-group if peer is member. */
6257 if (peer_group_active(peer
)) {
6258 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6259 peer_af_flag_inherit(peer
, afi
, safi
,
6260 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6261 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
6262 peer_on_policy_change(peer
, afi
, safi
, 0);
6267 /* Remove flag and configuration from peer. */
6268 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6269 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6270 peer
->allowas_in
[afi
][safi
] = 0;
6271 peer_on_policy_change(peer
, afi
, safi
, 0);
6273 /* Skip peer-group mechanics if handling a regular peer. */
6274 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6278 * Remove flags and configuration from all peer-group members, unless
6279 * they are explicitly overriding peer-group configuration.
6281 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6282 /* Skip peers with overridden configuration. */
6283 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6284 PEER_FLAG_ALLOWAS_IN
))
6287 /* Remove flags and configuration on peer-group member. */
6288 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6289 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6290 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6291 member
->allowas_in
[afi
][safi
] = 0;
6292 peer_on_policy_change(member
, afi
, safi
, 0);
6298 int peer_local_as_set(struct peer
*peer
, as_t as
, bool no_prepend
,
6299 bool replace_as
, const char *as_str
)
6301 bool old_no_prepend
, old_replace_as
;
6302 struct bgp
*bgp
= peer
->bgp
;
6303 struct peer
*member
;
6304 struct listnode
*node
, *nnode
;
6307 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
6309 /* Save previous flag states. */
6311 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6313 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6315 /* Set flag and configuration on peer. */
6316 peer_flag_set(peer
, PEER_FLAG_LOCAL_AS
);
6317 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
, no_prepend
);
6318 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
, replace_as
);
6320 if (peer
->change_local_as
== as
&& old_no_prepend
== no_prepend
6321 && old_replace_as
== replace_as
)
6323 peer
->change_local_as
= as
;
6325 if (peer
->change_local_as_pretty
)
6326 XFREE(MTYPE_BGP
, peer
->change_local_as_pretty
);
6327 peer
->change_local_as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
6330 (void)peer_sort(peer
);
6332 /* Check if handling a regular peer. */
6333 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6337 * Set flag and configuration on all peer-group members, unless they are
6338 * explicitly overriding peer-group configuration.
6340 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6341 /* Skip peers with overridden configuration. */
6342 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6345 /* Skip peers with the same configuration. */
6346 old_no_prepend
= CHECK_FLAG(member
->flags
,
6347 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6348 old_replace_as
= CHECK_FLAG(member
->flags
,
6349 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6350 if (member
->change_local_as
== as
6351 && CHECK_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
)
6352 && old_no_prepend
== no_prepend
6353 && old_replace_as
== replace_as
)
6356 /* Set flag and configuration on peer-group member. */
6357 SET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6358 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
,
6360 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
,
6362 member
->change_local_as
= as
;
6364 member
->change_local_as_pretty
=
6365 XSTRDUP(MTYPE_BGP
, as_str
);
6371 int peer_local_as_unset(struct peer
*peer
)
6373 struct peer
*member
;
6374 struct listnode
*node
, *nnode
;
6376 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS
))
6379 /* Inherit configuration from peer-group if peer is member. */
6380 if (peer_group_active(peer
)) {
6381 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS
);
6382 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6383 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6384 PEER_ATTR_INHERIT(peer
, peer
->group
, change_local_as
);
6386 /* Otherwise remove flag and configuration from peer. */
6387 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
6388 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6389 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6390 peer
->change_local_as
= 0;
6391 XFREE(MTYPE_BGP
, peer
->change_local_as_pretty
);
6394 /* Check if handling a regular peer. */
6395 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6396 /* Send notification or stop peer depending on state. */
6397 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
6398 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6399 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6400 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6402 BGP_EVENT_ADD(peer
, BGP_Stop
);
6404 /* Skip peer-group mechanics for regular peers. */
6409 * Remove flag and configuration from all peer-group members, unless
6410 * they are explicitly overriding peer-group configuration.
6412 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6413 /* Skip peers with overridden configuration. */
6414 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6417 /* Remove flag and configuration on peer-group member. */
6418 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6419 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6420 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6421 member
->change_local_as
= 0;
6422 XFREE(MTYPE_BGP
, member
->change_local_as_pretty
);
6424 /* Send notification or stop peer depending on state. */
6425 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
6426 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6427 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6428 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6430 bgp_session_reset(member
);
6436 /* Set password for authenticating with the peer. */
6437 int peer_password_set(struct peer
*peer
, const char *password
)
6439 struct peer
*member
;
6440 struct listnode
*node
, *nnode
;
6441 int len
= password
? strlen(password
) : 0;
6442 int ret
= BGP_SUCCESS
;
6444 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
6445 return BGP_ERR_INVALID_VALUE
;
6447 /* Set flag and configuration on peer. */
6448 peer_flag_set(peer
, PEER_FLAG_PASSWORD
);
6449 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
6451 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6452 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6454 /* Check if handling a regular peer. */
6455 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6456 /* Send notification or reset peer depending on state. */
6457 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6458 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6459 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6461 bgp_session_reset(peer
);
6464 * Attempt to install password on socket and skip peer-group
6467 if (BGP_PEER_SU_UNSPEC(peer
))
6469 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
6470 : BGP_ERR_TCPSIG_FAILED
;
6474 * Set flag and configuration on all peer-group members, unless they are
6475 * explicitly overriding peer-group configuration.
6477 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6478 /* Skip peers with overridden configuration. */
6479 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6482 /* Skip peers with the same password. */
6483 if (member
->password
&& strcmp(member
->password
, password
) == 0)
6486 /* Set flag and configuration on peer-group member. */
6487 SET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6488 if (member
->password
)
6489 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6490 member
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6492 /* Send notification or reset peer depending on state. */
6493 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6494 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6495 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6497 bgp_session_reset(member
);
6499 /* Attempt to install password on socket. */
6500 if (!BGP_PEER_SU_UNSPEC(member
) && bgp_md5_set(member
) < 0)
6501 ret
= BGP_ERR_TCPSIG_FAILED
;
6504 /* Set flag and configuration on all peer-group listen ranges */
6505 struct listnode
*ln
;
6508 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6509 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6510 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6511 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6516 int peer_password_unset(struct peer
*peer
)
6518 struct peer
*member
;
6519 struct listnode
*node
, *nnode
;
6521 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
))
6524 /* Inherit configuration from peer-group if peer is member. */
6525 if (peer_group_active(peer
)) {
6526 peer_flag_inherit(peer
, PEER_FLAG_PASSWORD
);
6527 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, password
,
6528 MTYPE_PEER_PASSWORD
);
6530 /* Otherwise remove flag and configuration from peer. */
6531 peer_flag_unset(peer
, PEER_FLAG_PASSWORD
);
6532 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6535 /* Check if handling a regular peer. */
6536 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6537 /* Send notification or reset peer depending on state. */
6538 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6539 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6540 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6542 bgp_session_reset(peer
);
6544 /* Attempt to uninstall password on socket. */
6545 if (!BGP_PEER_SU_UNSPEC(peer
))
6546 bgp_md5_unset(peer
);
6547 /* Skip peer-group mechanics for regular peers. */
6552 * Remove flag and configuration from all peer-group members, unless
6553 * they are explicitly overriding peer-group configuration.
6555 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6556 /* Skip peers with overridden configuration. */
6557 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6560 /* Remove flag and configuration on peer-group member. */
6561 UNSET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6562 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6564 /* Send notification or reset peer depending on state. */
6565 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6566 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6567 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6569 bgp_session_reset(member
);
6571 /* Attempt to uninstall password on socket. */
6572 if (!BGP_PEER_SU_UNSPEC(member
))
6573 bgp_md5_unset(member
);
6576 /* Set flag and configuration on all peer-group listen ranges */
6577 struct listnode
*ln
;
6580 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6581 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6582 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6583 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6589 /* Set distribute list to the peer. */
6590 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6593 struct peer
*member
;
6594 struct bgp_filter
*filter
;
6595 struct listnode
*node
, *nnode
;
6597 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6598 return BGP_ERR_INVALID_VALUE
;
6600 /* Set configuration on peer. */
6601 filter
= &peer
->filter
[afi
][safi
];
6602 if (filter
->plist
[direct
].name
)
6603 return BGP_ERR_PEER_FILTER_CONFLICT
;
6604 if (filter
->dlist
[direct
].name
)
6605 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
6606 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6607 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6609 /* Check if handling a regular peer. */
6610 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6611 /* Set override-flag and process peer route updates. */
6612 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6613 PEER_FT_DISTRIBUTE_LIST
);
6614 peer_on_policy_change(peer
, afi
, safi
,
6615 (direct
== FILTER_OUT
) ? 1 : 0);
6617 /* Skip peer-group mechanics for regular peers. */
6622 * Set configuration on all peer-group members, un less they are
6623 * explicitly overriding peer-group configuration.
6625 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6626 /* Skip peers with overridden configuration. */
6627 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6628 PEER_FT_DISTRIBUTE_LIST
))
6631 /* Set configuration on peer-group member. */
6632 filter
= &member
->filter
[afi
][safi
];
6633 if (filter
->dlist
[direct
].name
)
6634 XFREE(MTYPE_BGP_FILTER_NAME
,
6635 filter
->dlist
[direct
].name
);
6636 filter
->dlist
[direct
].name
=
6637 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6638 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6640 /* Process peer route updates. */
6641 peer_on_policy_change(member
, afi
, safi
,
6642 (direct
== FILTER_OUT
) ? 1 : 0);
6648 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6650 struct peer
*member
;
6651 struct bgp_filter
*filter
;
6652 struct listnode
*node
, *nnode
;
6654 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6655 return BGP_ERR_INVALID_VALUE
;
6657 /* Unset override-flag unconditionally. */
6658 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6659 PEER_FT_DISTRIBUTE_LIST
);
6661 /* Inherit configuration from peer-group if peer is member. */
6662 if (peer_group_active(peer
)) {
6663 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6664 filter
[afi
][safi
].dlist
[direct
].name
,
6665 MTYPE_BGP_FILTER_NAME
);
6666 PEER_ATTR_INHERIT(peer
, peer
->group
,
6667 filter
[afi
][safi
].dlist
[direct
].alist
);
6669 /* Otherwise remove configuration from peer. */
6670 filter
= &peer
->filter
[afi
][safi
];
6671 if (filter
->dlist
[direct
].name
)
6672 XFREE(MTYPE_BGP_FILTER_NAME
,
6673 filter
->dlist
[direct
].name
);
6674 filter
->dlist
[direct
].name
= NULL
;
6675 filter
->dlist
[direct
].alist
= NULL
;
6678 /* Check if handling a regular peer. */
6679 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6680 /* Process peer route updates. */
6681 peer_on_policy_change(peer
, afi
, safi
,
6682 (direct
== FILTER_OUT
) ? 1 : 0);
6684 /* Skip peer-group mechanics for regular peers. */
6689 * Remove configuration on all peer-group members, unless they are
6690 * explicitly overriding peer-group configuration.
6692 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6693 /* Skip peers with overridden configuration. */
6694 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6695 PEER_FT_DISTRIBUTE_LIST
))
6698 /* Remove configuration on peer-group member. */
6699 filter
= &member
->filter
[afi
][safi
];
6700 if (filter
->dlist
[direct
].name
)
6701 XFREE(MTYPE_BGP_FILTER_NAME
,
6702 filter
->dlist
[direct
].name
);
6703 filter
->dlist
[direct
].name
= NULL
;
6704 filter
->dlist
[direct
].alist
= NULL
;
6706 /* Process peer route updates. */
6707 peer_on_policy_change(member
, afi
, safi
,
6708 (direct
== FILTER_OUT
) ? 1 : 0);
6714 /* Update distribute list. */
6715 static void peer_distribute_update(struct access_list
*access
)
6720 struct listnode
*mnode
, *mnnode
;
6721 struct listnode
*node
, *nnode
;
6724 struct peer_group
*group
;
6725 struct bgp_filter
*filter
;
6727 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6729 update_group_policy_update(bgp
,
6730 BGP_POLICY_DISTRIBUTE_LIST
,
6731 access
->name
, true, 0);
6732 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6733 FOREACH_AFI_SAFI (afi
, safi
) {
6734 filter
= &peer
->filter
[afi
][safi
];
6736 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6738 if (filter
->dlist
[direct
].name
)
6739 filter
->dlist
[direct
]
6740 .alist
= access_list_lookup(
6742 filter
->dlist
[direct
]
6745 filter
->dlist
[direct
].alist
=
6750 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6751 FOREACH_AFI_SAFI (afi
, safi
) {
6752 filter
= &group
->conf
->filter
[afi
][safi
];
6754 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6756 if (filter
->dlist
[direct
].name
)
6757 filter
->dlist
[direct
]
6758 .alist
= access_list_lookup(
6760 filter
->dlist
[direct
]
6763 filter
->dlist
[direct
].alist
=
6768 #ifdef ENABLE_BGP_VNC
6769 vnc_prefix_list_update(bgp
);
6774 /* Set prefix list to the peer. */
6775 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6778 struct peer
*member
;
6779 struct bgp_filter
*filter
;
6780 struct listnode
*node
, *nnode
;
6782 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6783 return BGP_ERR_INVALID_VALUE
;
6785 /* Set configuration on peer. */
6786 filter
= &peer
->filter
[afi
][safi
];
6787 if (filter
->dlist
[direct
].name
)
6788 return BGP_ERR_PEER_FILTER_CONFLICT
;
6789 if (filter
->plist
[direct
].name
)
6790 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
6791 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6792 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6794 /* Check if handling a regular peer. */
6795 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6796 /* Set override-flag and process peer route updates. */
6797 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6798 PEER_FT_PREFIX_LIST
);
6799 peer_on_policy_change(peer
, afi
, safi
,
6800 (direct
== FILTER_OUT
) ? 1 : 0);
6802 /* Skip peer-group mechanics for regular peers. */
6807 * Set configuration on all peer-group members, unless they are
6808 * explicitly overriding peer-group configuration.
6810 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6811 /* Skip peers with overridden configuration. */
6812 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6813 PEER_FT_PREFIX_LIST
))
6816 /* Set configuration on peer-group member. */
6817 filter
= &member
->filter
[afi
][safi
];
6818 if (filter
->plist
[direct
].name
)
6819 XFREE(MTYPE_BGP_FILTER_NAME
,
6820 filter
->plist
[direct
].name
);
6821 filter
->plist
[direct
].name
=
6822 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6823 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6825 /* Process peer route updates. */
6826 peer_on_policy_change(member
, afi
, safi
,
6827 (direct
== FILTER_OUT
) ? 1 : 0);
6833 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
6836 struct peer
*member
;
6837 struct bgp_filter
*filter
;
6838 struct listnode
*node
, *nnode
;
6840 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6841 return BGP_ERR_INVALID_VALUE
;
6843 /* Unset override-flag unconditionally. */
6844 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6845 PEER_FT_PREFIX_LIST
);
6847 /* Inherit configuration from peer-group if peer is member. */
6848 if (peer_group_active(peer
)) {
6849 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6850 filter
[afi
][safi
].plist
[direct
].name
,
6851 MTYPE_BGP_FILTER_NAME
);
6852 PEER_ATTR_INHERIT(peer
, peer
->group
,
6853 filter
[afi
][safi
].plist
[direct
].plist
);
6855 /* Otherwise remove configuration from peer. */
6856 filter
= &peer
->filter
[afi
][safi
];
6857 if (filter
->plist
[direct
].name
)
6858 XFREE(MTYPE_BGP_FILTER_NAME
,
6859 filter
->plist
[direct
].name
);
6860 filter
->plist
[direct
].name
= NULL
;
6861 filter
->plist
[direct
].plist
= NULL
;
6864 /* Check if handling a regular peer. */
6865 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6866 /* Process peer route updates. */
6867 peer_on_policy_change(peer
, afi
, safi
,
6868 (direct
== FILTER_OUT
) ? 1 : 0);
6870 /* Skip peer-group mechanics for regular peers. */
6875 * Remove configuration on all peer-group members, unless they are
6876 * explicitly overriding peer-group configuration.
6878 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6879 /* Skip peers with overridden configuration. */
6880 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6881 PEER_FT_PREFIX_LIST
))
6884 /* Remove configuration on peer-group member. */
6885 filter
= &member
->filter
[afi
][safi
];
6886 if (filter
->plist
[direct
].name
)
6887 XFREE(MTYPE_BGP_FILTER_NAME
,
6888 filter
->plist
[direct
].name
);
6889 filter
->plist
[direct
].name
= NULL
;
6890 filter
->plist
[direct
].plist
= NULL
;
6892 /* Process peer route updates. */
6893 peer_on_policy_change(member
, afi
, safi
,
6894 (direct
== FILTER_OUT
) ? 1 : 0);
6900 /* Update prefix-list list. */
6901 static void peer_prefix_list_update(struct prefix_list
*plist
)
6903 struct listnode
*mnode
, *mnnode
;
6904 struct listnode
*node
, *nnode
;
6907 struct peer_group
*group
;
6908 struct bgp_filter
*filter
;
6913 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6916 * Update the prefix-list on update groups.
6918 update_group_policy_update(
6919 bgp
, BGP_POLICY_PREFIX_LIST
,
6920 plist
? prefix_list_name(plist
) : NULL
, true, 0);
6922 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6923 FOREACH_AFI_SAFI (afi
, safi
) {
6924 filter
= &peer
->filter
[afi
][safi
];
6926 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6928 if (filter
->plist
[direct
].name
)
6929 filter
->plist
[direct
]
6930 .plist
= prefix_list_lookup(
6932 filter
->plist
[direct
]
6935 filter
->plist
[direct
].plist
=
6939 /* If we touch prefix-list, we need to process
6940 * new updates. This is important for ORF to
6943 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6944 PEER_CAP_ORF_PREFIX_SM_ADV
) &&
6945 (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6946 PEER_CAP_ORF_PREFIX_RM_RCV
) ||
6948 peer
->af_cap
[afi
][safi
],
6949 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
6952 BGP_CLEAR_SOFT_IN_ORF_PREFIX
);
6955 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6956 FOREACH_AFI_SAFI (afi
, safi
) {
6957 filter
= &group
->conf
->filter
[afi
][safi
];
6959 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6961 if (filter
->plist
[direct
].name
)
6962 filter
->plist
[direct
]
6963 .plist
= prefix_list_lookup(
6965 filter
->plist
[direct
]
6968 filter
->plist
[direct
].plist
=
6976 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6979 struct peer
*member
;
6980 struct bgp_filter
*filter
;
6981 struct listnode
*node
, *nnode
;
6983 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6984 return BGP_ERR_INVALID_VALUE
;
6986 /* Set configuration on peer. */
6987 filter
= &peer
->filter
[afi
][safi
];
6988 if (filter
->aslist
[direct
].name
)
6989 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
6990 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6991 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6993 /* Check if handling a regular peer. */
6994 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6995 /* Set override-flag and process peer route updates. */
6996 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6997 PEER_FT_FILTER_LIST
);
6998 peer_on_policy_change(peer
, afi
, safi
,
6999 (direct
== FILTER_OUT
) ? 1 : 0);
7001 /* Skip peer-group mechanics for regular peers. */
7006 * Set configuration on all peer-group members, unless they are
7007 * explicitly overriding peer-group configuration.
7009 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7010 /* Skip peers with overridden configuration. */
7011 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7012 PEER_FT_FILTER_LIST
))
7015 /* Set configuration on peer-group member. */
7016 filter
= &member
->filter
[afi
][safi
];
7017 if (filter
->aslist
[direct
].name
)
7018 XFREE(MTYPE_BGP_FILTER_NAME
,
7019 filter
->aslist
[direct
].name
);
7020 filter
->aslist
[direct
].name
=
7021 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7022 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
7024 /* Process peer route updates. */
7025 peer_on_policy_change(member
, afi
, safi
,
7026 (direct
== FILTER_OUT
) ? 1 : 0);
7032 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
7034 struct peer
*member
;
7035 struct bgp_filter
*filter
;
7036 struct listnode
*node
, *nnode
;
7038 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
7039 return BGP_ERR_INVALID_VALUE
;
7041 /* Unset override-flag unconditionally. */
7042 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
7043 PEER_FT_FILTER_LIST
);
7045 /* Inherit configuration from peer-group if peer is member. */
7046 if (peer_group_active(peer
)) {
7047 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7048 filter
[afi
][safi
].aslist
[direct
].name
,
7049 MTYPE_BGP_FILTER_NAME
);
7050 PEER_ATTR_INHERIT(peer
, peer
->group
,
7051 filter
[afi
][safi
].aslist
[direct
].aslist
);
7053 /* Otherwise remove configuration from peer. */
7054 filter
= &peer
->filter
[afi
][safi
];
7055 if (filter
->aslist
[direct
].name
)
7056 XFREE(MTYPE_BGP_FILTER_NAME
,
7057 filter
->aslist
[direct
].name
);
7058 filter
->aslist
[direct
].name
= NULL
;
7059 filter
->aslist
[direct
].aslist
= NULL
;
7062 /* Check if handling a regular peer. */
7063 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7064 /* Process peer route updates. */
7065 peer_on_policy_change(peer
, afi
, safi
,
7066 (direct
== FILTER_OUT
) ? 1 : 0);
7068 /* Skip peer-group mechanics for regular peers. */
7073 * Remove configuration on all peer-group members, unless they are
7074 * explicitly overriding peer-group configuration.
7076 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7077 /* Skip peers with overridden configuration. */
7078 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7079 PEER_FT_FILTER_LIST
))
7082 /* Remove configuration on peer-group member. */
7083 filter
= &member
->filter
[afi
][safi
];
7084 if (filter
->aslist
[direct
].name
)
7085 XFREE(MTYPE_BGP_FILTER_NAME
,
7086 filter
->aslist
[direct
].name
);
7087 filter
->aslist
[direct
].name
= NULL
;
7088 filter
->aslist
[direct
].aslist
= NULL
;
7090 /* Process peer route updates. */
7091 peer_on_policy_change(member
, afi
, safi
,
7092 (direct
== FILTER_OUT
) ? 1 : 0);
7098 static void peer_aslist_update(const char *aslist_name
)
7103 struct listnode
*mnode
, *mnnode
;
7104 struct listnode
*node
, *nnode
;
7107 struct peer_group
*group
;
7108 struct bgp_filter
*filter
;
7110 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
7111 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
7112 aslist_name
, true, 0);
7114 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7115 FOREACH_AFI_SAFI (afi
, safi
) {
7116 filter
= &peer
->filter
[afi
][safi
];
7118 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7120 if (filter
->aslist
[direct
].name
)
7121 filter
->aslist
[direct
]
7122 .aslist
= as_list_lookup(
7123 filter
->aslist
[direct
]
7126 filter
->aslist
[direct
].aslist
=
7131 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
7132 FOREACH_AFI_SAFI (afi
, safi
) {
7133 filter
= &group
->conf
->filter
[afi
][safi
];
7135 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7137 if (filter
->aslist
[direct
].name
)
7138 filter
->aslist
[direct
]
7139 .aslist
= as_list_lookup(
7140 filter
->aslist
[direct
]
7143 filter
->aslist
[direct
].aslist
=
7151 static void peer_aslist_add(char *aslist_name
)
7153 peer_aslist_update(aslist_name
);
7154 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
7157 static void peer_aslist_del(const char *aslist_name
)
7159 peer_aslist_update(aslist_name
);
7160 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
7164 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
7165 const char *name
, struct route_map
*route_map
)
7167 struct peer
*member
;
7168 struct bgp_filter
*filter
;
7169 struct listnode
*node
, *nnode
;
7171 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7172 return BGP_ERR_INVALID_VALUE
;
7174 /* Set configuration on peer. */
7175 filter
= &peer
->filter
[afi
][safi
];
7176 if (filter
->map
[direct
].name
) {
7177 /* If the neighbor is configured with the same route-map
7178 * again then, ignore the duplicate configuration.
7180 if (strcmp(filter
->map
[direct
].name
, name
) == 0)
7183 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7185 route_map_counter_decrement(filter
->map
[direct
].map
);
7186 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7187 filter
->map
[direct
].map
= route_map
;
7188 route_map_counter_increment(route_map
);
7190 /* Check if handling a regular peer. */
7191 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7192 /* Set override-flag and process peer route updates. */
7193 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
7195 peer_on_policy_change(peer
, afi
, safi
,
7196 (direct
== RMAP_OUT
) ? 1 : 0);
7198 /* Skip peer-group mechanics for regular peers. */
7203 * Set configuration on all peer-group members, unless they are
7204 * explicitly overriding peer-group configuration.
7206 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7207 /* Skip peers with overridden configuration. */
7208 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7212 /* Set configuration on peer-group member. */
7213 filter
= &member
->filter
[afi
][safi
];
7214 if (filter
->map
[direct
].name
)
7215 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7216 route_map_counter_decrement(filter
->map
[direct
].map
);
7217 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7218 filter
->map
[direct
].map
= route_map
;
7219 route_map_counter_increment(route_map
);
7221 /* Process peer route updates. */
7222 peer_on_policy_change(member
, afi
, safi
,
7223 (direct
== RMAP_OUT
) ? 1 : 0);
7228 /* Unset route-map from the peer. */
7229 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
7231 struct peer
*member
;
7232 struct bgp_filter
*filter
;
7233 struct listnode
*node
, *nnode
;
7235 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7236 return BGP_ERR_INVALID_VALUE
;
7238 /* Unset override-flag unconditionally. */
7239 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
7241 /* Inherit configuration from peer-group if peer is member. */
7242 if (peer_group_active(peer
)) {
7243 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7244 filter
[afi
][safi
].map
[direct
].name
,
7245 MTYPE_BGP_FILTER_NAME
);
7246 PEER_ATTR_INHERIT(peer
, peer
->group
,
7247 filter
[afi
][safi
].map
[direct
].map
);
7249 /* Otherwise remove configuration from peer. */
7250 filter
= &peer
->filter
[afi
][safi
];
7251 if (filter
->map
[direct
].name
)
7252 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7253 route_map_counter_decrement(filter
->map
[direct
].map
);
7254 filter
->map
[direct
].name
= NULL
;
7255 filter
->map
[direct
].map
= NULL
;
7258 /* Check if handling a regular peer. */
7259 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7260 /* Process peer route updates. */
7261 peer_on_policy_change(peer
, afi
, safi
,
7262 (direct
== RMAP_OUT
) ? 1 : 0);
7264 /* Skip peer-group mechanics for regular peers. */
7269 * Remove configuration on all peer-group members, unless they are
7270 * explicitly overriding peer-group configuration.
7272 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7273 /* Skip peers with overridden configuration. */
7274 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7278 /* Remove configuration on peer-group member. */
7279 filter
= &member
->filter
[afi
][safi
];
7280 if (filter
->map
[direct
].name
)
7281 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7282 route_map_counter_decrement(filter
->map
[direct
].map
);
7283 filter
->map
[direct
].name
= NULL
;
7284 filter
->map
[direct
].map
= NULL
;
7286 /* Process peer route updates. */
7287 peer_on_policy_change(member
, afi
, safi
,
7288 (direct
== RMAP_OUT
) ? 1 : 0);
7294 /* Set unsuppress-map to the peer. */
7295 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7296 const char *name
, struct route_map
*route_map
)
7298 struct peer
*member
;
7299 struct bgp_filter
*filter
;
7300 struct listnode
*node
, *nnode
;
7302 /* Set configuration on peer. */
7303 filter
= &peer
->filter
[afi
][safi
];
7304 if (filter
->usmap
.name
)
7305 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7306 route_map_counter_decrement(filter
->usmap
.map
);
7307 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7308 filter
->usmap
.map
= route_map
;
7309 route_map_counter_increment(route_map
);
7311 /* Check if handling a regular peer. */
7312 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7313 /* Set override-flag and process peer route updates. */
7314 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
7315 PEER_FT_UNSUPPRESS_MAP
);
7316 peer_on_policy_change(peer
, afi
, safi
, 1);
7318 /* Skip peer-group mechanics for regular peers. */
7323 * Set configuration on all peer-group members, unless they are
7324 * explicitly overriding peer-group configuration.
7326 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7327 /* Skip peers with overridden configuration. */
7328 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7329 PEER_FT_UNSUPPRESS_MAP
))
7332 /* Set configuration on peer-group member. */
7333 filter
= &member
->filter
[afi
][safi
];
7334 if (filter
->usmap
.name
)
7335 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7336 route_map_counter_decrement(filter
->usmap
.map
);
7337 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7338 filter
->usmap
.map
= route_map
;
7339 route_map_counter_increment(route_map
);
7341 /* Process peer route updates. */
7342 peer_on_policy_change(member
, afi
, safi
, 1);
7348 /* Unset route-map from the peer. */
7349 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7351 struct peer
*member
;
7352 struct bgp_filter
*filter
;
7353 struct listnode
*node
, *nnode
;
7355 /* Unset override-flag unconditionally. */
7356 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
7358 /* Inherit configuration from peer-group if peer is member. */
7359 if (peer_group_active(peer
)) {
7360 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7361 filter
[afi
][safi
].usmap
.name
,
7362 MTYPE_BGP_FILTER_NAME
);
7363 PEER_ATTR_INHERIT(peer
, peer
->group
,
7364 filter
[afi
][safi
].usmap
.map
);
7366 /* Otherwise remove configuration from peer. */
7367 filter
= &peer
->filter
[afi
][safi
];
7368 if (filter
->usmap
.name
)
7369 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7370 route_map_counter_decrement(filter
->usmap
.map
);
7371 filter
->usmap
.name
= NULL
;
7372 filter
->usmap
.map
= NULL
;
7375 /* Check if handling a regular peer. */
7376 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7377 /* Process peer route updates. */
7378 peer_on_policy_change(peer
, afi
, safi
, 1);
7380 /* Skip peer-group mechanics for regular peers. */
7385 * Remove configuration on all peer-group members, unless they are
7386 * explicitly overriding peer-group configuration.
7388 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7389 /* Skip peers with overridden configuration. */
7390 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7391 PEER_FT_UNSUPPRESS_MAP
))
7394 /* Remove configuration on peer-group member. */
7395 filter
= &member
->filter
[afi
][safi
];
7396 if (filter
->usmap
.name
)
7397 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7398 route_map_counter_decrement(filter
->usmap
.map
);
7399 filter
->usmap
.name
= NULL
;
7400 filter
->usmap
.map
= NULL
;
7402 /* Process peer route updates. */
7403 peer_on_policy_change(member
, afi
, safi
, 1);
7409 static bool peer_maximum_prefix_clear_overflow(struct peer
*peer
)
7411 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
7414 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
7415 if (peer
->t_pmax_restart
) {
7416 EVENT_OFF(peer
->t_pmax_restart
);
7417 if (bgp_debug_neighbor_events(peer
))
7419 "%pBP Maximum-prefix restart timer cancelled",
7422 BGP_EVENT_ADD(peer
, BGP_Start
);
7426 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7427 uint32_t max
, uint8_t threshold
, int warning
,
7428 uint16_t restart
, bool force
)
7430 struct peer
*member
;
7431 struct listnode
*node
, *nnode
;
7433 /* Set flags and configuration on peer. */
7434 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7437 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7439 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7442 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7444 peer_af_flag_unset(peer
, afi
, safi
,
7445 PEER_FLAG_MAX_PREFIX_WARNING
);
7447 peer
->pmax
[afi
][safi
] = max
;
7448 peer
->pmax_threshold
[afi
][safi
] = threshold
;
7449 peer
->pmax_restart
[afi
][safi
] = restart
;
7451 /* Check if handling a regular peer. */
7452 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7453 /* Re-check if peer violates maximum-prefix. */
7454 if ((peer_established(peer
)) && (peer
->afc
[afi
][safi
]))
7455 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
7457 /* Skip peer-group mechanics for regular peers. */
7462 * Set flags and configuration on all peer-group members, unless they
7463 * are explicitly overriding peer-group configuration.
7465 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7466 /* Skip peers with overridden configuration. */
7467 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7468 PEER_FLAG_MAX_PREFIX
))
7471 /* Set flag and configuration on peer-group member. */
7472 member
->pmax
[afi
][safi
] = max
;
7473 member
->pmax_threshold
[afi
][safi
] = threshold
;
7474 member
->pmax_restart
[afi
][safi
] = restart
;
7477 SET_FLAG(member
->af_flags
[afi
][safi
],
7478 PEER_FLAG_MAX_PREFIX_FORCE
);
7480 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7481 PEER_FLAG_MAX_PREFIX_FORCE
);
7484 SET_FLAG(member
->af_flags
[afi
][safi
],
7485 PEER_FLAG_MAX_PREFIX_WARNING
);
7487 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7488 PEER_FLAG_MAX_PREFIX_WARNING
);
7490 /* Re-check if peer violates maximum-prefix. */
7491 if ((peer_established(member
)) && (member
->afc
[afi
][safi
]))
7492 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
7498 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7500 /* Inherit configuration from peer-group if peer is member. */
7501 if (peer_group_active(peer
)) {
7502 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7503 peer_af_flag_inherit(peer
, afi
, safi
,
7504 PEER_FLAG_MAX_PREFIX_FORCE
);
7505 peer_af_flag_inherit(peer
, afi
, safi
,
7506 PEER_FLAG_MAX_PREFIX_WARNING
);
7507 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
7508 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
7509 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
7514 /* Remove flags and configuration from peer. */
7515 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7516 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7517 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7518 peer
->pmax
[afi
][safi
] = 0;
7519 peer
->pmax_threshold
[afi
][safi
] = 0;
7520 peer
->pmax_restart
[afi
][safi
] = 0;
7523 * Remove flags and configuration from all peer-group members, unless
7524 * they are explicitly overriding peer-group configuration.
7526 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7527 struct peer
*member
;
7528 struct listnode
*node
;
7530 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7531 /* Skip peers with overridden configuration. */
7532 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7533 PEER_FLAG_MAX_PREFIX
))
7536 /* Remove flag and configuration on peer-group member.
7538 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7539 PEER_FLAG_MAX_PREFIX
);
7540 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7541 PEER_FLAG_MAX_PREFIX_FORCE
);
7542 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7543 PEER_FLAG_MAX_PREFIX_WARNING
);
7544 member
->pmax
[afi
][safi
] = 0;
7545 member
->pmax_threshold
[afi
][safi
] = 0;
7546 member
->pmax_restart
[afi
][safi
] = 0;
7548 peer_maximum_prefix_clear_overflow(member
);
7551 peer_maximum_prefix_clear_overflow(peer
);
7557 void peer_maximum_prefix_out_refresh_routes(struct peer
*peer
, afi_t afi
,
7560 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
7562 if (peer_established(peer
))
7563 bgp_announce_route(peer
, afi
, safi
, false);
7566 int peer_maximum_prefix_out_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7569 struct peer
*member
;
7570 struct listnode
*node
, *nnode
;
7572 /* Set flag on peer and peer-group member if any */
7573 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7574 /* Set configuration on peer. */
7575 peer
->pmax_out
[afi
][safi
] = max
;
7577 /* Check if handling a regular peer. */
7578 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7579 /* Skip peer-group mechanics for regular peers. */
7580 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7585 * Set flag and configuration on all peer-group members, unless they
7586 * are explicitly overriding peer-group configuration.
7588 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7589 /* Skip peers with overridden configuration. */
7590 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7591 PEER_FLAG_MAX_PREFIX_OUT
))
7594 /* Set configuration on peer-group member. */
7595 member
->pmax_out
[afi
][safi
] = max
;
7597 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7602 int peer_maximum_prefix_out_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7604 struct peer
*member
;
7605 struct listnode
*node
;
7606 /* Inherit configuration from peer-group if peer is member. */
7607 if (peer_group_active(peer
)) {
7608 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7609 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_out
[afi
][safi
]);
7611 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7615 /* Remove flag and configuration from peer. */
7616 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7617 peer
->pmax_out
[afi
][safi
] = 0;
7619 /* Check if handling a regular peer. */
7620 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7621 /* Skip peer-group mechanics for regular peers. */
7622 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7627 * Remove flag and configuration from all peer-group members, unless
7628 * they are explicitly overriding peer-group configuration.
7630 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7631 /* Skip peers with overridden configuration. */
7632 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7633 PEER_FLAG_MAX_PREFIX_OUT
))
7636 /* Remove flag and configuration on peer-group member.
7638 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7639 PEER_FLAG_MAX_PREFIX_OUT
);
7640 member
->pmax_out
[afi
][safi
] = 0;
7642 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7647 int is_ebgp_multihop_configured(struct peer
*peer
)
7649 struct peer_group
*group
;
7650 struct listnode
*node
, *nnode
;
7653 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7654 group
= peer
->group
;
7655 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7656 && (group
->conf
->ttl
!= BGP_DEFAULT_TTL
))
7659 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
7660 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
7661 && (peer1
->ttl
!= BGP_DEFAULT_TTL
))
7665 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7666 && (peer
->ttl
!= BGP_DEFAULT_TTL
))
7672 /* Set # of hops between us and BGP peer. */
7673 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
7675 struct peer_group
*group
;
7677 struct listnode
*node
, *nnode
;
7680 zlog_debug("%s: set gtsm_hops to %d for %s", __func__
, gtsm_hops
,
7683 /* We cannot configure ttl-security hops when ebgp-multihop is already
7684 set. For non peer-groups, the check is simple. For peer-groups,
7686 slightly messy, because we need to check both the peer-group
7688 and all peer-group members for any trace of ebgp-multihop
7690 before actually applying the ttl-security rules. Cisco really made a
7691 mess of this configuration parameter, and OpenBGPD got it right.
7694 if ((peer
->gtsm_hops
== BGP_GTSM_HOPS_DISABLED
)
7695 && (peer
->sort
!= BGP_PEER_IBGP
)) {
7696 if (is_ebgp_multihop_configured(peer
))
7697 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
7699 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7700 peer
->gtsm_hops
= gtsm_hops
;
7702 /* Calling ebgp multihop also resets the session.
7703 * On restart, NHT will get setup correctly as will the
7704 * min & max ttls on the socket. The return value is
7707 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
7712 group
= peer
->group
;
7713 group
->conf
->gtsm_hops
= gtsm_hops
;
7714 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7716 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7718 /* Calling ebgp multihop also resets the
7720 * On restart, NHT will get setup correctly as
7722 * min & max ttls on the socket. The return
7726 peer_ebgp_multihop_set(gpeer
, MAXTTL
);
7730 /* Post the first gtsm setup or if its ibgp, maxttl setting
7732 * necessary, just set the minttl.
7734 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7735 peer
->gtsm_hops
= gtsm_hops
;
7738 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7739 MAXTTL
+ 1 - gtsm_hops
);
7740 if ((peer
->status
< Established
) && peer
->doppelganger
7741 && (peer
->doppelganger
->fd
>= 0))
7742 sockopt_minttl(peer
->su
.sa
.sa_family
,
7743 peer
->doppelganger
->fd
,
7744 MAXTTL
+ 1 - gtsm_hops
);
7746 group
= peer
->group
;
7747 group
->conf
->gtsm_hops
= gtsm_hops
;
7748 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7750 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7752 /* Change setting of existing peer
7753 * established then change value (may break
7755 * not established yet (teardown session and
7757 * no session then do nothing (will get
7758 * handled by next connection)
7762 != BGP_GTSM_HOPS_DISABLED
)
7764 gpeer
->su
.sa
.sa_family
,
7766 MAXTTL
+ 1 - gpeer
->gtsm_hops
);
7767 if ((gpeer
->status
< Established
)
7768 && gpeer
->doppelganger
7769 && (gpeer
->doppelganger
->fd
>= 0))
7770 sockopt_minttl(gpeer
->su
.sa
.sa_family
,
7771 gpeer
->doppelganger
->fd
,
7772 MAXTTL
+ 1 - gtsm_hops
);
7780 int peer_ttl_security_hops_unset(struct peer
*peer
)
7782 struct peer_group
*group
;
7783 struct listnode
*node
, *nnode
;
7786 zlog_debug("%s: set gtsm_hops to zero for %s", __func__
, peer
->host
);
7788 /* if a peer-group member, then reset to peer-group default rather than
7790 if (peer_group_active(peer
))
7791 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
7793 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7795 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7796 /* Invoking ebgp_multihop_set will set the TTL back to the
7798 * value as well as restting the NHT and such. The session is
7801 if (peer
->sort
== BGP_PEER_EBGP
)
7802 ret
= peer_ebgp_multihop_unset(peer
);
7805 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7808 if ((peer
->status
< Established
) && peer
->doppelganger
7809 && (peer
->doppelganger
->fd
>= 0))
7810 sockopt_minttl(peer
->su
.sa
.sa_family
,
7811 peer
->doppelganger
->fd
, 0);
7814 group
= peer
->group
;
7815 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
7816 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7817 if (peer
->sort
== BGP_PEER_EBGP
)
7818 ret
= peer_ebgp_multihop_unset(peer
);
7821 sockopt_minttl(peer
->su
.sa
.sa_family
,
7824 if ((peer
->status
< Established
)
7825 && peer
->doppelganger
7826 && (peer
->doppelganger
->fd
>= 0))
7827 sockopt_minttl(peer
->su
.sa
.sa_family
,
7828 peer
->doppelganger
->fd
,
7837 static void peer_reset_message_stats(struct peer
*peer
)
7840 atomic_store_explicit(&peer
->open_in
, 0, memory_order_relaxed
);
7841 atomic_store_explicit(&peer
->open_out
, 0, memory_order_relaxed
);
7842 atomic_store_explicit(&peer
->update_in
, 0,
7843 memory_order_relaxed
);
7844 atomic_store_explicit(&peer
->update_out
, 0,
7845 memory_order_relaxed
);
7846 atomic_store_explicit(&peer
->keepalive_in
, 0,
7847 memory_order_relaxed
);
7848 atomic_store_explicit(&peer
->keepalive_out
, 0,
7849 memory_order_relaxed
);
7850 atomic_store_explicit(&peer
->notify_in
, 0,
7851 memory_order_relaxed
);
7852 atomic_store_explicit(&peer
->notify_out
, 0,
7853 memory_order_relaxed
);
7854 atomic_store_explicit(&peer
->refresh_in
, 0,
7855 memory_order_relaxed
);
7856 atomic_store_explicit(&peer
->refresh_out
, 0,
7857 memory_order_relaxed
);
7858 atomic_store_explicit(&peer
->dynamic_cap_in
, 0,
7859 memory_order_relaxed
);
7860 atomic_store_explicit(&peer
->dynamic_cap_out
, 0,
7861 memory_order_relaxed
);
7866 * If peer clear is invoked in a loop for all peers on the BGP instance,
7867 * it may end up freeing the doppelganger, and if this was the next node
7868 * to the current node, we would end up accessing the freed next node.
7869 * Pass along additional parameter which can be updated if next node
7870 * is freed; only required when walking the peer list on BGP instance.
7872 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
7874 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)
7875 || !CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_SHUTDOWN
)) {
7876 if (peer_maximum_prefix_clear_overflow(peer
))
7879 peer
->v_start
= BGP_INIT_START_TIMER
;
7880 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
7881 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7882 BGP_NOTIFY_CEASE_ADMIN_RESET
);
7884 bgp_session_reset_safe(peer
, nnode
);
7889 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
7890 enum bgp_clear_type stype
)
7892 struct peer_af
*paf
;
7894 if (!peer_established(peer
))
7897 if (!peer
->afc
[afi
][safi
])
7898 return BGP_ERR_AF_UNCONFIGURED
;
7900 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
7902 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
7903 /* Clear the "neighbor x.x.x.x default-originate" flag */
7904 paf
= peer_af_find(peer
, afi
, safi
);
7905 if (paf
&& paf
->subgroup
7906 && CHECK_FLAG(paf
->subgroup
->sflags
,
7907 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
7908 UNSET_FLAG(paf
->subgroup
->sflags
,
7909 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
7911 bgp_announce_route(peer
, afi
, safi
, false);
7914 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7915 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7916 PEER_CAP_ORF_PREFIX_SM_ADV
)
7917 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7918 PEER_CAP_ORF_PREFIX_RM_RCV
)
7919 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7920 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
7921 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
7922 uint8_t prefix_type
;
7924 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7925 PEER_CAP_ORF_PREFIX_RM_RCV
))
7926 prefix_type
= ORF_TYPE_PREFIX
;
7928 prefix_type
= ORF_TYPE_PREFIX_OLD
;
7930 if (filter
->plist
[FILTER_IN
].plist
) {
7931 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7932 PEER_STATUS_ORF_PREFIX_SEND
))
7933 bgp_route_refresh_send(
7934 peer
, afi
, safi
, prefix_type
,
7936 BGP_ROUTE_REFRESH_NORMAL
);
7937 bgp_route_refresh_send(
7938 peer
, afi
, safi
, prefix_type
,
7939 REFRESH_IMMEDIATE
, 0,
7940 BGP_ROUTE_REFRESH_NORMAL
);
7942 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7943 PEER_STATUS_ORF_PREFIX_SEND
))
7944 bgp_route_refresh_send(
7945 peer
, afi
, safi
, prefix_type
,
7946 REFRESH_IMMEDIATE
, 1,
7947 BGP_ROUTE_REFRESH_NORMAL
);
7949 bgp_route_refresh_send(
7950 peer
, afi
, safi
, 0, 0, 0,
7951 BGP_ROUTE_REFRESH_NORMAL
);
7957 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
7958 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7959 /* If neighbor has soft reconfiguration inbound flag.
7960 Use Adj-RIB-In database. */
7961 if (!bgp_soft_reconfig_in(peer
, afi
, safi
)) {
7962 /* If neighbor has route refresh capability, send route
7964 message to the peer. */
7965 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
7966 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
7967 bgp_route_refresh_send(
7968 peer
, afi
, safi
, 0, 0, 0,
7969 BGP_ROUTE_REFRESH_NORMAL
);
7971 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
7975 if (stype
== BGP_CLEAR_MESSAGE_STATS
)
7976 peer_reset_message_stats(peer
);
7981 /* Display peer uptime.*/
7982 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, bool use_json
,
7985 time_t uptime1
, epoch_tbuf
;
7988 /* If there is no connection has been done before print `never'. */
7991 json_object_string_add(json
, "peerUptime", "never");
7992 json_object_int_add(json
, "peerUptimeMsec", 0);
7994 snprintf(buf
, len
, "never");
7998 /* Get current time. */
7999 uptime1
= monotime(NULL
);
8001 gmtime_r(&uptime1
, &tm
);
8003 if (uptime1
< ONE_DAY_SECOND
)
8004 snprintf(buf
, len
, "%02d:%02d:%02d", tm
.tm_hour
, tm
.tm_min
,
8006 else if (uptime1
< ONE_WEEK_SECOND
)
8007 snprintf(buf
, len
, "%dd%02dh%02dm", tm
.tm_yday
, tm
.tm_hour
,
8009 else if (uptime1
< ONE_YEAR_SECOND
)
8010 snprintf(buf
, len
, "%02dw%dd%02dh", tm
.tm_yday
/ 7,
8011 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7), tm
.tm_hour
);
8013 snprintf(buf
, len
, "%02dy%02dw%dd", tm
.tm_year
- 70,
8015 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7));
8018 epoch_tbuf
= time(NULL
) - uptime1
;
8019 json_object_string_add(json
, "peerUptime", buf
);
8020 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
8021 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
8028 void bgp_master_init(struct event_loop
*master
, const int buffer_size
,
8029 struct list
*addresses
)
8033 memset(&bgp_master
, 0, sizeof(bgp_master
));
8036 bm
->bgp
= list_new();
8037 bm
->listen_sockets
= list_new();
8038 bm
->port
= BGP_PORT_DEFAULT
;
8039 bm
->addresses
= addresses
;
8040 bm
->master
= master
;
8041 bm
->start_time
= monotime(NULL
);
8042 bm
->t_rmap_update
= NULL
;
8043 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
8044 bm
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
8045 bm
->v_establish_wait
= BGP_UPDATE_DELAY_DEF
;
8046 bm
->terminating
= false;
8047 bm
->socket_buffer
= buffer_size
;
8048 bm
->wait_for_fib
= false;
8049 bm
->tcp_dscp
= IPTOS_PREC_INTERNETCONTROL
;
8050 bm
->inq_limit
= BM_DEFAULT_Q_LIMIT
;
8051 bm
->outq_limit
= BM_DEFAULT_Q_LIMIT
;
8054 /* init the rd id space.
8055 assign 0th index in the bitfield,
8056 so that we start with id 1
8058 bf_init(bm
->rd_idspace
, UINT16_MAX
);
8059 bf_assign_zero_index(bm
->rd_idspace
);
8061 /* mpls label dynamic allocation pool */
8062 bgp_lp_init(bm
->master
, &bm
->labelpool
);
8066 QOBJ_REG(bm
, bgp_master
);
8070 * Free up connected routes and interfaces for a BGP instance. Invoked upon
8071 * instance delete (non-default only) or BGP exit.
8073 static void bgp_if_finish(struct bgp
*bgp
)
8076 struct interface
*ifp
;
8078 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
8080 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
8083 FOR_ALL_INTERFACES (vrf
, ifp
) {
8084 struct listnode
*c_node
, *c_nnode
;
8085 struct connected
*c
;
8087 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
8088 bgp_connected_delete(bgp
, c
);
8092 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
8094 struct vrf
*vrf
= NULL
;
8095 struct listnode
*next
;
8098 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
8099 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
8101 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8102 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
8105 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
8109 static void bgp_instasn_autocomplete(vector comps
, struct cmd_token
*token
)
8111 struct listnode
*next
, *next2
;
8112 struct bgp
*bgp
, *bgp2
;
8113 char buf
[ASN_STRING_MAX_SIZE
];
8115 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8117 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next2
, bgp2
)) {
8118 if (bgp2
->as
== bgp
->as
)
8126 snprintf(buf
, sizeof(buf
), "%s", bgp
->as_pretty
);
8127 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, buf
));
8131 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
8132 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
8133 {.varname
= "instasn", .completions
= bgp_instasn_autocomplete
},
8134 {.completions
= NULL
},
8137 struct frr_pthread
*bgp_pth_io
;
8138 struct frr_pthread
*bgp_pth_ka
;
8140 static void bgp_pthreads_init(void)
8142 assert(!bgp_pth_io
);
8143 assert(!bgp_pth_ka
);
8145 struct frr_pthread_attr io
= {
8146 .start
= frr_pthread_attr_default
.start
,
8147 .stop
= frr_pthread_attr_default
.stop
,
8149 struct frr_pthread_attr ka
= {
8150 .start
= bgp_keepalives_start
,
8151 .stop
= bgp_keepalives_stop
,
8153 bgp_pth_io
= frr_pthread_new(&io
, "BGP I/O thread", "bgpd_io");
8154 bgp_pth_ka
= frr_pthread_new(&ka
, "BGP Keepalives thread", "bgpd_ka");
8157 void bgp_pthreads_run(void)
8159 frr_pthread_run(bgp_pth_io
, NULL
);
8160 frr_pthread_run(bgp_pth_ka
, NULL
);
8162 /* Wait until threads are ready. */
8163 frr_pthread_wait_running(bgp_pth_io
);
8164 frr_pthread_wait_running(bgp_pth_ka
);
8167 void bgp_pthreads_finish(void)
8169 frr_pthread_stop_all();
8172 static int peer_unshut_after_cfg(struct bgp
*bgp
)
8174 struct listnode
*node
;
8177 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
8178 if (!peer
->shut_during_cfg
)
8181 if (bgp_debug_neighbor_events(peer
))
8182 zlog_debug("%s: released from config-pending hold",
8185 peer
->shut_during_cfg
= false;
8186 if (peer_active(peer
) && peer
->status
!= Established
) {
8187 if (peer
->status
!= Idle
)
8188 BGP_EVENT_ADD(peer
, BGP_Stop
);
8189 BGP_EVENT_ADD(peer
, BGP_Start
);
8196 void bgp_init(unsigned short instance
)
8198 hook_register(bgp_config_end
, peer_unshut_after_cfg
);
8200 /* allocates some vital data structures used by peer commands in
8203 /* pre-init pthreads */
8204 bgp_pthreads_init();
8207 bgp_zebra_init(bm
->master
, instance
);
8209 #ifdef ENABLE_BGP_VNC
8210 vnc_zebra_init(bm
->master
);
8213 /* BGP VTY commands installation. */
8219 bgp_community_alias_init();
8222 bgp_route_map_init();
8223 bgp_scan_vty_init();
8225 #ifdef ENABLE_BGP_VNC
8228 bgp_ethernetvpn_init();
8229 bgp_flowspec_vty_init();
8231 /* Access list initialize. */
8233 access_list_add_hook(peer_distribute_update
);
8234 access_list_delete_hook(peer_distribute_update
);
8236 /* Filter list initialize. */
8238 as_list_add_hook(peer_aslist_add
);
8239 as_list_delete_hook(peer_aslist_del
);
8241 /* Prefix list initialize.*/
8243 prefix_list_add_hook(peer_prefix_list_update
);
8244 prefix_list_delete_hook(peer_prefix_list_update
);
8246 /* Community list initialize. */
8247 bgp_clist
= community_list_init();
8250 bgp_bfd_init(bm
->master
);
8254 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
8257 void bgp_terminate(void)
8261 struct listnode
*node
, *nnode
;
8262 struct listnode
*mnode
, *mnnode
;
8266 /* Close the listener sockets first as this prevents peers from
8268 * to reconnect on receiving the peer unconfig message. In the presence
8269 * of a large number of peers this will ensure that no peer is left with
8270 * a dangling connection
8274 /* reverse bgp_master_init */
8275 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
8276 bgp_close_vrf_socket(bgp
);
8277 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8278 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
8279 if (bgp_debug_neighbor_events(peer
))
8281 "%pBP configured Graceful-Restart, skipping unconfig notification",
8285 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
8286 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
8287 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
8291 if (bm
->listen_sockets
)
8292 list_delete(&bm
->listen_sockets
);
8294 EVENT_OFF(bm
->t_rmap_update
);
8299 struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
8300 const char *ip_str
, bool use_json
)
8306 /* Get peer sockunion. */
8307 ret
= str2sockunion(ip_str
, &su
);
8309 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
8311 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
8315 json_object
*json_no
= NULL
;
8316 json_no
= json_object_new_object();
8317 json_object_string_add(
8319 "malformedAddressOrName",
8321 vty_json(vty
, json_no
);
8324 "%% Malformed address or name: %s\n",
8332 /* Peer structure lookup. */
8333 peer
= peer_lookup(bgp
, &su
);
8336 json_object
*json_no
= NULL
;
8337 json_no
= json_object_new_object();
8338 json_object_string_add(json_no
, "warning",
8339 "No such neighbor in this view/vrf");
8340 vty_json(vty
, json_no
);
8342 vty_out(vty
, "No such neighbor in this view/vrf\n");
8349 void bgp_gr_apply_running_config(void)
8351 struct peer
*peer
= NULL
;
8352 struct bgp
*bgp
= NULL
;
8353 struct listnode
*node
, *nnode
;
8354 bool gr_router_detected
= false;
8356 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
8357 zlog_debug("[BGP_GR] %s called !", __func__
);
8359 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
8360 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8361 bgp_peer_gr_flags_update(peer
);
8362 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
))
8363 gr_router_detected
= true;
8366 if (gr_router_detected
8367 && bgp
->present_zebra_gr_state
== ZEBRA_GR_DISABLE
) {
8368 bgp_zebra_send_capabilities(bgp
, true);
8369 } else if (!gr_router_detected
8370 && bgp
->present_zebra_gr_state
== ZEBRA_GR_ENABLE
) {
8371 bgp_zebra_send_capabilities(bgp
, false);
8374 gr_router_detected
= false;
8378 printfrr_ext_autoreg_p("BP", printfrr_bp
);
8379 static ssize_t
printfrr_bp(struct fbuf
*buf
, struct printfrr_eargs
*ea
,
8382 const struct peer
*peer
= ptr
;
8385 return bputs(buf
, "(null)");
8387 return bprintfrr(buf
, "%s(%s)", peer
->host
,
8388 peer
->hostname
? peer
->hostname
: "Unknown");