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 thread_cancel_event_ready(bm
->master
, peer
);
1130 FOREACH_AFI_SAFI (afi
, safi
)
1131 THREAD_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
&& !peer_dst
->password
)
1500 peer_dst
->password
=
1501 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1503 FOREACH_AFI_SAFI (afi
, safi
) {
1504 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1505 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1506 peer_dst
->allowas_in
[afi
][safi
] =
1507 peer_src
->allowas_in
[afi
][safi
];
1508 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1509 peer_dst
->addpath_type
[afi
][safi
] =
1510 peer_src
->addpath_type
[afi
][safi
];
1513 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1514 paf
= peer_src
->peer_af_array
[afidx
];
1516 if (!peer_af_find(peer_dst
, paf
->afi
, paf
->safi
))
1517 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1521 /* update-source apply */
1522 if (peer_src
->update_source
) {
1523 if (peer_dst
->update_source
)
1524 sockunion_free(peer_dst
->update_source
);
1525 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1526 peer_dst
->update_source
=
1527 sockunion_dup(peer_src
->update_source
);
1528 } else if (peer_src
->update_if
) {
1529 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1530 if (peer_dst
->update_source
) {
1531 sockunion_free(peer_dst
->update_source
);
1532 peer_dst
->update_source
= NULL
;
1534 peer_dst
->update_if
=
1535 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1538 if (peer_src
->ifname
) {
1539 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1542 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1546 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1547 struct interface
*ifp
)
1549 struct connected
*ifc
;
1552 struct listnode
*node
;
1554 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1555 * IPv4 address of the other end.
1557 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1558 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1559 prefix_copy(&p
, CONNECTED_PREFIX(ifc
));
1560 if (p
.prefixlen
== 30) {
1561 peer
->su
.sa
.sa_family
= AF_INET
;
1562 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1564 peer
->su
.sin
.sin_addr
.s_addr
=
1566 else if (addr
% 4 == 2)
1567 peer
->su
.sin
.sin_addr
.s_addr
=
1569 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1570 peer
->su
.sin
.sin_len
=
1571 sizeof(struct sockaddr_in
);
1572 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1574 } else if (p
.prefixlen
== 31) {
1575 peer
->su
.sa
.sa_family
= AF_INET
;
1576 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1578 peer
->su
.sin
.sin_addr
.s_addr
=
1581 peer
->su
.sin
.sin_addr
.s_addr
=
1583 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1584 peer
->su
.sin
.sin_len
=
1585 sizeof(struct sockaddr_in
);
1586 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1588 } else if (bgp_debug_neighbor_events(peer
))
1590 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1598 static bool bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1599 struct interface
*ifp
)
1601 struct nbr_connected
*ifc_nbr
;
1603 /* Have we learnt the peer's IPv6 link-local address? */
1604 if (ifp
->nbr_connected
1605 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1606 peer
->su
.sa
.sa_family
= AF_INET6
;
1607 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1608 sizeof(struct in6_addr
));
1610 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1612 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1620 * Set or reset the peer address socketunion structure based on the
1621 * learnt/derived peer address. If the address has changed, update the
1622 * password on the listen socket, if needed.
1624 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1626 struct interface
*ifp
;
1628 int peer_addr_updated
= 0;
1629 struct listnode
*node
;
1630 union sockunion old_su
;
1633 * This function is only ever needed when FRR an interface
1634 * based peering, so this simple test will tell us if
1635 * we are in an interface based configuration or not
1642 prev_family
= peer
->su
.sa
.sa_family
;
1643 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1645 /* If BGP unnumbered is not "v6only", we first see if we can
1647 * peer's IPv4 address.
1649 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1651 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1653 /* If "v6only" or we can't derive peer's IPv4 address, see if
1655 * learnt the peer's IPv6 link-local address. This is from the
1657 * IPv6 address in router advertisement.
1659 if (!peer_addr_updated
)
1661 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1663 /* If we could derive the peer address, we may need to install the
1665 * configured for the peer, if any, on the listen socket. Otherwise,
1667 * that peer's address is not available and uninstall the password, if
1670 if (peer_addr_updated
) {
1671 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1672 && prev_family
== AF_UNSPEC
)
1675 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1676 && prev_family
!= AF_UNSPEC
)
1677 bgp_md5_unset(peer
);
1678 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1679 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1683 * If they are the same, nothing to do here, move along
1685 if (!sockunion_same(&old_su
, &peer
->su
)) {
1686 union sockunion new_su
= peer
->su
;
1687 struct bgp
*bgp
= peer
->bgp
;
1690 * Our peer structure is stored in the bgp->peerhash
1691 * release it before we modify anything in both the
1692 * hash and the list. But *only* if the peer
1693 * is in the bgp->peerhash as that on deletion
1694 * we call bgp_stop which calls this function :(
1695 * so on deletion let's remove from the list first
1696 * and then do the deletion preventing this from
1697 * being added back on the list below when we
1698 * fail to remove it up here.
1702 * listnode_lookup just scans the list
1703 * for the peer structure so it's safe
1704 * to use without modifying the su
1706 node
= listnode_lookup(bgp
->peer
, peer
);
1709 * Let's reset the peer->su release and
1710 * reset it and put it back. We have to
1711 * do this because hash_release will
1712 * scan through looking for a matching
1716 hash_release(peer
->bgp
->peerhash
, peer
);
1717 listnode_delete(peer
->bgp
->peer
, peer
);
1720 (void)hash_get(peer
->bgp
->peerhash
, peer
,
1722 listnode_add_sort(peer
->bgp
->peer
, peer
);
1727 void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1729 struct bgp_dest
*dest
, *ndest
;
1730 struct bgp_table
*table
;
1732 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
1733 dest
= bgp_route_next(dest
)) {
1734 table
= bgp_dest_get_bgp_table_info(dest
);
1735 if (table
!= NULL
) {
1736 /* Special handling for 2-level routing
1738 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1739 || safi
== SAFI_EVPN
) {
1740 for (ndest
= bgp_table_top(table
); ndest
;
1741 ndest
= bgp_route_next(ndest
))
1742 bgp_process(bgp
, ndest
, afi
, safi
);
1744 bgp_process(bgp
, dest
, afi
, safi
);
1749 /* Force a bestpath recalculation for all prefixes. This is used
1750 * when 'bgp bestpath' commands are entered.
1752 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1757 FOREACH_AFI_SAFI (afi
, safi
) {
1758 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1763 * Create new BGP peer.
1765 * conf_if and su are mutually exclusive if configuring from the cli.
1766 * If we are handing a doppelganger, then we *must* pass in both
1767 * the original peer's su and conf_if, so that we can appropriately
1768 * track the bgp->peerhash( ie we don't want to remove the current
1769 * one from the config ).
1771 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1772 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1773 int as_type
, struct peer_group
*group
,
1774 bool config_node
, const char *as_str
)
1778 char buf
[SU_ADDRSTRLEN
];
1782 peer
= peer_new(bgp
);
1784 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1788 bgp_peer_conf_if_to_su_update(peer
);
1789 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1790 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1793 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1794 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1795 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1797 peer
->local_as
= local_as
;
1798 peer
->as
= remote_as
;
1799 /* internal and external values do not use as_pretty */
1800 if (as_str
&& asn_str2asn(as_str
, NULL
))
1801 peer
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
1802 peer
->as_type
= as_type
;
1803 peer
->local_id
= bgp
->router_id
;
1804 peer
->v_holdtime
= bgp
->default_holdtime
;
1805 peer
->v_keepalive
= bgp
->default_keepalive
;
1806 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1807 ? BGP_DEFAULT_IBGP_ROUTEADV
1808 : BGP_DEFAULT_EBGP_ROUTEADV
;
1809 if (bgp_config_inprocess())
1810 peer
->shut_during_cfg
= true;
1812 peer
= peer_lock(peer
); /* bgp peer list reference */
1813 peer
->group
= group
;
1814 listnode_add_sort(bgp
->peer
, peer
);
1817 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1819 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1821 /* Adjust update-group coalesce timer heuristics for # peers. */
1822 if (bgp
->heuristic_coalesce
) {
1823 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1825 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1826 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1829 active
= peer_active(peer
);
1831 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
)
1832 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1834 peer
->last_reset
= PEER_DOWN_NOAFI_ACTIVATED
;
1837 /* Last read and reset time set */
1838 peer
->readtime
= peer
->resettime
= monotime(NULL
);
1840 /* Default TTL set. */
1841 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: BGP_DEFAULT_TTL
;
1843 /* Default configured keepalives count for shutdown rtt command */
1844 peer
->rtt_keepalive_conf
= 1;
1846 /* If 'bgp default <afi>-<safi>' is configured, then activate the
1847 * neighbor for the corresponding address family. IPv4 Unicast is
1848 * the only address family enabled by default without expliict
1851 FOREACH_AFI_SAFI (afi
, safi
) {
1852 if (bgp
->default_af
[afi
][safi
]) {
1853 peer
->afc
[afi
][safi
] = 1;
1854 peer_af_create(peer
, afi
, safi
);
1858 /* auto shutdown if configured */
1859 if (bgp
->autoshutdown
)
1860 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1861 /* Set up peer's events and timers. */
1862 else if (!active
&& peer_active(peer
))
1863 bgp_timer_set(peer
);
1865 bgp_peer_gr_flags_update(peer
);
1866 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp
, bgp
->peer
);
1871 /* Make accept BGP peer. This function is only called from the test code */
1872 struct peer
*peer_create_accept(struct bgp
*bgp
)
1876 peer
= peer_new(bgp
);
1878 peer
= peer_lock(peer
); /* bgp peer list reference */
1879 listnode_add_sort(bgp
->peer
, peer
);
1880 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1886 * Return true if we have a peer configured to use this afi/safi
1888 bool bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1890 struct listnode
*node
;
1893 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1894 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1897 if (peer
->afc
[afi
][safi
])
1904 /* Change peer's AS number. */
1905 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
,
1908 enum bgp_peer_sort origtype
, newtype
;
1911 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1912 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1913 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1914 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1915 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1917 bgp_session_reset(peer
);
1919 origtype
= peer_sort_lookup(peer
);
1921 if (as_specified
== AS_SPECIFIED
&& as_str
) {
1922 if (peer
->as_pretty
)
1923 XFREE(MTYPE_BGP
, peer
->as_pretty
);
1924 peer
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
1925 } else if (peer
->as_type
== AS_UNSPECIFIED
&& peer
->as_pretty
)
1926 XFREE(MTYPE_BGP
, peer
->as_pretty
);
1927 peer
->as_type
= as_specified
;
1929 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1930 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1931 && peer
->bgp
->as
!= as
)
1932 peer
->local_as
= peer
->bgp
->confed_id
;
1934 peer
->local_as
= peer
->bgp
->as
;
1936 newtype
= peer_sort(peer
);
1937 /* Advertisement-interval reset */
1938 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1939 peer
->v_routeadv
= (newtype
== BGP_PEER_IBGP
)
1940 ? BGP_DEFAULT_IBGP_ROUTEADV
1941 : BGP_DEFAULT_EBGP_ROUTEADV
;
1945 if (newtype
== BGP_PEER_IBGP
)
1947 else if (origtype
== BGP_PEER_IBGP
)
1948 peer
->ttl
= BGP_DEFAULT_TTL
;
1950 /* reflector-client reset */
1951 if (newtype
!= BGP_PEER_IBGP
) {
1952 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1953 PEER_FLAG_REFLECTOR_CLIENT
);
1954 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1955 PEER_FLAG_REFLECTOR_CLIENT
);
1956 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1957 PEER_FLAG_REFLECTOR_CLIENT
);
1958 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1959 PEER_FLAG_REFLECTOR_CLIENT
);
1960 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1961 PEER_FLAG_REFLECTOR_CLIENT
);
1962 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1963 PEER_FLAG_REFLECTOR_CLIENT
);
1964 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1965 PEER_FLAG_REFLECTOR_CLIENT
);
1966 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1967 PEER_FLAG_REFLECTOR_CLIENT
);
1968 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1969 PEER_FLAG_REFLECTOR_CLIENT
);
1970 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1971 PEER_FLAG_REFLECTOR_CLIENT
);
1972 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1973 PEER_FLAG_REFLECTOR_CLIENT
);
1974 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1975 PEER_FLAG_REFLECTOR_CLIENT
);
1976 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1977 PEER_FLAG_REFLECTOR_CLIENT
);
1981 /* If peer does not exist, create new one. If peer already exists,
1982 set AS number to the peer. */
1983 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1984 as_t
*as
, int as_type
, const char *as_str
)
1990 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1992 peer
= peer_lookup(bgp
, su
);
1995 /* Not allowed for a dynamic peer. */
1996 if (peer_dynamic_neighbor(peer
)) {
1998 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
2001 /* When this peer is a member of peer-group. */
2003 /* peer-group already has AS number/internal/external */
2004 if (peer
->group
->conf
->as
2005 || peer
->group
->conf
->as_type
) {
2006 /* Return peer group's AS number. */
2007 *as
= peer
->group
->conf
->as
;
2008 return BGP_ERR_PEER_GROUP_MEMBER
;
2011 enum bgp_peer_sort peer_sort_type
=
2012 peer_sort(peer
->group
->conf
);
2014 /* Explicit AS numbers used, compare AS numbers */
2015 if (as_type
== AS_SPECIFIED
) {
2016 if (((peer_sort_type
== BGP_PEER_IBGP
)
2017 && (bgp
->as
!= *as
))
2018 || ((peer_sort_type
== BGP_PEER_EBGP
)
2019 && (bgp
->as
== *as
))) {
2021 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2024 /* internal/external used, compare as-types */
2025 if (((peer_sort_type
== BGP_PEER_IBGP
)
2026 && (as_type
!= AS_INTERNAL
))
2027 || ((peer_sort_type
== BGP_PEER_EBGP
)
2028 && (as_type
!= AS_EXTERNAL
))) {
2030 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2035 /* Existing peer's AS number change. */
2036 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2037 || (peer
->as_type
!= as_type
))
2038 peer_as_change(peer
, *as
, as_type
, as_str
);
2041 return BGP_ERR_NO_INTERFACE_CONFIG
;
2043 /* If the peer is not part of our confederation, and its not an
2044 iBGP peer then spoof the source AS */
2045 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
) &&
2046 !bgp_confederation_peers_check(bgp
, *as
) && *as
&&
2048 local_as
= bgp
->confed_id
;
2052 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, NULL
,
2059 const char *bgp_get_name_by_role(uint8_t role
)
2064 case ROLE_RS_SERVER
:
2066 case ROLE_RS_CLIENT
:
2072 case ROLE_UNDEFINED
:
2078 enum asnotation_mode
bgp_get_asnotation(struct bgp
*bgp
)
2081 return ASNOTATION_PLAIN
;
2082 return bgp
->asnotation
;
2085 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
2086 struct peer
*peer
, afi_t afi
,
2090 int out
= FILTER_OUT
;
2092 uint64_t pflags_ovrd
;
2093 uint8_t *pfilter_ovrd
;
2097 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
2098 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
2100 /* peer af_flags apply */
2101 flags_tmp
= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
2102 flags_tmp
^= conf
->af_flags_invert
[afi
][safi
]
2103 ^ peer
->af_flags_invert
[afi
][safi
];
2104 flags_tmp
&= ~pflags_ovrd
;
2106 UNSET_FLAG(peer
->af_flags
[afi
][safi
], ~pflags_ovrd
);
2107 SET_FLAG(peer
->af_flags
[afi
][safi
], flags_tmp
);
2108 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
2109 conf
->af_flags_invert
[afi
][safi
]);
2111 /* maximum-prefix */
2112 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
2113 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
2114 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
2115 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
2118 /* maximum-prefix-out */
2119 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX_OUT
))
2120 PEER_ATTR_INHERIT(peer
, group
, pmax_out
[afi
][safi
]);
2123 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
2124 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
2127 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_SOO
))
2128 PEER_ATTR_INHERIT(peer
, group
, soo
[afi
][safi
]);
2131 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
2132 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
2134 /* default-originate route-map */
2135 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
2136 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
2137 MTYPE_ROUTE_MAP_NAME
);
2138 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
2141 /* inbound filter apply */
2142 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
2143 PEER_STR_ATTR_INHERIT(peer
, group
,
2144 filter
[afi
][safi
].dlist
[in
].name
,
2145 MTYPE_BGP_FILTER_NAME
);
2146 PEER_ATTR_INHERIT(peer
, group
,
2147 filter
[afi
][safi
].dlist
[in
].alist
);
2150 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
2151 PEER_STR_ATTR_INHERIT(peer
, group
,
2152 filter
[afi
][safi
].plist
[in
].name
,
2153 MTYPE_BGP_FILTER_NAME
);
2154 PEER_ATTR_INHERIT(peer
, group
,
2155 filter
[afi
][safi
].plist
[in
].plist
);
2158 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
2159 PEER_STR_ATTR_INHERIT(peer
, group
,
2160 filter
[afi
][safi
].aslist
[in
].name
,
2161 MTYPE_BGP_FILTER_NAME
);
2162 PEER_ATTR_INHERIT(peer
, group
,
2163 filter
[afi
][safi
].aslist
[in
].aslist
);
2166 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
2167 PEER_STR_ATTR_INHERIT(peer
, group
,
2168 filter
[afi
][safi
].map
[in
].name
,
2169 MTYPE_BGP_FILTER_NAME
);
2170 PEER_ATTR_INHERIT(peer
, group
,
2171 filter
[afi
][safi
].map
[RMAP_IN
].map
);
2174 /* outbound filter apply */
2175 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
2176 PEER_STR_ATTR_INHERIT(peer
, group
,
2177 filter
[afi
][safi
].dlist
[out
].name
,
2178 MTYPE_BGP_FILTER_NAME
);
2179 PEER_ATTR_INHERIT(peer
, group
,
2180 filter
[afi
][safi
].dlist
[out
].alist
);
2183 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
2184 PEER_STR_ATTR_INHERIT(peer
, group
,
2185 filter
[afi
][safi
].plist
[out
].name
,
2186 MTYPE_BGP_FILTER_NAME
);
2187 PEER_ATTR_INHERIT(peer
, group
,
2188 filter
[afi
][safi
].plist
[out
].plist
);
2191 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
2192 PEER_STR_ATTR_INHERIT(peer
, group
,
2193 filter
[afi
][safi
].aslist
[out
].name
,
2194 MTYPE_BGP_FILTER_NAME
);
2195 PEER_ATTR_INHERIT(peer
, group
,
2196 filter
[afi
][safi
].aslist
[out
].aslist
);
2199 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
2200 PEER_STR_ATTR_INHERIT(peer
, group
,
2201 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
2202 MTYPE_BGP_FILTER_NAME
);
2203 PEER_ATTR_INHERIT(peer
, group
,
2204 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
2207 /* nondirectional filter apply */
2208 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
2209 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
2210 MTYPE_BGP_FILTER_NAME
);
2211 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
2214 /* Conditional Advertisements */
2215 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ADVERTISE_MAP
)) {
2216 PEER_STR_ATTR_INHERIT(peer
, group
,
2217 filter
[afi
][safi
].advmap
.aname
,
2218 MTYPE_BGP_FILTER_NAME
);
2219 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.amap
);
2220 PEER_STR_ATTR_INHERIT(peer
, group
,
2221 filter
[afi
][safi
].advmap
.cname
,
2222 MTYPE_BGP_FILTER_NAME
);
2223 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.cmap
);
2224 PEER_ATTR_INHERIT(peer
, group
,
2225 filter
[afi
][safi
].advmap
.condition
);
2228 if (peer
->addpath_type
[afi
][safi
] == BGP_ADDPATH_NONE
) {
2229 peer
->addpath_type
[afi
][safi
] = conf
->addpath_type
[afi
][safi
];
2230 bgp_addpath_type_changed(conf
->bgp
);
2234 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
2239 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2240 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2241 __func__
, peer
->host
);
2245 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
2247 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2248 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
2249 return BGP_ERR_PEER_SAFI_CONFLICT
;
2251 /* Nothing to do if we've already activated this peer */
2252 if (peer
->afc
[afi
][safi
])
2255 if (peer_af_create(peer
, afi
, safi
) == NULL
)
2258 active
= peer_active(peer
);
2259 peer
->afc
[afi
][safi
] = 1;
2262 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
2264 if (!active
&& peer_active(peer
)) {
2265 bgp_timer_set(peer
);
2267 if (peer_established(peer
)) {
2268 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2269 peer
->afc_adv
[afi
][safi
] = 1;
2270 bgp_capability_send(peer
, afi
, safi
,
2272 CAPABILITY_ACTION_SET
);
2273 if (peer
->afc_recv
[afi
][safi
]) {
2274 peer
->afc_nego
[afi
][safi
] = 1;
2275 bgp_announce_route(peer
, afi
, safi
,
2279 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2280 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2281 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2284 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
2285 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2286 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2287 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2290 * If we are turning on a AFI/SAFI locally and we've
2291 * started bringing a peer up, we need to tell
2292 * the other peer to restart because we might loose
2293 * configuration here because when the doppelganger
2294 * gets to a established state due to how
2295 * we resolve we could just overwrite the afi/safi
2298 other
= peer
->doppelganger
;
2300 && (other
->status
== OpenSent
2301 || other
->status
== OpenConfirm
)) {
2302 other
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2303 bgp_notify_send(other
, BGP_NOTIFY_CEASE
,
2304 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2311 /* Activate the peer or peer group for specified AFI and SAFI. */
2312 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2315 struct peer_group
*group
;
2316 struct listnode
*node
, *nnode
;
2317 struct peer
*tmp_peer
;
2320 /* Nothing to do if we've already activated this peer */
2321 if (peer
->afc
[afi
][safi
])
2326 /* This is a peer-group so activate all of the members of the
2327 * peer-group as well */
2328 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2330 /* Do not activate a peer for both SAFI_UNICAST and
2331 * SAFI_LABELED_UNICAST */
2332 if ((safi
== SAFI_UNICAST
2333 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2334 || (safi
== SAFI_LABELED_UNICAST
2335 && peer
->afc
[afi
][SAFI_UNICAST
]))
2336 return BGP_ERR_PEER_SAFI_CONFLICT
;
2338 peer
->afc
[afi
][safi
] = 1;
2339 group
= peer
->group
;
2341 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2342 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2345 ret
|= peer_activate_af(peer
, afi
, safi
);
2348 /* If this is the first peer to be activated for this
2349 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2350 if (ret
!= BGP_ERR_PEER_SAFI_CONFLICT
&& safi
== SAFI_LABELED_UNICAST
2351 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2353 if (BGP_DEBUG(zebra
, ZEBRA
))
2355 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2357 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2358 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2361 if (safi
== SAFI_FLOWSPEC
) {
2362 /* connect to table manager */
2363 bgp_zebra_init_tm_connect(bgp
);
2368 static bool non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2371 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2372 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2373 __func__
, peer
->host
);
2377 /* Nothing to do if we've already deactivated this peer */
2378 if (!peer
->afc
[afi
][safi
])
2381 /* De-activate the address family configuration. */
2382 peer
->afc
[afi
][safi
] = 0;
2384 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2385 flog_err(EC_BGP_PEER_DELETE
,
2386 "couldn't delete af structure for peer %s(%s, %s)",
2387 peer
->host
, afi2str(afi
), safi2str(safi
));
2391 if (peer_established(peer
)) {
2392 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2393 peer
->afc_adv
[afi
][safi
] = 0;
2394 peer
->afc_nego
[afi
][safi
] = 0;
2396 if (peer_active_nego(peer
)) {
2397 bgp_capability_send(peer
, afi
, safi
,
2399 CAPABILITY_ACTION_UNSET
);
2400 bgp_clear_route(peer
, afi
, safi
);
2401 peer
->pcount
[afi
][safi
] = 0;
2403 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2404 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2405 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2408 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2409 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2410 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2417 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2420 struct peer_group
*group
;
2421 struct peer
*tmp_peer
;
2422 struct listnode
*node
, *nnode
;
2425 /* Nothing to do if we've already de-activated this peer */
2426 if (!peer
->afc
[afi
][safi
])
2429 /* This is a peer-group so de-activate all of the members of the
2430 * peer-group as well */
2431 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2432 peer
->afc
[afi
][safi
] = 0;
2433 group
= peer
->group
;
2435 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2436 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2439 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2444 /* If this is the last peer to be deactivated for this
2445 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2446 if (safi
== SAFI_LABELED_UNICAST
2447 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2448 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2450 if (BGP_DEBUG(zebra
, ZEBRA
))
2452 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2454 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2455 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2460 void peer_nsf_stop(struct peer
*peer
)
2465 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2466 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2468 FOREACH_AFI_SAFI_NSF (afi
, safi
) {
2469 peer
->nsf
[afi
][safi
] = 0;
2470 THREAD_OFF(peer
->t_llgr_stale
[afi
][safi
]);
2473 if (peer
->t_gr_restart
) {
2474 THREAD_OFF(peer
->t_gr_restart
);
2475 if (bgp_debug_neighbor_events(peer
))
2476 zlog_debug("%pBP graceful restart timer stopped", peer
);
2478 if (peer
->t_gr_stale
) {
2479 THREAD_OFF(peer
->t_gr_stale
);
2480 if (bgp_debug_neighbor_events(peer
))
2482 "%pBP graceful restart stalepath timer stopped",
2485 bgp_clear_route_all(peer
);
2488 /* Delete peer from confguration.
2490 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2491 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2493 * This function /should/ take care to be idempotent, to guard against
2494 * it being called multiple times through stray events that come in
2495 * that happen to result in this function being called again. That
2496 * said, getting here for a "Deleted" peer is a bug in the neighbour
2499 int peer_delete(struct peer
*peer
)
2505 struct bgp_filter
*filter
;
2506 struct listnode
*pn
;
2509 assert(peer
->status
!= Deleted
);
2512 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2514 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, peer
);
2516 bgp_keepalives_off(peer
);
2517 bgp_reads_off(peer
);
2518 bgp_writes_off(peer
);
2519 thread_cancel_event_ready(bm
->master
, peer
);
2520 FOREACH_AFI_SAFI (afi
, safi
)
2521 THREAD_OFF(peer
->t_revalidate_all
[afi
][safi
]);
2522 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2523 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2524 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_KEEPALIVES_ON
));
2526 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2527 peer_nsf_stop(peer
);
2529 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2531 /* Remove BFD settings. */
2532 if (peer
->bfd_config
)
2533 bgp_peer_remove_bfd_config(peer
);
2535 /* If this peer belongs to peer group, clear up the
2538 if (peer_dynamic_neighbor(peer
))
2539 peer_drop_dynamic_neighbor(peer
);
2541 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2543 peer
); /* group->peer list reference */
2544 list_delete_node(peer
->group
->peer
, pn
);
2549 /* Withdraw all information from routing table. We can not use
2550 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2551 * executed after peer structure is deleted.
2553 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2555 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2557 if (peer
->doppelganger
) {
2558 peer
->doppelganger
->doppelganger
= NULL
;
2559 peer
->doppelganger
= NULL
;
2562 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2563 bgp_fsm_change_status(peer
, Deleted
);
2565 /* Remove from NHT */
2566 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2567 bgp_unlink_nexthop_by_peer(peer
);
2569 /* Password configuration */
2570 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)) {
2571 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2572 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2573 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2574 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
))
2575 bgp_md5_unset(peer
);
2578 bgp_timer_set(peer
); /* stops all timers for Deleted */
2580 /* Delete from all peer list. */
2581 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2582 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2584 * Removing from the list node first because
2585 * peer_unlock *can* call peer_delete( I know,
2586 * I know ). So let's remove it and in
2587 * the su recalculate function we'll ensure
2588 * it's in there or not.
2590 list_delete_node(bgp
->peer
, pn
);
2591 hash_release(bgp
->peerhash
, peer
);
2592 peer_unlock(peer
); /* bgp peer list reference */
2597 stream_fifo_free(peer
->ibuf
);
2602 stream_fifo_free(peer
->obuf
);
2606 if (peer
->ibuf_work
) {
2607 ringbuf_del(peer
->ibuf_work
);
2608 peer
->ibuf_work
= NULL
;
2611 if (peer
->obuf_work
) {
2612 stream_free(peer
->obuf_work
);
2613 peer
->obuf_work
= NULL
;
2616 if (peer
->scratch
) {
2617 stream_free(peer
->scratch
);
2618 peer
->scratch
= NULL
;
2621 /* Local and remote addresses. */
2622 if (peer
->su_local
) {
2623 sockunion_free(peer
->su_local
);
2624 peer
->su_local
= NULL
;
2627 if (peer
->su_remote
) {
2628 sockunion_free(peer
->su_remote
);
2629 peer
->su_remote
= NULL
;
2632 /* Free filter related memory. */
2633 FOREACH_AFI_SAFI (afi
, safi
) {
2634 filter
= &peer
->filter
[afi
][safi
];
2636 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2637 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2638 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2639 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2642 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2643 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2646 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2647 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2648 ecommunity_free(&peer
->soo
[afi
][safi
]);
2651 FOREACH_AFI_SAFI (afi
, safi
)
2652 peer_af_delete(peer
, afi
, safi
);
2654 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2655 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2656 XFREE(MTYPE_BGP_SOFT_VERSION
, peer
->soft_version
);
2658 peer_unlock(peer
); /* initial reference */
2663 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2665 return strcmp(g1
->name
, g2
->name
);
2668 /* Peer group cofiguration. */
2669 static struct peer_group
*peer_group_new(void)
2671 return XCALLOC(MTYPE_PEER_GROUP
, sizeof(struct peer_group
));
2674 static void peer_group_free(struct peer_group
*group
)
2676 XFREE(MTYPE_PEER_GROUP
, group
);
2679 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2681 struct peer_group
*group
;
2682 struct listnode
*node
, *nnode
;
2684 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2685 if (strcmp(group
->name
, name
) == 0)
2691 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2693 struct peer_group
*group
;
2697 group
= peer_group_lookup(bgp
, name
);
2701 group
= peer_group_new();
2703 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2704 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2705 group
->peer
= list_new();
2706 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2707 group
->listen_range
[afi
] = list_new();
2708 group
->conf
= peer_new(bgp
);
2709 FOREACH_AFI_SAFI (afi
, safi
) {
2710 if (bgp
->default_af
[afi
][safi
])
2711 group
->conf
->afc
[afi
][safi
] = 1;
2713 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2714 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2715 group
->conf
->group
= group
;
2716 group
->conf
->as
= 0;
2717 group
->conf
->ttl
= BGP_DEFAULT_TTL
;
2718 group
->conf
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
2719 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2720 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2721 listnode_add_sort(bgp
->group
, group
);
2726 static void peer_group2peer_config_copy(struct peer_group
*group
,
2731 bool config_node
= !!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2737 peer
->as
= conf
->as
;
2740 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_LOCAL_AS
))
2741 peer
->change_local_as
= conf
->change_local_as
;
2743 /* If peer-group has configured TTL then override it */
2744 if (conf
->ttl
!= BGP_DEFAULT_TTL
)
2745 peer
->ttl
= conf
->ttl
;
2748 peer
->gtsm_hops
= conf
->gtsm_hops
;
2750 /* peer flags apply */
2751 flags_tmp
= conf
->flags
& ~peer
->flags_override
;
2752 flags_tmp
^= conf
->flags_invert
^ peer
->flags_invert
;
2753 flags_tmp
&= ~peer
->flags_override
;
2755 UNSET_FLAG(peer
->flags
, ~peer
->flags_override
);
2756 SET_FLAG(peer
->flags
, flags_tmp
);
2757 SET_FLAG(peer
->flags_invert
, conf
->flags_invert
);
2760 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2762 /* peer timers apply */
2763 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2764 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2765 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2768 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2769 PEER_ATTR_INHERIT(peer
, group
, connect
);
2770 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2771 peer
->v_connect
= conf
->connect
;
2773 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
2776 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_DELAYOPEN
)) {
2777 PEER_ATTR_INHERIT(peer
, group
, delayopen
);
2778 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
2779 peer
->v_delayopen
= conf
->delayopen
;
2781 peer
->v_delayopen
= peer
->bgp
->default_delayopen
;
2784 /* advertisement-interval apply */
2785 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2786 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2787 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2788 peer
->v_routeadv
= conf
->routeadv
;
2790 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2791 ? BGP_DEFAULT_IBGP_ROUTEADV
2792 : BGP_DEFAULT_EBGP_ROUTEADV
;
2795 /* capability extended-nexthop apply */
2796 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_CAPABILITY_ENHE
))
2797 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2798 SET_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
);
2800 /* capability software-version apply */
2801 if (!CHECK_FLAG(peer
->flags_override
,
2802 PEER_FLAG_CAPABILITY_SOFT_VERSION
))
2803 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_SOFT_VERSION
))
2804 SET_FLAG(peer
->flags
,
2805 PEER_FLAG_CAPABILITY_SOFT_VERSION
);
2807 /* password apply */
2808 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_PASSWORD
))
2809 PEER_STR_ATTR_INHERIT(peer
, group
, password
,
2810 MTYPE_PEER_PASSWORD
);
2812 if (!BGP_PEER_SU_UNSPEC(peer
))
2815 /* update-source apply */
2816 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_UPDATE_SOURCE
)) {
2817 if (conf
->update_source
) {
2818 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2819 PEER_SU_ATTR_INHERIT(peer
, group
, update_source
);
2820 } else if (conf
->update_if
) {
2821 sockunion_free(peer
->update_source
);
2822 PEER_STR_ATTR_INHERIT(peer
, group
, update_if
,
2823 MTYPE_PEER_UPDATE_SOURCE
);
2828 PEER_ATTR_INHERIT(peer
, group
, local_role
);
2830 /* Update GR flags for the peer. */
2831 bgp_peer_gr_flags_update(peer
);
2833 /* Apply BFD settings from group to peer if it exists. */
2834 if (conf
->bfd_config
) {
2835 bgp_peer_configure_bfd(peer
, false);
2836 bgp_peer_config_apply(peer
, group
);
2840 /* Peer group's remote AS configuration. */
2841 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2842 int as_type
, const char *as_str
)
2844 struct peer_group
*group
;
2846 struct listnode
*node
, *nnode
;
2848 group
= peer_group_lookup(bgp
, group_name
);
2852 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2856 /* When we setup peer-group AS number all peer group member's AS
2857 number must be updated to same number. */
2858 peer_as_change(group
->conf
, *as
, as_type
, as_str
);
2860 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2861 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2862 || (peer
->as_type
!= as_type
))
2863 peer_as_change(peer
, *as
, as_type
, as_str
);
2869 void peer_notify_unconfig(struct peer
*peer
)
2871 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2872 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2873 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
2876 static void peer_notify_shutdown(struct peer
*peer
)
2878 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
2879 if (bgp_debug_neighbor_events(peer
))
2881 "%pBP configured Graceful-Restart, skipping shutdown notification",
2886 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2887 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2888 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
2891 void peer_group_notify_unconfig(struct peer_group
*group
)
2893 struct peer
*peer
, *other
;
2894 struct listnode
*node
, *nnode
;
2896 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2897 other
= peer
->doppelganger
;
2898 if (other
&& other
->status
!= Deleted
) {
2899 other
->group
= NULL
;
2900 peer_notify_unconfig(other
);
2902 peer_notify_unconfig(peer
);
2906 int peer_group_delete(struct peer_group
*group
)
2910 struct prefix
*prefix
;
2912 struct listnode
*node
, *nnode
;
2917 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2918 other
= peer
->doppelganger
;
2920 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2921 bgp_zebra_terminate_radv(bgp
, peer
);
2924 if (other
&& other
->status
!= Deleted
) {
2925 other
->group
= NULL
;
2929 list_delete(&group
->peer
);
2931 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2932 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2934 prefix_free(&prefix
);
2936 list_delete(&group
->listen_range
[afi
]);
2939 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2942 if (group
->conf
->bfd_config
)
2943 bgp_peer_remove_bfd_config(group
->conf
);
2945 group
->conf
->group
= NULL
;
2946 peer_delete(group
->conf
);
2948 /* Delete from all peer_group list. */
2949 listnode_delete(bgp
->group
, group
);
2951 peer_group_free(group
);
2956 int peer_group_remote_as_delete(struct peer_group
*group
)
2958 struct peer
*peer
, *other
;
2959 struct listnode
*node
, *nnode
;
2961 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2962 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2965 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2966 other
= peer
->doppelganger
;
2968 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2969 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
2973 if (other
&& other
->status
!= Deleted
) {
2974 other
->group
= NULL
;
2978 list_delete_all_node(group
->peer
);
2980 group
->conf
->as
= 0;
2981 group
->conf
->as_type
= AS_UNSPECIFIED
;
2986 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2988 struct prefix
*prefix
;
2989 struct listnode
*node
, *nnode
;
2992 afi
= family2afi(range
->family
);
2994 /* Group needs remote AS configured. */
2995 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2996 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2998 /* Ensure no duplicates. Currently we don't care about overlaps. */
2999 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
3000 if (prefix_same(range
, prefix
))
3004 prefix
= prefix_new();
3005 prefix_copy(prefix
, range
);
3006 listnode_add(group
->listen_range
[afi
], prefix
);
3008 /* Update passwords for new ranges */
3009 if (group
->conf
->password
)
3010 bgp_md5_set_prefix(group
->bgp
, prefix
, group
->conf
->password
);
3015 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
3017 struct prefix
*prefix
, prefix2
;
3018 struct listnode
*node
, *nnode
;
3022 afi
= family2afi(range
->family
);
3024 /* Identify the listen range. */
3025 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
3026 if (prefix_same(range
, prefix
))
3031 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
3033 /* Dispose off any dynamic neighbors that exist due to this listen range
3035 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
3036 if (!peer_dynamic_neighbor(peer
))
3039 if (sockunion2hostprefix(&peer
->su
, &prefix2
)
3040 && prefix_match(prefix
, &prefix2
)) {
3041 if (bgp_debug_neighbor_events(peer
))
3043 "Deleting dynamic neighbor %s group %s upon delete of listen range %pFX",
3044 peer
->host
, group
->name
, prefix
);
3049 /* Get rid of the listen range */
3050 listnode_delete(group
->listen_range
[afi
], prefix
);
3052 /* Remove passwords for deleted ranges */
3053 if (group
->conf
->password
)
3054 bgp_md5_unset_prefix(group
->bgp
, prefix
);
3059 /* Bind specified peer to peer group. */
3060 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
3061 struct peer_group
*group
, as_t
*as
)
3063 int first_member
= 0;
3066 enum bgp_peer_sort ptype
, gtype
;
3068 /* Lookup the peer. */
3070 peer
= peer_lookup(bgp
, su
);
3072 /* The peer exist, bind it to the peer-group */
3074 /* When the peer already belongs to a peer-group, check the
3076 if (peer_group_active(peer
)) {
3078 /* The peer is already bound to the peer-group,
3081 if (strcmp(peer
->group
->name
, group
->name
) == 0)
3084 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
3087 /* The peer has not specified a remote-as, inherit it from the
3089 if (peer
->as_type
== AS_UNSPECIFIED
) {
3090 peer
->as_type
= group
->conf
->as_type
;
3091 peer
->as
= group
->conf
->as
;
3092 peer
->sort
= group
->conf
->sort
;
3095 ptype
= peer_sort(peer
);
3096 if (!group
->conf
->as
&& ptype
!= BGP_PEER_UNSPECIFIED
) {
3097 gtype
= peer_sort(group
->conf
);
3098 if ((gtype
!= BGP_PEER_INTERNAL
) && (gtype
!= ptype
)) {
3101 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
3104 if (gtype
== BGP_PEER_INTERNAL
)
3108 peer_group2peer_config_copy(group
, peer
);
3110 FOREACH_AFI_SAFI (afi
, safi
) {
3111 if (group
->conf
->afc
[afi
][safi
]) {
3112 peer
->afc
[afi
][safi
] = 1;
3114 if (peer_af_find(peer
, afi
, safi
)
3115 || peer_af_create(peer
, afi
, safi
)) {
3116 peer_group2peer_config_copy_af(
3117 group
, peer
, afi
, safi
);
3119 } else if (peer
->afc
[afi
][safi
])
3120 peer_deactivate(peer
, afi
, safi
);
3124 assert(group
&& peer
->group
== group
);
3126 listnode_delete(bgp
->peer
, peer
);
3128 peer
->group
= group
;
3129 listnode_add_sort(bgp
->peer
, peer
);
3131 peer
= peer_lock(peer
); /* group->peer list reference */
3132 listnode_add(group
->peer
, peer
);
3136 gtype
= peer_sort(group
->conf
);
3137 /* Advertisement-interval reset */
3138 if (!CHECK_FLAG(group
->conf
->flags
,
3139 PEER_FLAG_ROUTEADV
)) {
3140 group
->conf
->v_routeadv
=
3141 (gtype
== BGP_PEER_IBGP
)
3142 ? BGP_DEFAULT_IBGP_ROUTEADV
3143 : BGP_DEFAULT_EBGP_ROUTEADV
;
3146 /* ebgp-multihop reset */
3147 if (gtype
== BGP_PEER_IBGP
)
3148 group
->conf
->ttl
= MAXTTL
;
3151 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3153 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3154 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
3155 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3156 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3158 bgp_session_reset(peer
);
3162 /* Create a new peer. */
3164 if ((group
->conf
->as_type
== AS_SPECIFIED
)
3165 && (!group
->conf
->as
)) {
3166 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
3169 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3170 group
->conf
->as_type
, group
, true, NULL
);
3172 peer
= peer_lock(peer
); /* group->peer list reference */
3173 listnode_add(group
->peer
, peer
);
3175 peer_group2peer_config_copy(group
, peer
);
3177 /* If the peer-group is active for this afi/safi then activate
3179 FOREACH_AFI_SAFI (afi
, safi
) {
3180 if (group
->conf
->afc
[afi
][safi
]) {
3181 peer
->afc
[afi
][safi
] = 1;
3183 if (!peer_af_find(peer
, afi
, safi
))
3184 peer_af_create(peer
, afi
, safi
);
3186 peer_group2peer_config_copy_af(group
, peer
, afi
,
3188 } else if (peer
->afc
[afi
][safi
])
3189 peer_deactivate(peer
, afi
, safi
);
3192 /* Set up peer's events and timers. */
3193 if (peer_active(peer
))
3194 bgp_timer_set(peer
);
3200 static void bgp_startup_timer_expire(struct thread
*thread
)
3204 bgp
= THREAD_ARG(thread
);
3205 bgp
->t_startup
= NULL
;
3209 * On shutdown we call the cleanup function which
3210 * does a free of the link list nodes, free up
3211 * the data we are pointing at too.
3213 static void bgp_vrf_string_name_delete(void *data
)
3217 XFREE(MTYPE_TMP
, vname
);
3220 /* BGP instance creation by `router bgp' commands. */
3221 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
3222 enum bgp_instance_type inst_type
,
3223 const char *as_pretty
,
3224 enum asnotation_mode asnotation
)
3230 bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
));
3233 bgp
->as_pretty
= XSTRDUP(MTYPE_BGP
, as_pretty
);
3235 bgp
->as_pretty
= XSTRDUP(MTYPE_BGP
, asn_asn2asplain(*as
));
3237 if (asnotation
!= ASNOTATION_UNDEFINED
) {
3238 bgp
->asnotation
= asnotation
;
3239 SET_FLAG(bgp
->config
, BGP_CONFIG_ASNOTATION
);
3241 asn_str2asn_notation(bgp
->as_pretty
, NULL
, &bgp
->asnotation
);
3243 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3244 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3245 zlog_debug("Creating Default VRF, AS %s",
3248 zlog_debug("Creating %s %s, AS %s",
3249 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
3252 name
, bgp
->as_pretty
);
3255 /* Default the EVPN VRF to the default one */
3256 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
&& !bgp_master
.bgp_evpn
) {
3263 bgp
->allow_martian
= false;
3264 bgp_process_queue_init(bgp
);
3265 bgp
->heuristic_coalesce
= true;
3266 bgp
->inst_type
= inst_type
;
3267 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
3269 bgp
->peer_self
= peer_new(bgp
);
3270 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
3271 bgp
->peer_self
->host
=
3272 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
3273 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
3274 if (cmd_hostname_get())
3275 bgp
->peer_self
->hostname
=
3276 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
3278 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
3279 if (cmd_domainname_get())
3280 bgp
->peer_self
->domainname
=
3281 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
3282 bgp
->peer
= list_new();
3283 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
3284 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
3286 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
3288 bgp
->group
= list_new();
3289 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
3291 FOREACH_AFI_SAFI (afi
, safi
) {
3292 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3293 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3294 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3296 /* Enable maximum-paths */
3297 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
3299 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
3301 /* Initialize graceful restart info */
3302 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
3303 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
3304 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
3305 bgp
->gr_info
[afi
][safi
].t_route_select
= NULL
;
3306 bgp
->gr_info
[afi
][safi
].gr_deferred
= 0;
3309 bgp
->v_update_delay
= bm
->v_update_delay
;
3310 bgp
->v_establish_wait
= bm
->v_establish_wait
;
3311 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
3312 bgp
->default_subgroup_pkt_queue_max
=
3313 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
3314 bgp_tcp_keepalive_unset(bgp
);
3315 bgp_timers_unset(bgp
);
3316 bgp
->default_min_holdtime
= 0;
3317 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
3318 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
3319 bgp
->select_defer_time
= BGP_DEFAULT_SELECT_DEFERRAL_TIME
;
3320 bgp
->rib_stale_time
= BGP_DEFAULT_RIB_STALE_TIME
;
3321 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
3322 bgp
->dynamic_neighbors_count
= 0;
3323 bgp
->lb_ref_bw
= BGP_LINK_BW_REF_BW
;
3324 bgp
->lb_handling
= BGP_LINK_BW_ECMP
;
3325 bgp
->reject_as_sets
= false;
3326 bgp
->condition_check_period
= DEFAULT_CONDITIONAL_ROUTES_POLL_TIME
;
3327 bgp_addpath_init_bgp_data(&bgp
->tx_addpath
);
3328 bgp
->fast_convergence
= false;
3329 bgp
->llgr_stale_time
= BGP_DEFAULT_LLGR_STALE_TIME
;
3331 #ifdef ENABLE_BGP_VNC
3332 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
3333 bgp
->rfapi
= bgp_rfapi_new(bgp
);
3335 assert(bgp
->rfapi_cfg
);
3337 #endif /* ENABLE_BGP_VNC */
3339 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3340 bgp
->vpn_policy
[afi
].bgp
= bgp
;
3341 bgp
->vpn_policy
[afi
].afi
= afi
;
3342 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
3343 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
3346 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
3347 bgp
->vpn_policy
[afi
].import_vrf
->del
=
3348 bgp_vrf_string_name_delete
;
3349 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
3350 bgp
->vpn_policy
[afi
].export_vrf
->del
=
3351 bgp_vrf_string_name_delete
;
3352 SET_FLAG(bgp
->af_flags
[afi
][SAFI_MPLS_VPN
],
3353 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL
);
3356 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
3358 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
3359 bgp
->restart_time
, &bgp
->t_startup
);
3361 /* printable name we can use in debug messages */
3362 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3363 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3373 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3375 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3376 snprintf(bgp
->name_pretty
, len
, "%s %s",
3377 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3383 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3384 memory_order_relaxed
);
3385 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3386 memory_order_relaxed
);
3387 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3388 bgp
->default_af
[AFI_IP
][SAFI_UNICAST
] = true;
3392 update_bgp_group_init(bgp
);
3394 /* assign a unique rd id for auto derivation of vrf's RD */
3395 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3397 bgp
->evpn_info
= XCALLOC(MTYPE_BGP_EVPN_INFO
,
3398 sizeof(struct bgp_evpn_info
));
3400 bgp_evpn_vrf_es_init(bgp
);
3404 /*initilize global GR FSM */
3405 bgp_global_gr_init(bgp
);
3407 memset(&bgp
->ebgprequirespolicywarning
, 0,
3408 sizeof(bgp
->ebgprequirespolicywarning
));
3413 /* Return the "default VRF" instance of BGP. */
3414 struct bgp
*bgp_get_default(void)
3417 struct listnode
*node
, *nnode
;
3419 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3420 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3425 /* Lookup BGP entry. */
3426 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3429 struct listnode
*node
, *nnode
;
3431 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3433 && ((bgp
->name
== NULL
&& name
== NULL
)
3434 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3439 /* Lookup BGP structure by view name. */
3440 struct bgp
*bgp_lookup_by_name(const char *name
)
3443 struct listnode
*node
, *nnode
;
3445 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3446 if ((bgp
->name
== NULL
&& name
== NULL
)
3447 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3452 /* Lookup BGP instance based on VRF id. */
3453 /* Note: Only to be used for incoming messages from Zebra. */
3454 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3458 /* Lookup VRF (in tree) and follow link. */
3459 vrf
= vrf_lookup_by_id(vrf_id
);
3462 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3465 /* Sets the BGP instance where EVPN is enabled */
3466 void bgp_set_evpn(struct bgp
*bgp
)
3468 if (bm
->bgp_evpn
== bgp
)
3471 /* First, release the reference count we hold on the instance */
3473 bgp_unlock(bm
->bgp_evpn
);
3477 /* Increase the reference count on this new VRF */
3479 bgp_lock(bm
->bgp_evpn
);
3482 /* Returns the BGP instance where EVPN is enabled, if any */
3483 struct bgp
*bgp_get_evpn(void)
3485 return bm
->bgp_evpn
;
3488 /* handle socket creation or deletion, if necessary
3489 * this is called for all new BGP instances
3491 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3494 struct listnode
*node
;
3497 /* Create BGP server socket, if listen mode not disabled */
3498 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3500 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3502 * suppress vrf socket
3505 bgp_close_vrf_socket(bgp
);
3509 return BGP_ERR_INVALID_VALUE
;
3511 * if vrf_id did not change
3513 if (vrf
->vrf_id
== old_vrf_id
)
3515 if (old_vrf_id
!= VRF_UNKNOWN
) {
3516 /* look for old socket. close it. */
3517 bgp_close_vrf_socket(bgp
);
3519 /* if backend is not yet identified ( VRF_UNKNOWN) then
3520 * creation will be done later
3522 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3524 if (list_isempty(bm
->addresses
)) {
3525 if (bgp_socket(bgp
, bm
->port
, NULL
) < 0)
3526 return BGP_ERR_INVALID_VALUE
;
3528 for (ALL_LIST_ELEMENTS_RO(bm
->addresses
, node
, address
))
3529 if (bgp_socket(bgp
, bm
->port
, address
) < 0)
3530 return BGP_ERR_INVALID_VALUE
;
3534 return bgp_check_main_socket(create
, bgp
);
3537 int bgp_lookup_by_as_name_type(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3538 enum bgp_instance_type inst_type
)
3542 /* Multiple instance check. */
3544 bgp
= bgp_lookup_by_name(name
);
3546 bgp
= bgp_get_default();
3550 if (bgp
->as
!= *as
) {
3552 return BGP_ERR_AS_MISMATCH
;
3554 if (bgp
->inst_type
!= inst_type
)
3555 return BGP_ERR_INSTANCE_MISMATCH
;
3563 /* Called from VTY commands. */
3564 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3565 enum bgp_instance_type inst_type
, const char *as_pretty
,
3566 enum asnotation_mode asnotation
)
3569 struct vrf
*vrf
= NULL
;
3572 ret
= bgp_lookup_by_as_name_type(bgp_val
, as
, name
, inst_type
);
3573 if (ret
|| *bgp_val
)
3576 bgp
= bgp_create(as
, name
, inst_type
, as_pretty
, asnotation
);
3579 * view instances will never work inside of a vrf
3580 * as such they must always be in the VRF_DEFAULT
3581 * Also we must set this to something useful because
3582 * of the vrf socket code needing an actual useful
3583 * default value to send to the underlying OS.
3585 * This code is currently ignoring vrf based
3586 * code using the -Z option( and that is probably
3587 * best addressed elsewhere in the code )
3589 if (inst_type
== BGP_INSTANCE_TYPE_VIEW
)
3590 bgp
->vrf_id
= VRF_DEFAULT
;
3592 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
, true);
3593 bgp_address_init(bgp
);
3594 bgp_tip_hash_init(bgp
);
3598 bgp
->t_rmap_def_originate_eval
= NULL
;
3600 /* If Default instance or VRF, link to the VRF structure, if present. */
3601 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3602 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3603 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3605 bgp_vrf_link(bgp
, vrf
);
3607 /* BGP server socket already processed if BGP instance
3608 * already part of the list
3610 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3611 listnode_add(bm
->bgp
, bgp
);
3613 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3614 if (BGP_DEBUG(zebra
, ZEBRA
))
3615 zlog_debug("%s: Registering BGP instance %s to zebra",
3616 __func__
, bgp
->name_pretty
);
3617 bgp_zebra_instance_register(bgp
);
3623 static void bgp_zclient_set_redist(afi_t afi
, int type
, unsigned short instance
,
3624 vrf_id_t vrf_id
, bool set
)
3628 redist_add_instance(&zclient
->mi_redist
[afi
][type
],
3631 redist_del_instance(&zclient
->mi_redist
[afi
][type
],
3635 vrf_bitmap_set(zclient
->redist
[afi
][type
], vrf_id
);
3637 vrf_bitmap_unset(zclient
->redist
[afi
][type
], vrf_id
);
3641 static void bgp_set_redist_vrf_bitmaps(struct bgp
*bgp
, bool set
)
3645 struct list
*red_list
;
3646 struct listnode
*node
;
3647 struct bgp_redist
*red
;
3649 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3650 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3652 red_list
= bgp
->redist
[afi
][i
];
3656 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
3657 bgp_zclient_set_redist(afi
, i
, red
->instance
,
3664 * Make BGP instance "up". Applies only to VRFs (non-default) and
3665 * implies the VRF has been learnt from Zebra.
3667 void bgp_instance_up(struct bgp
*bgp
)
3670 struct listnode
*node
, *next
;
3672 bgp_set_redist_vrf_bitmaps(bgp
, true);
3674 /* Register with zebra. */
3675 bgp_zebra_instance_register(bgp
);
3677 /* Kick off any peers that may have been configured. */
3678 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3679 if (!BGP_PEER_START_SUPPRESSED(peer
))
3680 BGP_EVENT_ADD(peer
, BGP_Start
);
3683 /* Process any networks that have been configured. */
3684 bgp_static_add(bgp
);
3688 * Make BGP instance "down". Applies only to VRFs (non-default) and
3689 * implies the VRF has been deleted by Zebra.
3691 void bgp_instance_down(struct bgp
*bgp
)
3694 struct listnode
*node
;
3695 struct listnode
*next
;
3698 if (bgp
->t_rmap_def_originate_eval
) {
3699 THREAD_OFF(bgp
->t_rmap_def_originate_eval
);
3700 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3704 /* Bring down peers, so corresponding routes are purged. */
3705 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3706 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3707 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3708 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3710 bgp_session_reset(peer
);
3713 /* Purge network and redistributed routes. */
3714 bgp_purge_static_redist_routes(bgp
);
3716 /* Cleanup registered nexthops (flags) */
3717 bgp_cleanup_nexthops(bgp
);
3719 bgp_zebra_instance_deregister(bgp
);
3721 bgp_set_redist_vrf_bitmaps(bgp
, false);
3724 /* Delete BGP instance. */
3725 int bgp_delete(struct bgp
*bgp
)
3728 struct peer_group
*group
;
3729 struct listnode
*node
, *next
;
3734 struct graceful_restart_info
*gr_info
;
3738 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, NULL
);
3740 /* make sure we withdraw any exported routes */
3741 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP
, bgp_get_default(),
3743 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP6
, bgp_get_default(),
3746 bgp_vpn_leak_unimport(bgp
);
3748 hook_call(bgp_inst_delete
, bgp
);
3750 FOREACH_AFI_SAFI (afi
, safi
)
3751 THREAD_OFF(bgp
->t_revalidate
[afi
][safi
]);
3753 THREAD_OFF(bgp
->t_condition_check
);
3754 THREAD_OFF(bgp
->t_startup
);
3755 THREAD_OFF(bgp
->t_maxmed_onstartup
);
3756 THREAD_OFF(bgp
->t_update_delay
);
3757 THREAD_OFF(bgp
->t_establish_wait
);
3759 /* Set flag indicating bgp instance delete in progress */
3760 SET_FLAG(bgp
->flags
, BGP_FLAG_DELETE_IN_PROGRESS
);
3762 /* Delete the graceful restart info */
3763 FOREACH_AFI_SAFI (afi
, safi
) {
3766 gr_info
= &bgp
->gr_info
[afi
][safi
];
3769 t
= gr_info
->t_select_deferral
;
3771 void *info
= THREAD_ARG(t
);
3773 XFREE(MTYPE_TMP
, info
);
3775 THREAD_OFF(gr_info
->t_select_deferral
);
3777 t
= gr_info
->t_route_select
;
3779 void *info
= THREAD_ARG(t
);
3781 XFREE(MTYPE_TMP
, info
);
3783 THREAD_OFF(gr_info
->t_route_select
);
3786 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3787 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3788 zlog_debug("Deleting Default VRF");
3790 zlog_debug("Deleting %s %s",
3791 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3797 /* unmap from RT list */
3798 bgp_evpn_vrf_delete(bgp
);
3800 /* unmap bgp vrf label */
3801 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP
);
3802 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP6
);
3805 if (bgp
->t_rmap_def_originate_eval
) {
3806 THREAD_OFF(bgp
->t_rmap_def_originate_eval
);
3807 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3811 /* Inform peers we're going down. */
3812 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3813 peer_notify_shutdown(peer
);
3815 /* Delete static routes (networks). */
3816 bgp_static_delete(bgp
);
3818 /* Unset redistribution. */
3819 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3820 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3821 if (i
!= ZEBRA_ROUTE_BGP
)
3822 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3824 /* Free peers and peer-groups. */
3825 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3826 peer_group_delete(group
);
3828 while (listcount(bgp
->peer
)) {
3829 peer
= listnode_head(bgp
->peer
);
3833 if (bgp
->peer_self
) {
3834 peer_delete(bgp
->peer_self
);
3835 bgp
->peer_self
= NULL
;
3838 update_bgp_group_free(bgp
);
3840 /* TODO - Other memory may need to be freed - e.g., NHT */
3842 #ifdef ENABLE_BGP_VNC
3845 bgp_cleanup_routes(bgp
);
3847 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3848 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3851 &bgp
->vpn_policy
[afi
]
3852 .import_redirect_rtlist
);
3853 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3856 /* Free any memory allocated to holding routemap references */
3857 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3858 for (enum vpn_policy_direction dir
= 0;
3859 dir
< BGP_VPN_POLICY_DIR_MAX
; ++dir
) {
3860 if (bgp
->vpn_policy
[afi
].rmap_name
[dir
])
3861 XFREE(MTYPE_ROUTE_MAP_NAME
,
3862 bgp
->vpn_policy
[afi
].rmap_name
[dir
]);
3863 bgp
->vpn_policy
[afi
].rmap
[dir
] = NULL
;
3867 /* Deregister from Zebra, if needed */
3868 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3869 if (BGP_DEBUG(zebra
, ZEBRA
))
3871 "%s: deregistering this bgp %s instance from zebra",
3872 __func__
, bgp
->name
);
3873 bgp_zebra_instance_deregister(bgp
);
3876 /* Remove visibility via the master list - there may however still be
3877 * routes to be processed still referencing the struct bgp.
3879 listnode_delete(bm
->bgp
, bgp
);
3881 /* Free interfaces in this instance. */
3884 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3885 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3887 bgp_vrf_unlink(bgp
, vrf
);
3889 /* Update EVPN VRF pointer */
3890 if (bm
->bgp_evpn
== bgp
) {
3891 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3894 bgp_set_evpn(bgp_get_default());
3897 if (bgp
->process_queue
)
3898 work_queue_free_and_null(&bgp
->process_queue
);
3900 thread_master_free_unused(bm
->master
);
3901 bgp_unlock(bgp
); /* initial reference */
3906 void bgp_free(struct bgp
*bgp
)
3910 struct bgp_table
*table
;
3911 struct bgp_dest
*dest
;
3912 struct bgp_rmap
*rmap
;
3916 list_delete(&bgp
->group
);
3917 list_delete(&bgp
->peer
);
3919 if (bgp
->peerhash
) {
3920 hash_free(bgp
->peerhash
);
3921 bgp
->peerhash
= NULL
;
3924 FOREACH_AFI_SAFI (afi
, safi
) {
3925 /* Special handling for 2-level routing tables. */
3926 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3927 || safi
== SAFI_EVPN
) {
3928 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
3929 dest
= bgp_route_next(dest
)) {
3930 table
= bgp_dest_get_bgp_table_info(dest
);
3931 bgp_table_finish(&table
);
3934 if (bgp
->route
[afi
][safi
])
3935 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3936 if (bgp
->aggregate
[afi
][safi
])
3937 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3938 if (bgp
->rib
[afi
][safi
])
3939 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3940 rmap
= &bgp
->table_map
[afi
][safi
];
3941 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3944 bgp_scan_finish(bgp
);
3945 bgp_address_destroy(bgp
);
3946 bgp_tip_hash_destroy(bgp
);
3948 /* release the auto RD id */
3949 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3951 bgp_evpn_cleanup(bgp
);
3952 bgp_pbr_cleanup(bgp
);
3953 bgp_srv6_cleanup(bgp
);
3954 XFREE(MTYPE_BGP_EVPN_INFO
, bgp
->evpn_info
);
3956 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3957 enum vpn_policy_direction dir
;
3959 if (bgp
->vpn_policy
[afi
].import_vrf
)
3960 list_delete(&bgp
->vpn_policy
[afi
].import_vrf
);
3961 if (bgp
->vpn_policy
[afi
].export_vrf
)
3962 list_delete(&bgp
->vpn_policy
[afi
].export_vrf
);
3964 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3965 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3966 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3967 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3968 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3969 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3970 if (bgp
->vpn_policy
[afi
].tovpn_rd_pretty
)
3971 XFREE(MTYPE_BGP
, bgp
->vpn_policy
[afi
].tovpn_rd_pretty
);
3974 bgp_confederation_id_unset(bgp
);
3976 XFREE(MTYPE_BGP
, bgp
->as_pretty
);
3977 XFREE(MTYPE_BGP
, bgp
->name
);
3978 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3979 XFREE(MTYPE_BGP
, bgp
->snmp_stats
);
3981 XFREE(MTYPE_BGP
, bgp
);
3984 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3987 struct listnode
*node
, *nnode
;
3993 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3994 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3995 && !CHECK_FLAG(peer
->sflags
,
3996 PEER_STATUS_ACCEPT_PEER
))
3998 } else if (bm
->bgp
!= NULL
) {
3999 struct listnode
*bgpnode
, *nbgpnode
;
4001 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4002 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4004 && !strcmp(peer
->conf_if
, conf_if
)
4005 && !CHECK_FLAG(peer
->sflags
,
4006 PEER_STATUS_ACCEPT_PEER
))
4012 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
4015 struct listnode
*node
, *nnode
;
4021 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4022 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
4023 && !CHECK_FLAG(peer
->sflags
,
4024 PEER_STATUS_ACCEPT_PEER
))
4026 } else if (bm
->bgp
!= NULL
) {
4027 struct listnode
*bgpnode
, *nbgpnode
;
4029 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4030 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
4032 && !strcmp(peer
->hostname
, hostname
)
4033 && !CHECK_FLAG(peer
->sflags
,
4034 PEER_STATUS_ACCEPT_PEER
))
4040 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
4042 struct peer
*peer
= NULL
;
4043 struct peer tmp_peer
;
4045 memset(&tmp_peer
, 0, sizeof(struct peer
));
4048 * We do not want to find the doppelganger peer so search for the peer
4050 * the hash that has PEER_FLAG_CONFIG_NODE
4052 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
4057 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4058 } else if (bm
->bgp
!= NULL
) {
4059 struct listnode
*bgpnode
, *nbgpnode
;
4061 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
4062 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4071 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
4072 union sockunion
*su
,
4073 struct peer_group
*group
)
4079 /* Create peer first; we've already checked group config is valid. */
4080 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
4081 group
->conf
->as_type
, group
, true, NULL
);
4086 peer
= peer_lock(peer
);
4087 listnode_add(group
->peer
, peer
);
4089 peer_group2peer_config_copy(group
, peer
);
4092 * Bind peer for all AFs configured for the group. We don't call
4093 * peer_group_bind as that is sub-optimal and does some stuff we don't
4096 FOREACH_AFI_SAFI (afi
, safi
) {
4097 if (!group
->conf
->afc
[afi
][safi
])
4099 peer
->afc
[afi
][safi
] = 1;
4101 if (!peer_af_find(peer
, afi
, safi
))
4102 peer_af_create(peer
, afi
, safi
);
4104 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
4107 /* Mark as dynamic, but also as a "config node" for other things to
4109 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
4115 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
4116 struct prefix
*prefix
)
4118 struct listnode
*node
, *nnode
;
4119 struct prefix
*range
;
4122 afi
= family2afi(prefix
->family
);
4124 if (group
->listen_range
[afi
])
4125 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
4127 if (prefix_match(range
, prefix
))
4134 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
4135 struct prefix
**listen_range
)
4137 struct prefix
*range
= NULL
;
4138 struct peer_group
*group
= NULL
;
4139 struct listnode
*node
, *nnode
;
4141 *listen_range
= NULL
;
4143 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4144 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4147 } else if (bm
->bgp
!= NULL
) {
4148 struct listnode
*bgpnode
, *nbgpnode
;
4150 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4151 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4152 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4158 *listen_range
= range
;
4159 return (group
&& range
) ? group
: NULL
;
4162 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
4164 struct peer_group
*group
;
4167 struct prefix prefix
;
4168 struct prefix
*listen_range
;
4171 if (!sockunion2hostprefix(su
, &prefix
))
4174 /* See if incoming connection matches a configured listen range. */
4175 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
4186 if (bgp_debug_neighbor_events(NULL
))
4188 "Dynamic Neighbor %pFX matches group %s listen range %pFX",
4189 &prefix
, group
->name
, listen_range
);
4191 /* Are we within the listen limit? */
4192 dncount
= gbgp
->dynamic_neighbors_count
;
4194 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
4195 if (bgp_debug_neighbor_events(NULL
))
4197 "Dynamic Neighbor %pFX rejected - at limit %d",
4198 &prefix
, gbgp
->dynamic_neighbors_limit
);
4202 /* Ensure group is not disabled. */
4203 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
4204 if (bgp_debug_neighbor_events(NULL
))
4206 "Dynamic Neighbor %pFX rejected - group %s disabled",
4207 &prefix
, group
->name
);
4211 /* Check that at least one AF is activated for the group. */
4212 if (!peer_group_af_configured(group
)) {
4213 if (bgp_debug_neighbor_events(NULL
))
4215 "Dynamic Neighbor %pFX rejected - no AF activated for group %s",
4216 &prefix
, group
->name
);
4220 /* Create dynamic peer and bind to associated group. */
4221 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
4224 gbgp
->dynamic_neighbors_count
= ++dncount
;
4226 if (bgp_debug_neighbor_events(peer
))
4227 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
4228 peer
->host
, group
->name
, dncount
);
4233 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
4236 if (peer
->group
->bgp
) {
4237 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
4239 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
4241 if (bgp_debug_neighbor_events(peer
))
4242 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
4243 peer
->group
->name
, dncount
);
4246 bool bgp_path_attribute_discard(struct peer
*peer
, char *buf
, size_t size
)
4253 for (unsigned int i
= 0; i
< BGP_ATTR_MAX
; i
++) {
4254 if (peer
->discard_attrs
[i
])
4255 snprintf(buf
+ strlen(buf
), size
- strlen(buf
), "%s%d",
4256 (strlen(buf
) > 0) ? " " : "", i
);
4259 if (strlen(buf
) > 0)
4265 bool bgp_path_attribute_treat_as_withdraw(struct peer
*peer
, char *buf
,
4273 for (unsigned int i
= 0; i
< BGP_ATTR_MAX
; i
++) {
4274 if (peer
->withdraw_attrs
[i
])
4275 snprintf(buf
+ strlen(buf
), size
- strlen(buf
), "%s%d",
4276 (strlen(buf
) > 0) ? " " : "", i
);
4279 if (strlen(buf
) > 0)
4285 /* If peer is configured at least one address family return 1. */
4286 bool peer_active(struct peer
*peer
)
4288 if (BGP_PEER_SU_UNSPEC(peer
))
4290 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
4291 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
4292 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
4293 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
4294 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
4295 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
4296 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4297 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
4298 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
4299 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
4300 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
4305 /* If peer is negotiated at least one address family return 1. */
4306 bool peer_active_nego(struct peer
*peer
)
4308 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
4309 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
4310 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
4311 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
4312 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
4313 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
4314 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
4315 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
4316 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4317 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
4318 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
4319 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
4320 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
4325 /* If peer received at least one address family MP, return true */
4326 bool peer_afc_received(struct peer
*peer
)
4331 FOREACH_AFI_SAFI (afi
, safi
)
4332 if (peer
->afc_recv
[afi
][safi
])
4338 /* If peer advertised at least one address family MP, return true */
4339 bool peer_afc_advertised(struct peer
*peer
)
4344 FOREACH_AFI_SAFI (afi
, safi
)
4345 if (peer
->afc_adv
[afi
][safi
])
4351 void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
4352 enum peer_change_type type
)
4354 struct peer_af
*paf
;
4356 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4359 if (!peer_established(peer
))
4362 if (type
== peer_change_reset
) {
4363 /* If we're resetting session, we've to delete both peer struct
4365 if ((peer
->doppelganger
)
4366 && (peer
->doppelganger
->status
!= Deleted
)
4367 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4368 PEER_FLAG_CONFIG_NODE
)))
4369 peer_delete(peer
->doppelganger
);
4371 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4372 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4373 } else if (type
== peer_change_reset_in
) {
4374 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4375 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4376 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0,
4377 BGP_ROUTE_REFRESH_NORMAL
);
4379 if ((peer
->doppelganger
)
4380 && (peer
->doppelganger
->status
!= Deleted
)
4381 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4382 PEER_FLAG_CONFIG_NODE
)))
4383 peer_delete(peer
->doppelganger
);
4385 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4386 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4388 } else if (type
== peer_change_reset_out
) {
4389 paf
= peer_af_find(peer
, afi
, safi
);
4390 if (paf
&& paf
->subgroup
)
4391 SET_FLAG(paf
->subgroup
->sflags
,
4392 SUBGRP_STATUS_FORCE_UPDATES
);
4394 update_group_adjust_peer(paf
);
4395 bgp_announce_route(peer
, afi
, safi
, false);
4399 struct peer_flag_action
{
4403 /* This flag can be set for peer-group member. */
4404 uint8_t not_for_member
;
4406 /* Action when the flag is changed. */
4407 enum peer_change_type type
;
4410 static const struct peer_flag_action peer_flag_action_list
[] = {
4411 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
4412 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
4413 {PEER_FLAG_RTT_SHUTDOWN
, 0, peer_change_none
},
4414 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
4415 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
4416 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
4417 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
4418 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
4419 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
4420 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
4421 {PEER_FLAG_IFPEER_V6ONLY
, 0, peer_change_reset
},
4422 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
4423 {PEER_FLAG_TIMER
, 0, peer_change_none
},
4424 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
4425 {PEER_FLAG_TIMER_DELAYOPEN
, 0, peer_change_none
},
4426 {PEER_FLAG_PASSWORD
, 0, peer_change_none
},
4427 {PEER_FLAG_LOCAL_AS
, 0, peer_change_reset
},
4428 {PEER_FLAG_LOCAL_AS_NO_PREPEND
, 0, peer_change_reset
},
4429 {PEER_FLAG_LOCAL_AS_REPLACE_AS
, 0, peer_change_reset
},
4430 {PEER_FLAG_UPDATE_SOURCE
, 0, peer_change_none
},
4431 {PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
, 0, peer_change_none
},
4432 {PEER_FLAG_EXTENDED_OPT_PARAMS
, 0, peer_change_reset
},
4433 {PEER_FLAG_ROLE_STRICT_MODE
, 0, peer_change_reset
},
4434 {PEER_FLAG_ROLE
, 0, peer_change_reset
},
4435 {PEER_FLAG_PORT
, 0, peer_change_reset
},
4436 {PEER_FLAG_AIGP
, 0, peer_change_none
},
4437 {PEER_FLAG_GRACEFUL_SHUTDOWN
, 0, peer_change_none
},
4438 {PEER_FLAG_CAPABILITY_SOFT_VERSION
, 0, peer_change_reset
},
4441 static const struct peer_flag_action peer_af_flag_action_list
[] = {
4442 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
4443 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
4444 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
4445 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4446 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
4447 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
4448 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
4449 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
4450 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
4451 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
4452 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
4453 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
4454 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
4455 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
4456 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
4457 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
4458 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
4459 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
4460 {PEER_FLAG_MAX_PREFIX_FORCE
, 0, peer_change_none
},
4461 {PEER_FLAG_MAX_PREFIX_OUT
, 0, peer_change_none
},
4462 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
4463 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4464 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
4465 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
4466 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
4467 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
4468 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
4469 {PEER_FLAG_DISABLE_ADDPATH_RX
, 0, peer_change_reset
},
4470 {PEER_FLAG_SOO
, 0, peer_change_reset
},
4471 {PEER_FLAG_ACCEPT_OWN
, 0, peer_change_reset
},
4474 /* Proper action set. */
4475 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
4476 int size
, struct peer_flag_action
*action
,
4483 const struct peer_flag_action
*match
= NULL
;
4485 /* Check peer's frag action. */
4486 for (i
= 0; i
< size
; i
++) {
4487 match
= &action_list
[i
];
4489 if (match
->flag
== 0)
4492 if (match
->flag
& flag
) {
4495 if (match
->type
== peer_change_reset_in
)
4497 if (match
->type
== peer_change_reset_out
)
4499 if (match
->type
== peer_change_reset
) {
4503 if (match
->not_for_member
)
4504 action
->not_for_member
= 1;
4508 /* Set peer clear type. */
4509 if (reset_in
&& reset_out
)
4510 action
->type
= peer_change_reset
;
4512 action
->type
= peer_change_reset_in
;
4514 action
->type
= peer_change_reset_out
;
4516 action
->type
= peer_change_none
;
4521 static void peer_flag_modify_action(struct peer
*peer
, uint64_t flag
)
4523 if (flag
== PEER_FLAG_SHUTDOWN
) {
4524 if (CHECK_FLAG(peer
->flags
, flag
)) {
4525 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
4526 peer_nsf_stop(peer
);
4528 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
4530 if (peer
->t_pmax_restart
) {
4531 THREAD_OFF(peer
->t_pmax_restart
);
4532 if (bgp_debug_neighbor_events(peer
))
4534 "%pBP Maximum-prefix restart timer canceled",
4538 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4539 char *msg
= peer
->tx_shutdown_message
;
4541 uint8_t msgbuf
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4543 if (!msg
&& peer_group_active(peer
))
4544 msg
= peer
->group
->conf
4545 ->tx_shutdown_message
;
4546 msglen
= msg
? strlen(msg
) : 0;
4547 if (msglen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4548 msglen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4552 memcpy(msgbuf
+ 1, msg
, msglen
);
4554 bgp_notify_send_with_data(
4555 peer
, BGP_NOTIFY_CEASE
,
4556 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
4557 msgbuf
, msglen
+ 1);
4560 peer
, BGP_NOTIFY_CEASE
,
4561 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4563 bgp_session_reset(peer
);
4565 peer
->v_start
= BGP_INIT_START_TIMER
;
4566 BGP_EVENT_ADD(peer
, BGP_Stop
);
4568 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4569 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
4570 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4571 else if (flag
== PEER_FLAG_PASSIVE
)
4572 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
4573 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
4574 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
4576 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4577 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4579 bgp_session_reset(peer
);
4582 /* Enable global administrative shutdown of all peers of BGP instance */
4583 void bgp_shutdown_enable(struct bgp
*bgp
, const char *msg
)
4586 struct listnode
*node
;
4587 /* length(1) + message(N) */
4588 uint8_t data
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4590 /* do nothing if already shut down */
4591 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4594 /* informational log message */
4595 zlog_info("Enabled administrative shutdown on BGP instance AS %u",
4598 /* iterate through peers of BGP instance */
4599 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
4600 /* continue, if peer is already in administrative shutdown. */
4601 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
))
4604 /* send a RFC 4486 notification message if necessary */
4605 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4607 size_t datalen
= strlen(msg
);
4609 if (datalen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4610 datalen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4613 memcpy(data
+ 1, msg
, datalen
);
4615 bgp_notify_send_with_data(
4616 peer
, BGP_NOTIFY_CEASE
,
4617 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
, data
,
4621 peer
, BGP_NOTIFY_CEASE
,
4622 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4626 /* reset start timer to initial value */
4627 peer
->v_start
= BGP_INIT_START_TIMER
;
4629 /* trigger a RFC 4271 ManualStop event */
4630 BGP_EVENT_ADD(peer
, BGP_Stop
);
4633 /* set the BGP instances shutdown flag */
4634 SET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4637 /* Disable global administrative shutdown of all peers of BGP instance */
4638 void bgp_shutdown_disable(struct bgp
*bgp
)
4640 const struct listnode
*node
;
4643 /* do nothing if not shut down. */
4644 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4647 /* informational log message */
4648 zlog_info("Disabled administrative shutdown on BGP instance AS %u",
4651 /* clear the BGP instances shutdown flag */
4652 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4654 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
))
4655 bgp_timer_set(peer
);
4658 /* Change specified peer flag. */
4659 static int peer_flag_modify(struct peer
*peer
, uint64_t flag
, int set
)
4663 bool invert
, member_invert
;
4664 struct peer
*member
;
4665 struct listnode
*node
, *nnode
;
4666 struct peer_flag_action action
;
4668 memset(&action
, 0, sizeof(struct peer_flag_action
));
4669 size
= sizeof(peer_flag_action_list
) / sizeof(struct peer_flag_action
);
4671 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4672 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4675 /* Abort if no flag action exists. */
4677 return BGP_ERR_INVALID_FLAG
;
4679 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4680 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4681 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4682 return BGP_ERR_PEER_FLAG_CONFLICT
;
4684 /* Handle flag updates where desired state matches current state. */
4685 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4686 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4687 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4691 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4692 COND_FLAG(peer
->flags_override
, flag
, invert
);
4697 /* Inherit from peer-group or set/unset flags accordingly. */
4698 if (peer_group_active(peer
) && set
== invert
)
4699 peer_flag_inherit(peer
, flag
);
4701 COND_FLAG(peer
->flags
, flag
, set
);
4703 /* Check if handling a regular peer. */
4704 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4705 /* Update flag override state accordingly. */
4706 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4709 * For the extended next-hop encoding flag we need to turn RAs
4710 * on if flag is being set, but only turn RAs off if the flag
4711 * is being unset on this peer and if this peer is a member of a
4712 * peer-group, the peer-group also doesn't have the flag set.
4714 if (flag
== PEER_FLAG_CAPABILITY_ENHE
) {
4716 bgp_zebra_initiate_radv(peer
->bgp
, peer
);
4717 } else if (peer_group_active(peer
)) {
4718 if (!CHECK_FLAG(peer
->group
->conf
->flags
,
4721 bgp_zebra_terminate_radv(peer
->bgp
,
4724 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
4727 /* Execute flag action on peer. */
4728 if (action
.type
== peer_change_reset
)
4729 peer_flag_modify_action(peer
, flag
);
4731 /* Skip peer-group mechanics for regular peers. */
4736 * Update peer-group members, unless they are explicitly overriding
4737 * peer-group configuration.
4739 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4740 /* Skip peers with overridden configuration. */
4741 if (CHECK_FLAG(member
->flags_override
, flag
))
4744 /* Check if only member without group is inverted. */
4746 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4748 /* Skip peers with equivalent configuration. */
4749 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4752 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4755 /* Update flag on peer-group member. */
4756 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4758 if (flag
== PEER_FLAG_CAPABILITY_ENHE
&& !member
->conf_if
)
4759 set
? bgp_zebra_initiate_radv(member
->bgp
, member
)
4760 : bgp_zebra_terminate_radv(member
->bgp
, member
);
4762 /* Execute flag action on peer-group member. */
4763 if (action
.type
== peer_change_reset
)
4764 peer_flag_modify_action(member
, flag
);
4770 int peer_flag_set(struct peer
*peer
, uint64_t flag
)
4772 return peer_flag_modify(peer
, flag
, 1);
4775 int peer_flag_unset(struct peer
*peer
, uint64_t flag
)
4777 return peer_flag_modify(peer
, flag
, 0);
4780 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4781 uint64_t flag
, bool set
)
4785 bool invert
, member_invert
;
4786 struct peer
*member
;
4787 struct listnode
*node
, *nnode
;
4788 struct peer_flag_action action
;
4789 enum bgp_peer_sort ptype
;
4791 memset(&action
, 0, sizeof(struct peer_flag_action
));
4792 size
= sizeof(peer_af_flag_action_list
)
4793 / sizeof(struct peer_flag_action
);
4795 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4796 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4799 /* Abort if flag action exists. */
4801 return BGP_ERR_INVALID_FLAG
;
4803 ptype
= peer_sort(peer
);
4804 /* Special check for reflector client. */
4805 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
&& ptype
!= BGP_PEER_IBGP
)
4806 return BGP_ERR_NOT_INTERNAL_PEER
;
4808 /* Special check for remove-private-AS. */
4809 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
&& ptype
== BGP_PEER_IBGP
)
4810 return BGP_ERR_REMOVE_PRIVATE_AS
;
4812 /* as-override is not allowed for IBGP peers */
4813 if (flag
& PEER_FLAG_AS_OVERRIDE
&& ptype
== BGP_PEER_IBGP
)
4814 return BGP_ERR_AS_OVERRIDE
;
4816 /* Handle flag updates where desired state matches current state. */
4817 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4818 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4819 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4824 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4825 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4832 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4833 * if we are setting/unsetting flags which conflict with this flag
4834 * handle accordingly
4836 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4840 * if we are setting NEXTHOP_SELF, we need to unset the
4841 * NEXTHOP_UNCHANGED flag
4843 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4844 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4845 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4846 PEER_FLAG_NEXTHOP_UNCHANGED
);
4850 * if we are unsetting NEXTHOP_SELF, we need to set the
4851 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4853 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4854 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4855 SET_FLAG(peer
->af_flags
[afi
][safi
],
4856 PEER_FLAG_NEXTHOP_UNCHANGED
);
4861 * If the peer is a route server client let's not
4862 * muck with the nexthop on the way out the door
4864 if (flag
& PEER_FLAG_RSERVER_CLIENT
) {
4866 SET_FLAG(peer
->af_flags
[afi
][safi
],
4867 PEER_FLAG_NEXTHOP_UNCHANGED
);
4869 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4870 PEER_FLAG_NEXTHOP_UNCHANGED
);
4873 /* Inherit from peer-group or set/unset flags accordingly. */
4874 if (peer_group_active(peer
) && set
== invert
)
4875 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4877 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4879 /* Execute action when peer is established. */
4880 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4881 && peer_established(peer
)) {
4882 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4883 bgp_clear_adj_in(peer
, afi
, safi
);
4885 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4886 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4887 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4888 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4889 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4890 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4891 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4892 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4894 peer_change_action(peer
, afi
, safi
, action
.type
);
4898 /* Check if handling a regular peer. */
4899 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4900 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4904 * Update peer-group members, unless they are explicitly
4905 * overriding peer-group configuration.
4907 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4909 /* Skip peers with overridden configuration. */
4910 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4914 /* Check if only member without group is inverted. */
4916 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4920 /* Skip peers with equivalent configuration. */
4921 if (set
!= member_invert
4922 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4925 if (set
== member_invert
4926 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4929 /* Update flag on peer-group member. */
4930 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4931 set
!= member_invert
);
4933 /* Execute flag action on peer-group member. */
4934 if (peer_established(member
)) {
4935 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4936 bgp_clear_adj_in(member
, afi
, safi
);
4938 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4939 member
->last_reset
=
4940 PEER_DOWN_RR_CLIENT_CHANGE
;
4942 == PEER_FLAG_RSERVER_CLIENT
)
4943 member
->last_reset
=
4944 PEER_DOWN_RS_CLIENT_CHANGE
;
4946 == PEER_FLAG_ORF_PREFIX_SM
)
4947 member
->last_reset
=
4948 PEER_DOWN_CAPABILITY_CHANGE
;
4950 == PEER_FLAG_ORF_PREFIX_RM
)
4951 member
->last_reset
=
4952 PEER_DOWN_CAPABILITY_CHANGE
;
4954 peer_change_action(member
, afi
, safi
,
4964 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4966 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4969 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4971 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4975 void peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4977 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4978 peer
->tx_shutdown_message
=
4979 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4982 void peer_tx_shutdown_message_unset(struct peer
*peer
)
4984 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4988 /* EBGP multihop configuration. */
4989 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4991 struct peer_group
*group
;
4992 struct listnode
*node
, *nnode
;
4995 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4998 /* is there anything to do? */
4999 if (peer
->ttl
== ttl
)
5002 /* see comment in peer_ttl_security_hops_set() */
5003 if (ttl
!= MAXTTL
) {
5004 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5005 group
= peer
->group
;
5006 if (group
->conf
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5007 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5009 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
5011 if (peer1
->sort
== BGP_PEER_IBGP
)
5014 if (peer1
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5015 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5018 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
5019 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5025 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5026 if (peer
->sort
!= BGP_PEER_IBGP
) {
5027 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5028 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5029 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5031 bgp_session_reset(peer
);
5033 /* Reconfigure BFD peer with new TTL. */
5034 if (peer
->bfd_config
)
5035 bgp_peer_bfd_update_source(peer
);
5038 group
= peer
->group
;
5039 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5040 if (peer
->sort
== BGP_PEER_IBGP
)
5043 peer
->ttl
= group
->conf
->ttl
;
5045 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5046 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5047 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5049 bgp_session_reset(peer
);
5051 /* Reconfigure BFD peer with new TTL. */
5052 if (peer
->bfd_config
)
5053 bgp_peer_bfd_update_source(peer
);
5059 int peer_ebgp_multihop_unset(struct peer
*peer
)
5061 struct peer_group
*group
;
5062 struct listnode
*node
, *nnode
;
5065 if (peer
->sort
== BGP_PEER_IBGP
)
5068 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
&& peer
->ttl
!= MAXTTL
)
5069 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5071 if (peer_group_active(peer
))
5072 ttl
= peer
->group
->conf
->ttl
;
5074 ttl
= BGP_DEFAULT_TTL
;
5076 if (ttl
== peer
->ttl
)
5081 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5082 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5083 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5084 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5086 bgp_session_reset(peer
);
5088 /* Reconfigure BFD peer with new TTL. */
5089 if (peer
->bfd_config
)
5090 bgp_peer_bfd_update_source(peer
);
5092 group
= peer
->group
;
5093 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5094 if (peer
->sort
== BGP_PEER_IBGP
)
5097 peer
->ttl
= BGP_DEFAULT_TTL
;
5099 if (peer
->fd
>= 0) {
5100 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5102 peer
, BGP_NOTIFY_CEASE
,
5103 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5105 bgp_session_reset(peer
);
5108 /* Reconfigure BFD peer with new TTL. */
5109 if (peer
->bfd_config
)
5110 bgp_peer_bfd_update_source(peer
);
5116 /* Set Open Policy Role and check its correctness */
5117 int peer_role_set(struct peer
*peer
, uint8_t role
, bool strict_mode
)
5119 struct peer
*member
;
5120 struct listnode
*node
, *nnode
;
5122 peer_flag_set(peer
, PEER_FLAG_ROLE
);
5124 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5125 if (peer
->sort
!= BGP_PEER_EBGP
)
5126 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5128 if (peer
->local_role
== role
) {
5129 if (CHECK_FLAG(peer
->flags
,
5130 PEER_FLAG_ROLE_STRICT_MODE
) &&
5132 /* TODO: Is session restart needed if it was
5135 UNSET_FLAG(peer
->flags
,
5136 PEER_FLAG_ROLE_STRICT_MODE
);
5137 if (!CHECK_FLAG(peer
->flags
,
5138 PEER_FLAG_ROLE_STRICT_MODE
) &&
5140 SET_FLAG(peer
->flags
,
5141 PEER_FLAG_ROLE_STRICT_MODE
);
5142 /* Restart session to throw Role Mismatch
5145 if (peer
->remote_role
== ROLE_UNDEFINED
)
5146 bgp_session_reset(peer
);
5149 peer
->local_role
= role
;
5151 SET_FLAG(peer
->flags
,
5152 PEER_FLAG_ROLE_STRICT_MODE
);
5154 UNSET_FLAG(peer
->flags
,
5155 PEER_FLAG_ROLE_STRICT_MODE
);
5156 bgp_session_reset(peer
);
5162 peer
->local_role
= role
;
5163 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5164 if (member
->sort
!= BGP_PEER_EBGP
)
5165 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5167 if (member
->local_role
== role
) {
5168 if (CHECK_FLAG(member
->flags
,
5169 PEER_FLAG_ROLE_STRICT_MODE
) &&
5171 /* TODO: Is session restart needed if it was
5174 UNSET_FLAG(member
->flags
,
5175 PEER_FLAG_ROLE_STRICT_MODE
);
5176 if (!CHECK_FLAG(member
->flags
,
5177 PEER_FLAG_ROLE_STRICT_MODE
) &&
5179 SET_FLAG(peer
->flags
,
5180 PEER_FLAG_ROLE_STRICT_MODE
);
5181 SET_FLAG(member
->flags
,
5182 PEER_FLAG_ROLE_STRICT_MODE
);
5183 /* Restart session to throw Role Mismatch
5186 if (member
->remote_role
== ROLE_UNDEFINED
)
5187 bgp_session_reset(member
);
5190 member
->local_role
= role
;
5193 SET_FLAG(peer
->flags
,
5194 PEER_FLAG_ROLE_STRICT_MODE
);
5195 SET_FLAG(member
->flags
,
5196 PEER_FLAG_ROLE_STRICT_MODE
);
5198 UNSET_FLAG(member
->flags
,
5199 PEER_FLAG_ROLE_STRICT_MODE
);
5201 bgp_session_reset(member
);
5208 int peer_role_unset(struct peer
*peer
)
5210 struct peer
*member
;
5211 struct listnode
*node
, *nnode
;
5213 peer_flag_unset(peer
, PEER_FLAG_ROLE
);
5215 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5216 return peer_role_set(peer
, ROLE_UNDEFINED
, 0);
5218 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
))
5219 peer_role_set(member
, ROLE_UNDEFINED
, 0);
5224 /* Neighbor description. */
5225 void peer_description_set(struct peer
*peer
, const char *desc
)
5227 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5229 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
5232 void peer_description_unset(struct peer
*peer
)
5234 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5237 /* Neighbor update-source. */
5238 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
5240 struct peer
*member
;
5241 struct listnode
*node
, *nnode
;
5243 /* Set flag and configuration on peer. */
5244 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5245 if (peer
->update_if
) {
5246 if (strcmp(peer
->update_if
, ifname
) == 0)
5248 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5250 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5251 sockunion_free(peer
->update_source
);
5252 peer
->update_source
= NULL
;
5254 /* Check if handling a regular peer. */
5255 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5256 /* Send notification or reset peer depending on state. */
5257 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5258 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5259 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5260 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5262 bgp_session_reset(peer
);
5264 /* Apply new source configuration to BFD session. */
5265 if (peer
->bfd_config
)
5266 bgp_peer_bfd_update_source(peer
);
5268 /* Skip peer-group mechanics for regular peers. */
5273 * Set flag and configuration on all peer-group members, unless they are
5274 * explicitly overriding peer-group configuration.
5276 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5277 /* Skip peers with overridden configuration. */
5278 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5281 /* Skip peers with the same configuration. */
5282 if (member
->update_if
) {
5283 if (strcmp(member
->update_if
, ifname
) == 0)
5285 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5288 /* Set flag and configuration on peer-group member. */
5289 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5290 member
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5291 sockunion_free(member
->update_source
);
5292 member
->update_source
= NULL
;
5294 /* Send notification or reset peer depending on state. */
5295 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5296 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5297 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5298 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5300 bgp_session_reset(member
);
5302 /* Apply new source configuration to BFD session. */
5303 if (member
->bfd_config
)
5304 bgp_peer_bfd_update_source(member
);
5310 void peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
5312 struct peer
*member
;
5313 struct listnode
*node
, *nnode
;
5315 /* Set flag and configuration on peer. */
5316 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5317 if (peer
->update_source
) {
5318 if (sockunion_cmp(peer
->update_source
, su
) == 0)
5320 sockunion_free(peer
->update_source
);
5322 peer
->update_source
= sockunion_dup(su
);
5323 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5325 /* Check if handling a regular peer. */
5326 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5327 /* Send notification or reset peer depending on state. */
5328 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5329 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5330 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5331 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5333 bgp_session_reset(peer
);
5335 /* Apply new source configuration to BFD session. */
5336 if (peer
->bfd_config
)
5337 bgp_peer_bfd_update_source(peer
);
5339 /* Skip peer-group mechanics for regular peers. */
5344 * Set flag and configuration on all peer-group members, unless they are
5345 * explicitly overriding peer-group configuration.
5347 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5348 /* Skip peers with overridden configuration. */
5349 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5352 /* Skip peers with the same configuration. */
5353 if (member
->update_source
) {
5354 if (sockunion_cmp(member
->update_source
, su
) == 0)
5356 sockunion_free(member
->update_source
);
5359 /* Set flag and configuration on peer-group member. */
5360 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5361 member
->update_source
= sockunion_dup(su
);
5362 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5364 /* Send notification or reset peer depending on state. */
5365 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5366 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5367 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5368 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5370 bgp_session_reset(member
);
5372 /* Apply new source configuration to BFD session. */
5373 if (member
->bfd_config
)
5374 bgp_peer_bfd_update_source(member
);
5378 void peer_update_source_unset(struct peer
*peer
)
5380 struct peer
*member
;
5381 struct listnode
*node
, *nnode
;
5383 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_UPDATE_SOURCE
))
5386 /* Inherit configuration from peer-group if peer is member. */
5387 if (peer_group_active(peer
)) {
5388 peer_flag_inherit(peer
, PEER_FLAG_UPDATE_SOURCE
);
5389 PEER_SU_ATTR_INHERIT(peer
, peer
->group
, update_source
);
5390 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, update_if
,
5391 MTYPE_PEER_UPDATE_SOURCE
);
5393 /* Otherwise remove flag and configuration from peer. */
5394 peer_flag_unset(peer
, PEER_FLAG_UPDATE_SOURCE
);
5395 sockunion_free(peer
->update_source
);
5396 peer
->update_source
= NULL
;
5397 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5400 /* Check if handling a regular peer. */
5401 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5402 /* Send notification or reset peer depending on state. */
5403 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5404 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5405 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5406 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5408 bgp_session_reset(peer
);
5410 /* Apply new source configuration to BFD session. */
5411 if (peer
->bfd_config
)
5412 bgp_peer_bfd_update_source(peer
);
5414 /* Skip peer-group mechanics for regular peers. */
5419 * Set flag and configuration on all peer-group members, unless they are
5420 * explicitly overriding peer-group configuration.
5422 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5423 /* Skip peers with overridden configuration. */
5424 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5427 /* Skip peers with the same configuration. */
5428 if (!CHECK_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
)
5429 && !member
->update_source
&& !member
->update_if
)
5432 /* Remove flag and configuration on peer-group member. */
5433 UNSET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5434 sockunion_free(member
->update_source
);
5435 member
->update_source
= NULL
;
5436 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5438 /* Send notification or reset peer depending on state. */
5439 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5440 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5441 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5442 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5444 bgp_session_reset(member
);
5446 /* Apply new source configuration to BFD session. */
5447 if (member
->bfd_config
)
5448 bgp_peer_bfd_update_source(member
);
5452 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5453 const char *rmap
, struct route_map
*route_map
)
5455 struct peer
*member
;
5456 struct listnode
*node
, *nnode
;
5457 struct update_subgroup
*subgrp
;
5459 /* Set flag and configuration on peer. */
5460 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
5462 subgrp
= peer_subgroup(peer
, afi
, safi
);
5465 if (!peer
->default_rmap
[afi
][safi
].name
5466 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
5467 if (peer
->default_rmap
[afi
][safi
].name
)
5468 XFREE(MTYPE_ROUTE_MAP_NAME
,
5469 peer
->default_rmap
[afi
][safi
].name
);
5472 * When there is a change in route-map policy,
5473 * this flow gets triggered. Since, the default
5474 * route is already originated, the flag is set.
5475 * The flag should be unset here,
5476 * to trigger the flow of sending update message.
5479 UNSET_FLAG(subgrp
->sflags
,
5480 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5482 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5483 peer
->default_rmap
[afi
][safi
].name
=
5484 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5485 peer
->default_rmap
[afi
][safi
].map
= route_map
;
5486 route_map_counter_increment(route_map
);
5489 if (peer
->default_rmap
[afi
][safi
].name
)
5490 XFREE(MTYPE_ROUTE_MAP_NAME
,
5491 peer
->default_rmap
[afi
][safi
].name
);
5494 * This is triggered in case of route-map deletion.
5495 * The flag needs to be unset, to trigger the flow
5496 * of sending an update message.
5499 UNSET_FLAG(subgrp
->sflags
,
5500 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5502 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5503 peer
->default_rmap
[afi
][safi
].name
= NULL
;
5504 peer
->default_rmap
[afi
][safi
].map
= NULL
;
5507 /* Check if handling a regular peer. */
5508 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5509 /* Update peer route announcements. */
5510 if (peer_established(peer
) && peer
->afc_nego
[afi
][safi
]) {
5511 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5512 bgp_default_originate(peer
, afi
, safi
, 0);
5513 bgp_announce_route(peer
, afi
, safi
, false);
5516 /* Skip peer-group mechanics for regular peers. */
5521 * Set flag and configuration on all peer-group members, unless they are
5522 * explicitly overriding peer-group configuration.
5524 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5525 /* Skip peers with overridden configuration. */
5526 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5527 PEER_FLAG_DEFAULT_ORIGINATE
))
5530 /* Set flag and configuration on peer-group member. */
5531 SET_FLAG(member
->af_flags
[afi
][safi
],
5532 PEER_FLAG_DEFAULT_ORIGINATE
);
5534 if (member
->default_rmap
[afi
][safi
].name
)
5535 XFREE(MTYPE_ROUTE_MAP_NAME
,
5536 member
->default_rmap
[afi
][safi
].name
);
5537 route_map_counter_decrement(
5538 member
->default_rmap
[afi
][safi
].map
);
5539 member
->default_rmap
[afi
][safi
].name
=
5540 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5541 member
->default_rmap
[afi
][safi
].map
= route_map
;
5542 route_map_counter_increment(route_map
);
5545 /* Update peer route announcements. */
5546 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5547 update_group_adjust_peer(
5548 peer_af_find(member
, afi
, safi
));
5549 bgp_default_originate(member
, afi
, safi
, 0);
5550 bgp_announce_route(member
, afi
, safi
, false);
5557 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5559 struct peer
*member
;
5560 struct listnode
*node
, *nnode
;
5562 /* Inherit configuration from peer-group if peer is member. */
5563 if (peer_group_active(peer
)) {
5564 peer_af_flag_inherit(peer
, afi
, safi
,
5565 PEER_FLAG_DEFAULT_ORIGINATE
);
5566 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5567 default_rmap
[afi
][safi
].name
,
5568 MTYPE_ROUTE_MAP_NAME
);
5569 PEER_ATTR_INHERIT(peer
, peer
->group
,
5570 default_rmap
[afi
][safi
].map
);
5572 /* Otherwise remove flag and configuration from peer. */
5573 peer_af_flag_unset(peer
, afi
, safi
,
5574 PEER_FLAG_DEFAULT_ORIGINATE
);
5575 if (peer
->default_rmap
[afi
][safi
].name
)
5576 XFREE(MTYPE_ROUTE_MAP_NAME
,
5577 peer
->default_rmap
[afi
][safi
].name
);
5578 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5579 peer
->default_rmap
[afi
][safi
].name
= NULL
;
5580 peer
->default_rmap
[afi
][safi
].map
= NULL
;
5583 /* Check if handling a regular peer. */
5584 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5585 /* Update peer route announcements. */
5586 if (peer_established(peer
) && peer
->afc_nego
[afi
][safi
]) {
5587 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5588 bgp_default_originate(peer
, afi
, safi
, 1);
5589 bgp_announce_route(peer
, afi
, safi
, false);
5592 /* Skip peer-group mechanics for regular peers. */
5597 * Remove flag and configuration from all peer-group members, unless
5598 * they are explicitly overriding peer-group configuration.
5600 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5601 /* Skip peers with overridden configuration. */
5602 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5603 PEER_FLAG_DEFAULT_ORIGINATE
))
5606 /* Remove flag and configuration on peer-group member. */
5607 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5608 PEER_FLAG_DEFAULT_ORIGINATE
);
5609 if (member
->default_rmap
[afi
][safi
].name
)
5610 XFREE(MTYPE_ROUTE_MAP_NAME
,
5611 member
->default_rmap
[afi
][safi
].name
);
5612 route_map_counter_decrement(member
->default_rmap
[afi
][safi
].map
);
5613 member
->default_rmap
[afi
][safi
].name
= NULL
;
5614 member
->default_rmap
[afi
][safi
].map
= NULL
;
5616 /* Update peer route announcements. */
5617 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5618 update_group_adjust_peer(peer_af_find(member
, afi
, safi
));
5619 bgp_default_originate(member
, afi
, safi
, 1);
5620 bgp_announce_route(member
, afi
, safi
, false);
5627 void peer_port_set(struct peer
*peer
, uint16_t port
)
5630 peer_flag_set(peer
, PEER_FLAG_PORT
);
5633 void peer_port_unset(struct peer
*peer
)
5635 peer
->port
= BGP_PORT_DEFAULT
;
5636 peer_flag_unset(peer
, PEER_FLAG_PORT
);
5639 /* Set the TCP-MSS value in the peer structure,
5640 * This gets applied only after connection reset
5641 * So this value will be used in bgp_connect.
5643 void peer_tcp_mss_set(struct peer
*peer
, uint32_t tcp_mss
)
5645 peer
->tcp_mss
= tcp_mss
;
5646 SET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5649 /* Reset the TCP-MSS value in the peer structure,
5650 * This gets applied only after connection reset
5651 * So this value will be used in bgp_connect.
5653 void peer_tcp_mss_unset(struct peer
*peer
)
5655 UNSET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5660 * Helper function that is called after the name of the policy
5661 * being used by a peer has changed (AF specific). Automatically
5662 * initiates inbound or outbound processing as needed.
5664 void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
5668 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5669 if (peer_established(peer
))
5670 bgp_announce_route(peer
, afi
, safi
, false);
5672 if (!peer_established(peer
))
5675 if (bgp_soft_reconfig_in(peer
, afi
, safi
))
5678 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
) ||
5679 CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
)) {
5680 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5681 PEER_CAP_ORF_PREFIX_SM_ADV
) &&
5682 (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5683 PEER_CAP_ORF_PREFIX_RM_RCV
) ||
5684 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5685 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
5686 peer_clear_soft(peer
, afi
, safi
,
5687 BGP_CLEAR_SOFT_IN_ORF_PREFIX
);
5689 bgp_route_refresh_send(
5690 peer
, afi
, safi
, 0, 0, 0,
5691 BGP_ROUTE_REFRESH_NORMAL
);
5697 /* neighbor weight. */
5698 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
5700 struct peer
*member
;
5701 struct listnode
*node
, *nnode
;
5703 /* Set flag and configuration on peer. */
5704 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5705 if (peer
->weight
[afi
][safi
] != weight
) {
5706 peer
->weight
[afi
][safi
] = weight
;
5707 peer_on_policy_change(peer
, afi
, safi
, 0);
5710 /* Skip peer-group mechanics for regular peers. */
5711 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5715 * Set flag and configuration on all peer-group members, unless they are
5716 * explicitly overriding peer-group configuration.
5718 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5719 /* Skip peers with overridden configuration. */
5720 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5724 /* Set flag and configuration on peer-group member. */
5725 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5726 if (member
->weight
[afi
][safi
] != weight
) {
5727 member
->weight
[afi
][safi
] = weight
;
5728 peer_on_policy_change(member
, afi
, safi
, 0);
5735 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5737 struct peer
*member
;
5738 struct listnode
*node
, *nnode
;
5740 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5743 /* Inherit configuration from peer-group if peer is member. */
5744 if (peer_group_active(peer
)) {
5745 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5746 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
5748 peer_on_policy_change(peer
, afi
, safi
, 0);
5752 /* Remove flag and configuration from peer. */
5753 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5754 peer
->weight
[afi
][safi
] = 0;
5755 peer_on_policy_change(peer
, afi
, safi
, 0);
5757 /* Skip peer-group mechanics for regular peers. */
5758 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5762 * Remove flag and configuration from all peer-group members, unless
5763 * they are explicitly overriding peer-group configuration.
5765 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5766 /* Skip peers with overridden configuration. */
5767 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5771 /* Skip peers where flag is already disabled. */
5772 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5775 /* Remove flag and configuration on peer-group member. */
5776 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5777 member
->weight
[afi
][safi
] = 0;
5778 peer_on_policy_change(member
, afi
, safi
, 0);
5784 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
5786 struct peer
*member
;
5787 struct listnode
*node
, *nnode
;
5789 if (keepalive
> UINT16_MAX
)
5790 return BGP_ERR_INVALID_VALUE
;
5792 if (holdtime
> UINT16_MAX
)
5793 return BGP_ERR_INVALID_VALUE
;
5795 if (holdtime
< 3 && holdtime
!= 0)
5796 return BGP_ERR_INVALID_VALUE
;
5798 /* Set flag and configuration on peer. */
5799 peer_flag_set(peer
, PEER_FLAG_TIMER
);
5800 peer
->holdtime
= holdtime
;
5801 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
5803 /* Skip peer-group mechanics for regular peers. */
5804 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5808 * Set flag and configuration on all peer-group members, unless they are
5809 * explicitly overriding peer-group configuration.
5811 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5812 /* Skip peers with overridden configuration. */
5813 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5816 /* Set flag and configuration on peer-group member. */
5817 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5818 PEER_ATTR_INHERIT(member
, peer
->group
, holdtime
);
5819 PEER_ATTR_INHERIT(member
, peer
->group
, keepalive
);
5825 int peer_timers_unset(struct peer
*peer
)
5827 struct peer
*member
;
5828 struct listnode
*node
, *nnode
;
5830 /* Inherit configuration from peer-group if peer is member. */
5831 if (peer_group_active(peer
)) {
5832 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
5833 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
5834 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
5836 /* Otherwise remove flag and configuration from peer. */
5837 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
5839 peer
->keepalive
= 0;
5842 /* Skip peer-group mechanics for regular peers. */
5843 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5847 * Remove flag and configuration from all peer-group members, unless
5848 * they are explicitly overriding peer-group configuration.
5850 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5851 /* Skip peers with overridden configuration. */
5852 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5855 /* Remove flag and configuration on peer-group member. */
5856 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5857 member
->holdtime
= 0;
5858 member
->keepalive
= 0;
5864 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
5866 struct peer
*member
;
5867 struct listnode
*node
, *nnode
;
5869 if (connect
> UINT16_MAX
)
5870 return BGP_ERR_INVALID_VALUE
;
5872 /* Set flag and configuration on peer. */
5873 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
5874 peer
->connect
= connect
;
5875 peer
->v_connect
= connect
;
5877 /* Skip peer-group mechanics for regular peers. */
5878 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5879 if (!peer_established(peer
)) {
5880 if (peer_active(peer
))
5881 BGP_EVENT_ADD(peer
, BGP_Stop
);
5882 BGP_EVENT_ADD(peer
, BGP_Start
);
5887 * Set flag and configuration on all peer-group members, unless they are
5888 * explicitly overriding peer-group configuration.
5890 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5891 /* Skip peers with overridden configuration. */
5892 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5895 /* Set flag and configuration on peer-group member. */
5896 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5897 member
->connect
= connect
;
5898 member
->v_connect
= connect
;
5900 if (!peer_established(member
)) {
5901 if (peer_active(member
))
5902 BGP_EVENT_ADD(member
, BGP_Stop
);
5903 BGP_EVENT_ADD(member
, BGP_Start
);
5910 int peer_timers_connect_unset(struct peer
*peer
)
5912 struct peer
*member
;
5913 struct listnode
*node
, *nnode
;
5915 /* Inherit configuration from peer-group if peer is member. */
5916 if (peer_group_active(peer
)) {
5917 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5918 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5920 /* Otherwise remove flag and configuration from peer. */
5921 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5925 /* Set timer with fallback to default value. */
5927 peer
->v_connect
= peer
->connect
;
5929 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
5931 /* Skip peer-group mechanics for regular peers. */
5932 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5933 if (!peer_established(peer
)) {
5934 if (peer_active(peer
))
5935 BGP_EVENT_ADD(peer
, BGP_Stop
);
5936 BGP_EVENT_ADD(peer
, BGP_Start
);
5941 * Remove flag and configuration from all peer-group members, unless
5942 * they are explicitly overriding peer-group configuration.
5944 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5945 /* Skip peers with overridden configuration. */
5946 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5949 /* Remove flag and configuration on peer-group member. */
5950 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5951 member
->connect
= 0;
5952 member
->v_connect
= peer
->bgp
->default_connect_retry
;
5954 if (!peer_established(member
)) {
5955 if (peer_active(member
))
5956 BGP_EVENT_ADD(member
, BGP_Stop
);
5957 BGP_EVENT_ADD(member
, BGP_Start
);
5964 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5966 struct peer
*member
;
5967 struct listnode
*node
, *nnode
;
5970 return BGP_ERR_INVALID_VALUE
;
5972 /* Set flag and configuration on peer. */
5973 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5974 peer
->routeadv
= routeadv
;
5975 peer
->v_routeadv
= routeadv
;
5977 /* Check if handling a regular peer. */
5978 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5979 /* Update peer route announcements. */
5980 update_group_adjust_peer_afs(peer
);
5981 if (peer_established(peer
))
5982 bgp_announce_route_all(peer
);
5984 /* Skip peer-group mechanics for regular peers. */
5989 * Set flag and configuration on all peer-group members, unless they are
5990 * explicitly overriding peer-group configuration.
5992 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5993 /* Skip peers with overridden configuration. */
5994 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5997 /* Set flag and configuration on peer-group member. */
5998 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5999 member
->routeadv
= routeadv
;
6000 member
->v_routeadv
= routeadv
;
6002 /* Update peer route announcements. */
6003 update_group_adjust_peer_afs(member
);
6004 if (peer_established(member
))
6005 bgp_announce_route_all(member
);
6011 int peer_advertise_interval_unset(struct peer
*peer
)
6013 struct peer
*member
;
6014 struct listnode
*node
, *nnode
;
6016 /* Inherit configuration from peer-group if peer is member. */
6017 if (peer_group_active(peer
)) {
6018 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
6019 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
6021 /* Otherwise remove flag and configuration from peer. */
6022 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
6026 /* Set timer with fallback to default value. */
6028 peer
->v_routeadv
= peer
->routeadv
;
6030 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
6031 ? BGP_DEFAULT_IBGP_ROUTEADV
6032 : BGP_DEFAULT_EBGP_ROUTEADV
;
6034 /* Check if handling a regular peer. */
6035 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6036 /* Update peer route announcements. */
6037 update_group_adjust_peer_afs(peer
);
6038 if (peer_established(peer
))
6039 bgp_announce_route_all(peer
);
6041 /* Skip peer-group mechanics for regular peers. */
6046 * Remove flag and configuration from all peer-group members, unless
6047 * they are explicitly overriding peer-group configuration.
6049 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6050 /* Skip peers with overridden configuration. */
6051 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
6054 /* Remove flag and configuration on peer-group member. */
6055 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
6056 member
->routeadv
= 0;
6057 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
6058 ? BGP_DEFAULT_IBGP_ROUTEADV
6059 : BGP_DEFAULT_EBGP_ROUTEADV
;
6061 /* Update peer route announcements. */
6062 update_group_adjust_peer_afs(member
);
6063 if (peer_established(member
))
6064 bgp_announce_route_all(member
);
6070 /* set the peers RFC 4271 DelayOpen session attribute flag and DelayOpenTimer
6073 int peer_timers_delayopen_set(struct peer
*peer
, uint32_t delayopen
)
6075 struct peer
*member
;
6076 struct listnode
*node
;
6078 /* Set peers session attribute flag and timer interval. */
6079 peer_flag_set(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6080 peer
->delayopen
= delayopen
;
6081 peer
->v_delayopen
= delayopen
;
6083 /* Skip group mechanics for regular peers. */
6084 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6087 /* Set flag and configuration on all peer-group members, unless they are
6088 * explicitly overriding peer-group configuration.
6090 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6091 /* Skip peers with overridden configuration. */
6092 if (CHECK_FLAG(member
->flags_override
,
6093 PEER_FLAG_TIMER_DELAYOPEN
))
6096 /* Set session attribute flag and timer intervals on peer-group
6099 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6100 member
->delayopen
= delayopen
;
6101 member
->v_delayopen
= delayopen
;
6107 /* unset the peers RFC 4271 DelayOpen session attribute flag and reset the
6108 * DelayOpenTimer interval to the default value.
6110 int peer_timers_delayopen_unset(struct peer
*peer
)
6112 struct peer
*member
;
6113 struct listnode
*node
;
6115 /* Inherit configuration from peer-group if peer is member. */
6116 if (peer_group_active(peer
)) {
6117 peer_flag_inherit(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6118 PEER_ATTR_INHERIT(peer
, peer
->group
, delayopen
);
6120 /* Otherwise remove session attribute flag and set timer
6121 * interval to default value.
6123 peer_flag_unset(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6124 peer
->delayopen
= peer
->bgp
->default_delayopen
;
6127 /* Set timer value to zero */
6128 peer
->v_delayopen
= 0;
6130 /* Skip peer-group mechanics for regular peers. */
6131 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6134 /* Remove flag and configuration from all peer-group members, unless
6135 * they are explicitly overriding peer-group configuration.
6137 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6138 /* Skip peers with overridden configuration. */
6139 if (CHECK_FLAG(member
->flags_override
,
6140 PEER_FLAG_TIMER_DELAYOPEN
))
6143 /* Remove session attribute flag, reset the timer interval to
6144 * the default value and set the timer value to zero.
6146 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6147 member
->delayopen
= peer
->bgp
->default_delayopen
;
6148 member
->v_delayopen
= 0;
6154 /* neighbor interface */
6155 void peer_interface_set(struct peer
*peer
, const char *str
)
6157 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6158 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
6161 void peer_interface_unset(struct peer
*peer
)
6163 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6167 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6168 int allow_num
, int origin
)
6170 struct peer
*member
;
6171 struct listnode
*node
, *nnode
;
6173 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
6174 return BGP_ERR_INVALID_VALUE
;
6176 /* Set flag and configuration on peer. */
6177 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6179 if (peer
->allowas_in
[afi
][safi
] != 0
6180 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6181 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6182 peer_af_flag_set(peer
, afi
, safi
,
6183 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6184 peer
->allowas_in
[afi
][safi
] = 0;
6185 peer_on_policy_change(peer
, afi
, safi
, 0);
6188 if (peer
->allowas_in
[afi
][safi
] != allow_num
6189 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6190 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6192 peer_af_flag_unset(peer
, afi
, safi
,
6193 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6194 peer
->allowas_in
[afi
][safi
] = allow_num
;
6195 peer_on_policy_change(peer
, afi
, safi
, 0);
6199 /* Skip peer-group mechanics for regular peers. */
6200 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6204 * Set flag and configuration on all peer-group members, unless
6205 * they are explicitly overriding peer-group configuration.
6207 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6208 /* Skip peers with overridden configuration. */
6209 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6210 PEER_FLAG_ALLOWAS_IN
))
6213 /* Set flag and configuration on peer-group member. */
6214 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6216 if (member
->allowas_in
[afi
][safi
] != 0
6217 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
6218 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6219 SET_FLAG(member
->af_flags
[afi
][safi
],
6220 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6221 member
->allowas_in
[afi
][safi
] = 0;
6222 peer_on_policy_change(peer
, afi
, safi
, 0);
6225 if (member
->allowas_in
[afi
][safi
] != allow_num
6226 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
6227 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6228 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6229 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6230 member
->allowas_in
[afi
][safi
] = allow_num
;
6231 peer_on_policy_change(peer
, afi
, safi
, 0);
6239 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6241 struct peer
*member
;
6242 struct listnode
*node
, *nnode
;
6244 /* Skip peer if flag is already disabled. */
6245 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
6248 /* Inherit configuration from peer-group if peer is member. */
6249 if (peer_group_active(peer
)) {
6250 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6251 peer_af_flag_inherit(peer
, afi
, safi
,
6252 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6253 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
6254 peer_on_policy_change(peer
, afi
, safi
, 0);
6259 /* Remove flag and configuration from peer. */
6260 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6261 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6262 peer
->allowas_in
[afi
][safi
] = 0;
6263 peer_on_policy_change(peer
, afi
, safi
, 0);
6265 /* Skip peer-group mechanics if handling a regular peer. */
6266 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6270 * Remove flags and configuration from all peer-group members, unless
6271 * they are explicitly overriding peer-group configuration.
6273 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6274 /* Skip peers with overridden configuration. */
6275 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6276 PEER_FLAG_ALLOWAS_IN
))
6279 /* Remove flags and configuration on peer-group member. */
6280 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6281 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6282 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6283 member
->allowas_in
[afi
][safi
] = 0;
6284 peer_on_policy_change(member
, afi
, safi
, 0);
6290 int peer_local_as_set(struct peer
*peer
, as_t as
, bool no_prepend
,
6291 bool replace_as
, const char *as_str
)
6293 bool old_no_prepend
, old_replace_as
;
6294 struct bgp
*bgp
= peer
->bgp
;
6295 struct peer
*member
;
6296 struct listnode
*node
, *nnode
;
6299 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
6301 /* Save previous flag states. */
6303 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6305 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6307 /* Set flag and configuration on peer. */
6308 peer_flag_set(peer
, PEER_FLAG_LOCAL_AS
);
6309 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
, no_prepend
);
6310 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
, replace_as
);
6312 if (peer
->change_local_as
== as
&& old_no_prepend
== no_prepend
6313 && old_replace_as
== replace_as
)
6315 peer
->change_local_as
= as
;
6317 if (peer
->change_local_as_pretty
)
6318 XFREE(MTYPE_BGP
, peer
->change_local_as_pretty
);
6319 peer
->change_local_as_pretty
= XSTRDUP(MTYPE_BGP
, as_str
);
6322 (void)peer_sort(peer
);
6324 /* Check if handling a regular peer. */
6325 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6329 * Set flag and configuration on all peer-group members, unless they are
6330 * explicitly overriding peer-group configuration.
6332 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6333 /* Skip peers with overridden configuration. */
6334 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6337 /* Skip peers with the same configuration. */
6338 old_no_prepend
= CHECK_FLAG(member
->flags
,
6339 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6340 old_replace_as
= CHECK_FLAG(member
->flags
,
6341 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6342 if (member
->change_local_as
== as
6343 && CHECK_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
)
6344 && old_no_prepend
== no_prepend
6345 && old_replace_as
== replace_as
)
6348 /* Set flag and configuration on peer-group member. */
6349 SET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6350 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
,
6352 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
,
6354 member
->change_local_as
= as
;
6356 member
->change_local_as_pretty
=
6357 XSTRDUP(MTYPE_BGP
, as_str
);
6363 int peer_local_as_unset(struct peer
*peer
)
6365 struct peer
*member
;
6366 struct listnode
*node
, *nnode
;
6368 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS
))
6371 /* Inherit configuration from peer-group if peer is member. */
6372 if (peer_group_active(peer
)) {
6373 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS
);
6374 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6375 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6376 PEER_ATTR_INHERIT(peer
, peer
->group
, change_local_as
);
6378 /* Otherwise remove flag and configuration from peer. */
6379 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
6380 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6381 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6382 peer
->change_local_as
= 0;
6383 XFREE(MTYPE_BGP
, peer
->change_local_as_pretty
);
6386 /* Check if handling a regular peer. */
6387 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6388 /* Send notification or stop peer depending on state. */
6389 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
6390 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6391 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6392 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6394 BGP_EVENT_ADD(peer
, BGP_Stop
);
6396 /* Skip peer-group mechanics for regular peers. */
6401 * Remove flag and configuration from all peer-group members, unless
6402 * they are explicitly overriding peer-group configuration.
6404 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6405 /* Skip peers with overridden configuration. */
6406 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6409 /* Remove flag and configuration on peer-group member. */
6410 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6411 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6412 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6413 member
->change_local_as
= 0;
6414 XFREE(MTYPE_BGP
, member
->change_local_as_pretty
);
6416 /* Send notification or stop peer depending on state. */
6417 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
6418 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6419 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6420 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6422 bgp_session_reset(member
);
6428 /* Set password for authenticating with the peer. */
6429 int peer_password_set(struct peer
*peer
, const char *password
)
6431 struct peer
*member
;
6432 struct listnode
*node
, *nnode
;
6433 int len
= password
? strlen(password
) : 0;
6434 int ret
= BGP_SUCCESS
;
6436 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
6437 return BGP_ERR_INVALID_VALUE
;
6439 /* Set flag and configuration on peer. */
6440 peer_flag_set(peer
, PEER_FLAG_PASSWORD
);
6441 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
6443 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6444 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6446 /* Check if handling a regular peer. */
6447 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6448 /* Send notification or reset peer depending on state. */
6449 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6450 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6451 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6453 bgp_session_reset(peer
);
6456 * Attempt to install password on socket and skip peer-group
6459 if (BGP_PEER_SU_UNSPEC(peer
))
6461 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
6462 : BGP_ERR_TCPSIG_FAILED
;
6466 * Set flag and configuration on all peer-group members, unless they are
6467 * explicitly overriding peer-group configuration.
6469 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6470 /* Skip peers with overridden configuration. */
6471 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6474 /* Skip peers with the same password. */
6475 if (member
->password
&& strcmp(member
->password
, password
) == 0)
6478 /* Set flag and configuration on peer-group member. */
6479 SET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6480 if (member
->password
)
6481 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6482 member
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6484 /* Send notification or reset peer depending on state. */
6485 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6486 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6487 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6489 bgp_session_reset(member
);
6491 /* Attempt to install password on socket. */
6492 if (!BGP_PEER_SU_UNSPEC(member
) && bgp_md5_set(member
) < 0)
6493 ret
= BGP_ERR_TCPSIG_FAILED
;
6496 /* Set flag and configuration on all peer-group listen ranges */
6497 struct listnode
*ln
;
6500 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6501 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6502 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6503 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6508 int peer_password_unset(struct peer
*peer
)
6510 struct peer
*member
;
6511 struct listnode
*node
, *nnode
;
6513 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
))
6516 /* Inherit configuration from peer-group if peer is member. */
6517 if (peer_group_active(peer
)) {
6518 peer_flag_inherit(peer
, PEER_FLAG_PASSWORD
);
6519 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, password
,
6520 MTYPE_PEER_PASSWORD
);
6522 /* Otherwise remove flag and configuration from peer. */
6523 peer_flag_unset(peer
, PEER_FLAG_PASSWORD
);
6524 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6527 /* Check if handling a regular peer. */
6528 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6529 /* Send notification or reset peer depending on state. */
6530 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6531 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6532 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6534 bgp_session_reset(peer
);
6536 /* Attempt to uninstall password on socket. */
6537 if (!BGP_PEER_SU_UNSPEC(peer
))
6538 bgp_md5_unset(peer
);
6539 /* Skip peer-group mechanics for regular peers. */
6544 * Remove flag and configuration from all peer-group members, unless
6545 * they are explicitly overriding peer-group configuration.
6547 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6548 /* Skip peers with overridden configuration. */
6549 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6552 /* Remove flag and configuration on peer-group member. */
6553 UNSET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6554 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6556 /* Send notification or reset peer depending on state. */
6557 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6558 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6559 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6561 bgp_session_reset(member
);
6563 /* Attempt to uninstall password on socket. */
6564 if (!BGP_PEER_SU_UNSPEC(member
))
6565 bgp_md5_unset(member
);
6568 /* Set flag and configuration on all peer-group listen ranges */
6569 struct listnode
*ln
;
6572 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6573 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6574 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6575 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6581 /* Set distribute list to the peer. */
6582 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6585 struct peer
*member
;
6586 struct bgp_filter
*filter
;
6587 struct listnode
*node
, *nnode
;
6589 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6590 return BGP_ERR_INVALID_VALUE
;
6592 /* Set configuration on peer. */
6593 filter
= &peer
->filter
[afi
][safi
];
6594 if (filter
->plist
[direct
].name
)
6595 return BGP_ERR_PEER_FILTER_CONFLICT
;
6596 if (filter
->dlist
[direct
].name
)
6597 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
6598 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6599 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6601 /* Check if handling a regular peer. */
6602 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6603 /* Set override-flag and process peer route updates. */
6604 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6605 PEER_FT_DISTRIBUTE_LIST
);
6606 peer_on_policy_change(peer
, afi
, safi
,
6607 (direct
== FILTER_OUT
) ? 1 : 0);
6609 /* Skip peer-group mechanics for regular peers. */
6614 * Set configuration on all peer-group members, un less they are
6615 * explicitly overriding peer-group configuration.
6617 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6618 /* Skip peers with overridden configuration. */
6619 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6620 PEER_FT_DISTRIBUTE_LIST
))
6623 /* Set configuration on peer-group member. */
6624 filter
= &member
->filter
[afi
][safi
];
6625 if (filter
->dlist
[direct
].name
)
6626 XFREE(MTYPE_BGP_FILTER_NAME
,
6627 filter
->dlist
[direct
].name
);
6628 filter
->dlist
[direct
].name
=
6629 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6630 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6632 /* Process peer route updates. */
6633 peer_on_policy_change(member
, afi
, safi
,
6634 (direct
== FILTER_OUT
) ? 1 : 0);
6640 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6642 struct peer
*member
;
6643 struct bgp_filter
*filter
;
6644 struct listnode
*node
, *nnode
;
6646 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6647 return BGP_ERR_INVALID_VALUE
;
6649 /* Unset override-flag unconditionally. */
6650 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6651 PEER_FT_DISTRIBUTE_LIST
);
6653 /* Inherit configuration from peer-group if peer is member. */
6654 if (peer_group_active(peer
)) {
6655 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6656 filter
[afi
][safi
].dlist
[direct
].name
,
6657 MTYPE_BGP_FILTER_NAME
);
6658 PEER_ATTR_INHERIT(peer
, peer
->group
,
6659 filter
[afi
][safi
].dlist
[direct
].alist
);
6661 /* Otherwise remove configuration from peer. */
6662 filter
= &peer
->filter
[afi
][safi
];
6663 if (filter
->dlist
[direct
].name
)
6664 XFREE(MTYPE_BGP_FILTER_NAME
,
6665 filter
->dlist
[direct
].name
);
6666 filter
->dlist
[direct
].name
= NULL
;
6667 filter
->dlist
[direct
].alist
= NULL
;
6670 /* Check if handling a regular peer. */
6671 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6672 /* Process peer route updates. */
6673 peer_on_policy_change(peer
, afi
, safi
,
6674 (direct
== FILTER_OUT
) ? 1 : 0);
6676 /* Skip peer-group mechanics for regular peers. */
6681 * Remove configuration on all peer-group members, unless they are
6682 * explicitly overriding peer-group configuration.
6684 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6685 /* Skip peers with overridden configuration. */
6686 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6687 PEER_FT_DISTRIBUTE_LIST
))
6690 /* Remove configuration on peer-group member. */
6691 filter
= &member
->filter
[afi
][safi
];
6692 if (filter
->dlist
[direct
].name
)
6693 XFREE(MTYPE_BGP_FILTER_NAME
,
6694 filter
->dlist
[direct
].name
);
6695 filter
->dlist
[direct
].name
= NULL
;
6696 filter
->dlist
[direct
].alist
= NULL
;
6698 /* Process peer route updates. */
6699 peer_on_policy_change(member
, afi
, safi
,
6700 (direct
== FILTER_OUT
) ? 1 : 0);
6706 /* Update distribute list. */
6707 static void peer_distribute_update(struct access_list
*access
)
6712 struct listnode
*mnode
, *mnnode
;
6713 struct listnode
*node
, *nnode
;
6716 struct peer_group
*group
;
6717 struct bgp_filter
*filter
;
6719 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6721 update_group_policy_update(bgp
,
6722 BGP_POLICY_DISTRIBUTE_LIST
,
6723 access
->name
, true, 0);
6724 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6725 FOREACH_AFI_SAFI (afi
, safi
) {
6726 filter
= &peer
->filter
[afi
][safi
];
6728 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6730 if (filter
->dlist
[direct
].name
)
6731 filter
->dlist
[direct
]
6732 .alist
= access_list_lookup(
6734 filter
->dlist
[direct
]
6737 filter
->dlist
[direct
].alist
=
6742 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6743 FOREACH_AFI_SAFI (afi
, safi
) {
6744 filter
= &group
->conf
->filter
[afi
][safi
];
6746 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6748 if (filter
->dlist
[direct
].name
)
6749 filter
->dlist
[direct
]
6750 .alist
= access_list_lookup(
6752 filter
->dlist
[direct
]
6755 filter
->dlist
[direct
].alist
=
6760 #ifdef ENABLE_BGP_VNC
6761 vnc_prefix_list_update(bgp
);
6766 /* Set prefix list to the peer. */
6767 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6770 struct peer
*member
;
6771 struct bgp_filter
*filter
;
6772 struct listnode
*node
, *nnode
;
6774 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6775 return BGP_ERR_INVALID_VALUE
;
6777 /* Set configuration on peer. */
6778 filter
= &peer
->filter
[afi
][safi
];
6779 if (filter
->dlist
[direct
].name
)
6780 return BGP_ERR_PEER_FILTER_CONFLICT
;
6781 if (filter
->plist
[direct
].name
)
6782 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
6783 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6784 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6786 /* Check if handling a regular peer. */
6787 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6788 /* Set override-flag and process peer route updates. */
6789 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6790 PEER_FT_PREFIX_LIST
);
6791 peer_on_policy_change(peer
, afi
, safi
,
6792 (direct
== FILTER_OUT
) ? 1 : 0);
6794 /* Skip peer-group mechanics for regular peers. */
6799 * Set configuration on all peer-group members, unless they are
6800 * explicitly overriding peer-group configuration.
6802 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6803 /* Skip peers with overridden configuration. */
6804 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6805 PEER_FT_PREFIX_LIST
))
6808 /* Set configuration on peer-group member. */
6809 filter
= &member
->filter
[afi
][safi
];
6810 if (filter
->plist
[direct
].name
)
6811 XFREE(MTYPE_BGP_FILTER_NAME
,
6812 filter
->plist
[direct
].name
);
6813 filter
->plist
[direct
].name
=
6814 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6815 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6817 /* Process peer route updates. */
6818 peer_on_policy_change(member
, afi
, safi
,
6819 (direct
== FILTER_OUT
) ? 1 : 0);
6825 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
6828 struct peer
*member
;
6829 struct bgp_filter
*filter
;
6830 struct listnode
*node
, *nnode
;
6832 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6833 return BGP_ERR_INVALID_VALUE
;
6835 /* Unset override-flag unconditionally. */
6836 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6837 PEER_FT_PREFIX_LIST
);
6839 /* Inherit configuration from peer-group if peer is member. */
6840 if (peer_group_active(peer
)) {
6841 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6842 filter
[afi
][safi
].plist
[direct
].name
,
6843 MTYPE_BGP_FILTER_NAME
);
6844 PEER_ATTR_INHERIT(peer
, peer
->group
,
6845 filter
[afi
][safi
].plist
[direct
].plist
);
6847 /* Otherwise remove configuration from peer. */
6848 filter
= &peer
->filter
[afi
][safi
];
6849 if (filter
->plist
[direct
].name
)
6850 XFREE(MTYPE_BGP_FILTER_NAME
,
6851 filter
->plist
[direct
].name
);
6852 filter
->plist
[direct
].name
= NULL
;
6853 filter
->plist
[direct
].plist
= NULL
;
6856 /* Check if handling a regular peer. */
6857 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6858 /* Process peer route updates. */
6859 peer_on_policy_change(peer
, afi
, safi
,
6860 (direct
== FILTER_OUT
) ? 1 : 0);
6862 /* Skip peer-group mechanics for regular peers. */
6867 * Remove configuration on all peer-group members, unless they are
6868 * explicitly overriding peer-group configuration.
6870 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6871 /* Skip peers with overridden configuration. */
6872 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6873 PEER_FT_PREFIX_LIST
))
6876 /* Remove configuration on peer-group member. */
6877 filter
= &member
->filter
[afi
][safi
];
6878 if (filter
->plist
[direct
].name
)
6879 XFREE(MTYPE_BGP_FILTER_NAME
,
6880 filter
->plist
[direct
].name
);
6881 filter
->plist
[direct
].name
= NULL
;
6882 filter
->plist
[direct
].plist
= NULL
;
6884 /* Process peer route updates. */
6885 peer_on_policy_change(member
, afi
, safi
,
6886 (direct
== FILTER_OUT
) ? 1 : 0);
6892 /* Update prefix-list list. */
6893 static void peer_prefix_list_update(struct prefix_list
*plist
)
6895 struct listnode
*mnode
, *mnnode
;
6896 struct listnode
*node
, *nnode
;
6899 struct peer_group
*group
;
6900 struct bgp_filter
*filter
;
6905 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6908 * Update the prefix-list on update groups.
6910 update_group_policy_update(
6911 bgp
, BGP_POLICY_PREFIX_LIST
,
6912 plist
? prefix_list_name(plist
) : NULL
, true, 0);
6914 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6915 FOREACH_AFI_SAFI (afi
, safi
) {
6916 filter
= &peer
->filter
[afi
][safi
];
6918 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6920 if (filter
->plist
[direct
].name
)
6921 filter
->plist
[direct
]
6922 .plist
= prefix_list_lookup(
6924 filter
->plist
[direct
]
6927 filter
->plist
[direct
].plist
=
6931 /* If we touch prefix-list, we need to process
6932 * new updates. This is important for ORF to
6933 * work correctly as well.
6935 if (peer
->afc_nego
[afi
][safi
])
6936 peer_on_policy_change(peer
, afi
, safi
,
6940 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6941 FOREACH_AFI_SAFI (afi
, safi
) {
6942 filter
= &group
->conf
->filter
[afi
][safi
];
6944 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6946 if (filter
->plist
[direct
].name
)
6947 filter
->plist
[direct
]
6948 .plist
= prefix_list_lookup(
6950 filter
->plist
[direct
]
6953 filter
->plist
[direct
].plist
=
6961 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6964 struct peer
*member
;
6965 struct bgp_filter
*filter
;
6966 struct listnode
*node
, *nnode
;
6968 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6969 return BGP_ERR_INVALID_VALUE
;
6971 /* Set configuration on peer. */
6972 filter
= &peer
->filter
[afi
][safi
];
6973 if (filter
->aslist
[direct
].name
)
6974 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
6975 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6976 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6978 /* Check if handling a regular peer. */
6979 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6980 /* Set override-flag and process peer route updates. */
6981 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6982 PEER_FT_FILTER_LIST
);
6983 peer_on_policy_change(peer
, afi
, safi
,
6984 (direct
== FILTER_OUT
) ? 1 : 0);
6986 /* Skip peer-group mechanics for regular peers. */
6991 * Set configuration on all peer-group members, unless they are
6992 * explicitly overriding peer-group configuration.
6994 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6995 /* Skip peers with overridden configuration. */
6996 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6997 PEER_FT_FILTER_LIST
))
7000 /* Set configuration on peer-group member. */
7001 filter
= &member
->filter
[afi
][safi
];
7002 if (filter
->aslist
[direct
].name
)
7003 XFREE(MTYPE_BGP_FILTER_NAME
,
7004 filter
->aslist
[direct
].name
);
7005 filter
->aslist
[direct
].name
=
7006 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7007 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
7009 /* Process peer route updates. */
7010 peer_on_policy_change(member
, afi
, safi
,
7011 (direct
== FILTER_OUT
) ? 1 : 0);
7017 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
7019 struct peer
*member
;
7020 struct bgp_filter
*filter
;
7021 struct listnode
*node
, *nnode
;
7023 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
7024 return BGP_ERR_INVALID_VALUE
;
7026 /* Unset override-flag unconditionally. */
7027 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
7028 PEER_FT_FILTER_LIST
);
7030 /* Inherit configuration from peer-group if peer is member. */
7031 if (peer_group_active(peer
)) {
7032 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7033 filter
[afi
][safi
].aslist
[direct
].name
,
7034 MTYPE_BGP_FILTER_NAME
);
7035 PEER_ATTR_INHERIT(peer
, peer
->group
,
7036 filter
[afi
][safi
].aslist
[direct
].aslist
);
7038 /* Otherwise remove configuration from peer. */
7039 filter
= &peer
->filter
[afi
][safi
];
7040 if (filter
->aslist
[direct
].name
)
7041 XFREE(MTYPE_BGP_FILTER_NAME
,
7042 filter
->aslist
[direct
].name
);
7043 filter
->aslist
[direct
].name
= NULL
;
7044 filter
->aslist
[direct
].aslist
= NULL
;
7047 /* Check if handling a regular peer. */
7048 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7049 /* Process peer route updates. */
7050 peer_on_policy_change(peer
, afi
, safi
,
7051 (direct
== FILTER_OUT
) ? 1 : 0);
7053 /* Skip peer-group mechanics for regular peers. */
7058 * Remove configuration on all peer-group members, unless they are
7059 * explicitly overriding peer-group configuration.
7061 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7062 /* Skip peers with overridden configuration. */
7063 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7064 PEER_FT_FILTER_LIST
))
7067 /* Remove configuration on peer-group member. */
7068 filter
= &member
->filter
[afi
][safi
];
7069 if (filter
->aslist
[direct
].name
)
7070 XFREE(MTYPE_BGP_FILTER_NAME
,
7071 filter
->aslist
[direct
].name
);
7072 filter
->aslist
[direct
].name
= NULL
;
7073 filter
->aslist
[direct
].aslist
= NULL
;
7075 /* Process peer route updates. */
7076 peer_on_policy_change(member
, afi
, safi
,
7077 (direct
== FILTER_OUT
) ? 1 : 0);
7083 static void peer_aslist_update(const char *aslist_name
)
7088 struct listnode
*mnode
, *mnnode
;
7089 struct listnode
*node
, *nnode
;
7092 struct peer_group
*group
;
7093 struct bgp_filter
*filter
;
7095 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
7096 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
7097 aslist_name
, true, 0);
7099 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7100 FOREACH_AFI_SAFI (afi
, safi
) {
7101 filter
= &peer
->filter
[afi
][safi
];
7103 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7105 if (filter
->aslist
[direct
].name
)
7106 filter
->aslist
[direct
]
7107 .aslist
= as_list_lookup(
7108 filter
->aslist
[direct
]
7111 filter
->aslist
[direct
].aslist
=
7116 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
7117 FOREACH_AFI_SAFI (afi
, safi
) {
7118 filter
= &group
->conf
->filter
[afi
][safi
];
7120 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7122 if (filter
->aslist
[direct
].name
)
7123 filter
->aslist
[direct
]
7124 .aslist
= as_list_lookup(
7125 filter
->aslist
[direct
]
7128 filter
->aslist
[direct
].aslist
=
7136 static void peer_aslist_add(char *aslist_name
)
7138 peer_aslist_update(aslist_name
);
7139 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
7142 static void peer_aslist_del(const char *aslist_name
)
7144 peer_aslist_update(aslist_name
);
7145 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
7149 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
7150 const char *name
, struct route_map
*route_map
)
7152 struct peer
*member
;
7153 struct bgp_filter
*filter
;
7154 struct listnode
*node
, *nnode
;
7156 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7157 return BGP_ERR_INVALID_VALUE
;
7159 /* Set configuration on peer. */
7160 filter
= &peer
->filter
[afi
][safi
];
7161 if (filter
->map
[direct
].name
) {
7162 /* If the neighbor is configured with the same route-map
7163 * again then, ignore the duplicate configuration.
7165 if (strcmp(filter
->map
[direct
].name
, name
) == 0)
7168 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7170 route_map_counter_decrement(filter
->map
[direct
].map
);
7171 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7172 filter
->map
[direct
].map
= route_map
;
7173 route_map_counter_increment(route_map
);
7175 /* Check if handling a regular peer. */
7176 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7177 /* Set override-flag and process peer route updates. */
7178 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
7180 peer_on_policy_change(peer
, afi
, safi
,
7181 (direct
== RMAP_OUT
) ? 1 : 0);
7183 /* Skip peer-group mechanics for regular peers. */
7188 * Set configuration on all peer-group members, unless they are
7189 * explicitly overriding peer-group configuration.
7191 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7192 /* Skip peers with overridden configuration. */
7193 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7197 /* Set configuration on peer-group member. */
7198 filter
= &member
->filter
[afi
][safi
];
7199 if (filter
->map
[direct
].name
)
7200 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7201 route_map_counter_decrement(filter
->map
[direct
].map
);
7202 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7203 filter
->map
[direct
].map
= route_map
;
7204 route_map_counter_increment(route_map
);
7206 /* Process peer route updates. */
7207 peer_on_policy_change(member
, afi
, safi
,
7208 (direct
== RMAP_OUT
) ? 1 : 0);
7213 /* Unset route-map from the peer. */
7214 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
7216 struct peer
*member
;
7217 struct bgp_filter
*filter
;
7218 struct listnode
*node
, *nnode
;
7220 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7221 return BGP_ERR_INVALID_VALUE
;
7223 /* Unset override-flag unconditionally. */
7224 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
7226 /* Inherit configuration from peer-group if peer is member. */
7227 if (peer_group_active(peer
)) {
7228 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7229 filter
[afi
][safi
].map
[direct
].name
,
7230 MTYPE_BGP_FILTER_NAME
);
7231 PEER_ATTR_INHERIT(peer
, peer
->group
,
7232 filter
[afi
][safi
].map
[direct
].map
);
7234 /* Otherwise remove configuration from peer. */
7235 filter
= &peer
->filter
[afi
][safi
];
7236 if (filter
->map
[direct
].name
)
7237 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7238 route_map_counter_decrement(filter
->map
[direct
].map
);
7239 filter
->map
[direct
].name
= NULL
;
7240 filter
->map
[direct
].map
= NULL
;
7243 /* Check if handling a regular peer. */
7244 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7245 /* Process peer route updates. */
7246 peer_on_policy_change(peer
, afi
, safi
,
7247 (direct
== RMAP_OUT
) ? 1 : 0);
7249 /* Skip peer-group mechanics for regular peers. */
7254 * Remove configuration on all peer-group members, unless they are
7255 * explicitly overriding peer-group configuration.
7257 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7258 /* Skip peers with overridden configuration. */
7259 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7263 /* Remove configuration on peer-group member. */
7264 filter
= &member
->filter
[afi
][safi
];
7265 if (filter
->map
[direct
].name
)
7266 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7267 route_map_counter_decrement(filter
->map
[direct
].map
);
7268 filter
->map
[direct
].name
= NULL
;
7269 filter
->map
[direct
].map
= NULL
;
7271 /* Process peer route updates. */
7272 peer_on_policy_change(member
, afi
, safi
,
7273 (direct
== RMAP_OUT
) ? 1 : 0);
7279 /* Set unsuppress-map to the peer. */
7280 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7281 const char *name
, struct route_map
*route_map
)
7283 struct peer
*member
;
7284 struct bgp_filter
*filter
;
7285 struct listnode
*node
, *nnode
;
7287 /* Set configuration on peer. */
7288 filter
= &peer
->filter
[afi
][safi
];
7289 if (filter
->usmap
.name
)
7290 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7291 route_map_counter_decrement(filter
->usmap
.map
);
7292 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7293 filter
->usmap
.map
= route_map
;
7294 route_map_counter_increment(route_map
);
7296 /* Check if handling a regular peer. */
7297 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7298 /* Set override-flag and process peer route updates. */
7299 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
7300 PEER_FT_UNSUPPRESS_MAP
);
7301 peer_on_policy_change(peer
, afi
, safi
, 1);
7303 /* Skip peer-group mechanics for regular peers. */
7308 * Set configuration on all peer-group members, unless they are
7309 * explicitly overriding peer-group configuration.
7311 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7312 /* Skip peers with overridden configuration. */
7313 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7314 PEER_FT_UNSUPPRESS_MAP
))
7317 /* Set configuration on peer-group member. */
7318 filter
= &member
->filter
[afi
][safi
];
7319 if (filter
->usmap
.name
)
7320 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7321 route_map_counter_decrement(filter
->usmap
.map
);
7322 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7323 filter
->usmap
.map
= route_map
;
7324 route_map_counter_increment(route_map
);
7326 /* Process peer route updates. */
7327 peer_on_policy_change(member
, afi
, safi
, 1);
7333 /* Unset route-map from the peer. */
7334 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7336 struct peer
*member
;
7337 struct bgp_filter
*filter
;
7338 struct listnode
*node
, *nnode
;
7340 /* Unset override-flag unconditionally. */
7341 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
7343 /* Inherit configuration from peer-group if peer is member. */
7344 if (peer_group_active(peer
)) {
7345 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7346 filter
[afi
][safi
].usmap
.name
,
7347 MTYPE_BGP_FILTER_NAME
);
7348 PEER_ATTR_INHERIT(peer
, peer
->group
,
7349 filter
[afi
][safi
].usmap
.map
);
7351 /* Otherwise remove configuration from peer. */
7352 filter
= &peer
->filter
[afi
][safi
];
7353 if (filter
->usmap
.name
)
7354 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7355 route_map_counter_decrement(filter
->usmap
.map
);
7356 filter
->usmap
.name
= NULL
;
7357 filter
->usmap
.map
= NULL
;
7360 /* Check if handling a regular peer. */
7361 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7362 /* Process peer route updates. */
7363 peer_on_policy_change(peer
, afi
, safi
, 1);
7365 /* Skip peer-group mechanics for regular peers. */
7370 * Remove configuration on all peer-group members, unless they are
7371 * explicitly overriding peer-group configuration.
7373 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7374 /* Skip peers with overridden configuration. */
7375 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7376 PEER_FT_UNSUPPRESS_MAP
))
7379 /* Remove configuration on peer-group member. */
7380 filter
= &member
->filter
[afi
][safi
];
7381 if (filter
->usmap
.name
)
7382 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7383 route_map_counter_decrement(filter
->usmap
.map
);
7384 filter
->usmap
.name
= NULL
;
7385 filter
->usmap
.map
= NULL
;
7387 /* Process peer route updates. */
7388 peer_on_policy_change(member
, afi
, safi
, 1);
7394 static bool peer_maximum_prefix_clear_overflow(struct peer
*peer
)
7396 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
7399 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
7400 if (peer
->t_pmax_restart
) {
7401 THREAD_OFF(peer
->t_pmax_restart
);
7402 if (bgp_debug_neighbor_events(peer
))
7404 "%pBP Maximum-prefix restart timer cancelled",
7407 BGP_EVENT_ADD(peer
, BGP_Start
);
7411 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7412 uint32_t max
, uint8_t threshold
, int warning
,
7413 uint16_t restart
, bool force
)
7415 struct peer
*member
;
7416 struct listnode
*node
, *nnode
;
7418 /* Set flags and configuration on peer. */
7419 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7422 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7424 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7427 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7429 peer_af_flag_unset(peer
, afi
, safi
,
7430 PEER_FLAG_MAX_PREFIX_WARNING
);
7432 peer
->pmax
[afi
][safi
] = max
;
7433 peer
->pmax_threshold
[afi
][safi
] = threshold
;
7434 peer
->pmax_restart
[afi
][safi
] = restart
;
7436 /* Check if handling a regular peer. */
7437 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7438 /* Re-check if peer violates maximum-prefix. */
7439 if ((peer_established(peer
)) && (peer
->afc
[afi
][safi
]))
7440 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
7442 /* Skip peer-group mechanics for regular peers. */
7447 * Set flags and configuration on all peer-group members, unless they
7448 * are explicitly overriding peer-group configuration.
7450 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7451 /* Skip peers with overridden configuration. */
7452 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7453 PEER_FLAG_MAX_PREFIX
))
7456 /* Set flag and configuration on peer-group member. */
7457 member
->pmax
[afi
][safi
] = max
;
7458 member
->pmax_threshold
[afi
][safi
] = threshold
;
7459 member
->pmax_restart
[afi
][safi
] = restart
;
7462 SET_FLAG(member
->af_flags
[afi
][safi
],
7463 PEER_FLAG_MAX_PREFIX_FORCE
);
7465 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7466 PEER_FLAG_MAX_PREFIX_FORCE
);
7469 SET_FLAG(member
->af_flags
[afi
][safi
],
7470 PEER_FLAG_MAX_PREFIX_WARNING
);
7472 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7473 PEER_FLAG_MAX_PREFIX_WARNING
);
7475 /* Re-check if peer violates maximum-prefix. */
7476 if ((peer_established(member
)) && (member
->afc
[afi
][safi
]))
7477 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
7483 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7485 /* Inherit configuration from peer-group if peer is member. */
7486 if (peer_group_active(peer
)) {
7487 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7488 peer_af_flag_inherit(peer
, afi
, safi
,
7489 PEER_FLAG_MAX_PREFIX_FORCE
);
7490 peer_af_flag_inherit(peer
, afi
, safi
,
7491 PEER_FLAG_MAX_PREFIX_WARNING
);
7492 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
7493 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
7494 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
7499 /* Remove flags and configuration from peer. */
7500 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7501 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7502 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7503 peer
->pmax
[afi
][safi
] = 0;
7504 peer
->pmax_threshold
[afi
][safi
] = 0;
7505 peer
->pmax_restart
[afi
][safi
] = 0;
7508 * Remove flags and configuration from all peer-group members, unless
7509 * they are explicitly overriding peer-group configuration.
7511 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7512 struct peer
*member
;
7513 struct listnode
*node
;
7515 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7516 /* Skip peers with overridden configuration. */
7517 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7518 PEER_FLAG_MAX_PREFIX
))
7521 /* Remove flag and configuration on peer-group member.
7523 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7524 PEER_FLAG_MAX_PREFIX
);
7525 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7526 PEER_FLAG_MAX_PREFIX_FORCE
);
7527 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7528 PEER_FLAG_MAX_PREFIX_WARNING
);
7529 member
->pmax
[afi
][safi
] = 0;
7530 member
->pmax_threshold
[afi
][safi
] = 0;
7531 member
->pmax_restart
[afi
][safi
] = 0;
7533 peer_maximum_prefix_clear_overflow(member
);
7536 peer_maximum_prefix_clear_overflow(peer
);
7542 void peer_maximum_prefix_out_refresh_routes(struct peer
*peer
, afi_t afi
,
7545 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
7547 if (peer_established(peer
))
7548 bgp_announce_route(peer
, afi
, safi
, false);
7551 int peer_maximum_prefix_out_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7554 struct peer
*member
;
7555 struct listnode
*node
, *nnode
;
7557 /* Set flag on peer and peer-group member if any */
7558 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7559 /* Set configuration on peer. */
7560 peer
->pmax_out
[afi
][safi
] = max
;
7562 /* Check if handling a regular peer. */
7563 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7564 /* Skip peer-group mechanics for regular peers. */
7565 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7570 * Set flag and configuration on all peer-group members, unless they
7571 * are explicitly overriding peer-group configuration.
7573 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7574 /* Skip peers with overridden configuration. */
7575 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7576 PEER_FLAG_MAX_PREFIX_OUT
))
7579 /* Set configuration on peer-group member. */
7580 member
->pmax_out
[afi
][safi
] = max
;
7582 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7587 int peer_maximum_prefix_out_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7589 struct peer
*member
;
7590 struct listnode
*node
;
7591 /* Inherit configuration from peer-group if peer is member. */
7592 if (peer_group_active(peer
)) {
7593 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7594 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_out
[afi
][safi
]);
7596 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7600 /* Remove flag and configuration from peer. */
7601 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7602 peer
->pmax_out
[afi
][safi
] = 0;
7604 /* Check if handling a regular peer. */
7605 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7606 /* Skip peer-group mechanics for regular peers. */
7607 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7612 * Remove flag and configuration from all peer-group members, unless
7613 * they are explicitly overriding peer-group configuration.
7615 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7616 /* Skip peers with overridden configuration. */
7617 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7618 PEER_FLAG_MAX_PREFIX_OUT
))
7621 /* Remove flag and configuration on peer-group member.
7623 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7624 PEER_FLAG_MAX_PREFIX_OUT
);
7625 member
->pmax_out
[afi
][safi
] = 0;
7627 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7632 int is_ebgp_multihop_configured(struct peer
*peer
)
7634 struct peer_group
*group
;
7635 struct listnode
*node
, *nnode
;
7638 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7639 group
= peer
->group
;
7640 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7641 && (group
->conf
->ttl
!= BGP_DEFAULT_TTL
))
7644 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
7645 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
7646 && (peer1
->ttl
!= BGP_DEFAULT_TTL
))
7650 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7651 && (peer
->ttl
!= BGP_DEFAULT_TTL
))
7657 /* Set # of hops between us and BGP peer. */
7658 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
7660 struct peer_group
*group
;
7662 struct listnode
*node
, *nnode
;
7665 zlog_debug("%s: set gtsm_hops to %d for %s", __func__
, gtsm_hops
,
7668 /* We cannot configure ttl-security hops when ebgp-multihop is already
7669 set. For non peer-groups, the check is simple. For peer-groups,
7671 slightly messy, because we need to check both the peer-group
7673 and all peer-group members for any trace of ebgp-multihop
7675 before actually applying the ttl-security rules. Cisco really made a
7676 mess of this configuration parameter, and OpenBGPD got it right.
7679 if ((peer
->gtsm_hops
== BGP_GTSM_HOPS_DISABLED
)
7680 && (peer
->sort
!= BGP_PEER_IBGP
)) {
7681 if (is_ebgp_multihop_configured(peer
))
7682 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
7684 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7685 peer
->gtsm_hops
= gtsm_hops
;
7687 /* Calling ebgp multihop also resets the session.
7688 * On restart, NHT will get setup correctly as will the
7689 * min & max ttls on the socket. The return value is
7692 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
7697 group
= peer
->group
;
7698 group
->conf
->gtsm_hops
= gtsm_hops
;
7699 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7701 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7703 /* Calling ebgp multihop also resets the
7705 * On restart, NHT will get setup correctly as
7707 * min & max ttls on the socket. The return
7711 peer_ebgp_multihop_set(gpeer
, MAXTTL
);
7715 /* Post the first gtsm setup or if its ibgp, maxttl setting
7717 * necessary, just set the minttl.
7719 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7720 peer
->gtsm_hops
= gtsm_hops
;
7723 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7724 MAXTTL
+ 1 - gtsm_hops
);
7725 if ((peer
->status
< Established
) && peer
->doppelganger
7726 && (peer
->doppelganger
->fd
>= 0))
7727 sockopt_minttl(peer
->su
.sa
.sa_family
,
7728 peer
->doppelganger
->fd
,
7729 MAXTTL
+ 1 - gtsm_hops
);
7731 group
= peer
->group
;
7732 group
->conf
->gtsm_hops
= gtsm_hops
;
7733 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7735 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7737 /* Change setting of existing peer
7738 * established then change value (may break
7740 * not established yet (teardown session and
7742 * no session then do nothing (will get
7743 * handled by next connection)
7747 != BGP_GTSM_HOPS_DISABLED
)
7749 gpeer
->su
.sa
.sa_family
,
7751 MAXTTL
+ 1 - gpeer
->gtsm_hops
);
7752 if ((gpeer
->status
< Established
)
7753 && gpeer
->doppelganger
7754 && (gpeer
->doppelganger
->fd
>= 0))
7755 sockopt_minttl(gpeer
->su
.sa
.sa_family
,
7756 gpeer
->doppelganger
->fd
,
7757 MAXTTL
+ 1 - gtsm_hops
);
7765 int peer_ttl_security_hops_unset(struct peer
*peer
)
7767 struct peer_group
*group
;
7768 struct listnode
*node
, *nnode
;
7771 zlog_debug("%s: set gtsm_hops to zero for %s", __func__
, peer
->host
);
7773 /* if a peer-group member, then reset to peer-group default rather than
7775 if (peer_group_active(peer
))
7776 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
7778 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7780 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7781 /* Invoking ebgp_multihop_set will set the TTL back to the
7783 * value as well as restting the NHT and such. The session is
7786 if (peer
->sort
== BGP_PEER_EBGP
)
7787 ret
= peer_ebgp_multihop_unset(peer
);
7790 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7793 if ((peer
->status
< Established
) && peer
->doppelganger
7794 && (peer
->doppelganger
->fd
>= 0))
7795 sockopt_minttl(peer
->su
.sa
.sa_family
,
7796 peer
->doppelganger
->fd
, 0);
7799 group
= peer
->group
;
7800 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
7801 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7802 if (peer
->sort
== BGP_PEER_EBGP
)
7803 ret
= peer_ebgp_multihop_unset(peer
);
7806 sockopt_minttl(peer
->su
.sa
.sa_family
,
7809 if ((peer
->status
< Established
)
7810 && peer
->doppelganger
7811 && (peer
->doppelganger
->fd
>= 0))
7812 sockopt_minttl(peer
->su
.sa
.sa_family
,
7813 peer
->doppelganger
->fd
,
7822 static void peer_reset_message_stats(struct peer
*peer
)
7825 atomic_store_explicit(&peer
->open_in
, 0, memory_order_relaxed
);
7826 atomic_store_explicit(&peer
->open_out
, 0, memory_order_relaxed
);
7827 atomic_store_explicit(&peer
->update_in
, 0,
7828 memory_order_relaxed
);
7829 atomic_store_explicit(&peer
->update_out
, 0,
7830 memory_order_relaxed
);
7831 atomic_store_explicit(&peer
->keepalive_in
, 0,
7832 memory_order_relaxed
);
7833 atomic_store_explicit(&peer
->keepalive_out
, 0,
7834 memory_order_relaxed
);
7835 atomic_store_explicit(&peer
->notify_in
, 0,
7836 memory_order_relaxed
);
7837 atomic_store_explicit(&peer
->notify_out
, 0,
7838 memory_order_relaxed
);
7839 atomic_store_explicit(&peer
->refresh_in
, 0,
7840 memory_order_relaxed
);
7841 atomic_store_explicit(&peer
->refresh_out
, 0,
7842 memory_order_relaxed
);
7843 atomic_store_explicit(&peer
->dynamic_cap_in
, 0,
7844 memory_order_relaxed
);
7845 atomic_store_explicit(&peer
->dynamic_cap_out
, 0,
7846 memory_order_relaxed
);
7851 * If peer clear is invoked in a loop for all peers on the BGP instance,
7852 * it may end up freeing the doppelganger, and if this was the next node
7853 * to the current node, we would end up accessing the freed next node.
7854 * Pass along additional parameter which can be updated if next node
7855 * is freed; only required when walking the peer list on BGP instance.
7857 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
7859 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)
7860 || !CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_SHUTDOWN
)) {
7861 if (peer_maximum_prefix_clear_overflow(peer
))
7864 peer
->v_start
= BGP_INIT_START_TIMER
;
7865 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
7866 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7867 BGP_NOTIFY_CEASE_ADMIN_RESET
);
7869 bgp_session_reset_safe(peer
, nnode
);
7874 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
7875 enum bgp_clear_type stype
)
7877 struct peer_af
*paf
;
7879 if (!peer_established(peer
))
7882 if (!peer
->afc
[afi
][safi
])
7883 return BGP_ERR_AF_UNCONFIGURED
;
7885 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
7887 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
7888 /* Clear the "neighbor x.x.x.x default-originate" flag */
7889 paf
= peer_af_find(peer
, afi
, safi
);
7890 if (paf
&& paf
->subgroup
7891 && CHECK_FLAG(paf
->subgroup
->sflags
,
7892 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
7893 UNSET_FLAG(paf
->subgroup
->sflags
,
7894 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
7896 bgp_announce_route(peer
, afi
, safi
, false);
7899 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7900 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7901 PEER_CAP_ORF_PREFIX_SM_ADV
)
7902 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7903 PEER_CAP_ORF_PREFIX_RM_RCV
)
7904 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7905 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
7906 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
7907 uint8_t prefix_type
;
7909 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7910 PEER_CAP_ORF_PREFIX_RM_RCV
))
7911 prefix_type
= ORF_TYPE_PREFIX
;
7913 prefix_type
= ORF_TYPE_PREFIX_OLD
;
7915 if (filter
->plist
[FILTER_IN
].plist
) {
7916 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7917 PEER_STATUS_ORF_PREFIX_SEND
))
7918 bgp_route_refresh_send(
7919 peer
, afi
, safi
, prefix_type
,
7921 BGP_ROUTE_REFRESH_NORMAL
);
7922 bgp_route_refresh_send(
7923 peer
, afi
, safi
, prefix_type
,
7924 REFRESH_IMMEDIATE
, 0,
7925 BGP_ROUTE_REFRESH_NORMAL
);
7927 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7928 PEER_STATUS_ORF_PREFIX_SEND
))
7929 bgp_route_refresh_send(
7930 peer
, afi
, safi
, prefix_type
,
7931 REFRESH_IMMEDIATE
, 1,
7932 BGP_ROUTE_REFRESH_NORMAL
);
7934 bgp_route_refresh_send(
7935 peer
, afi
, safi
, 0, 0, 0,
7936 BGP_ROUTE_REFRESH_NORMAL
);
7942 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
7943 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7944 /* If neighbor has soft reconfiguration inbound flag.
7945 Use Adj-RIB-In database. */
7946 if (!bgp_soft_reconfig_in(peer
, afi
, safi
)) {
7947 /* If neighbor has route refresh capability, send route
7949 message to the peer. */
7950 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
7951 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
7952 bgp_route_refresh_send(
7953 peer
, afi
, safi
, 0, 0, 0,
7954 BGP_ROUTE_REFRESH_NORMAL
);
7956 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
7960 if (stype
== BGP_CLEAR_MESSAGE_STATS
)
7961 peer_reset_message_stats(peer
);
7966 /* Display peer uptime.*/
7967 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, bool use_json
,
7970 time_t uptime1
, epoch_tbuf
;
7973 /* If there is no connection has been done before print `never'. */
7976 json_object_string_add(json
, "peerUptime", "never");
7977 json_object_int_add(json
, "peerUptimeMsec", 0);
7979 snprintf(buf
, len
, "never");
7983 /* Get current time. */
7984 uptime1
= monotime(NULL
);
7986 gmtime_r(&uptime1
, &tm
);
7988 if (uptime1
< ONE_DAY_SECOND
)
7989 snprintf(buf
, len
, "%02d:%02d:%02d", tm
.tm_hour
, tm
.tm_min
,
7991 else if (uptime1
< ONE_WEEK_SECOND
)
7992 snprintf(buf
, len
, "%dd%02dh%02dm", tm
.tm_yday
, tm
.tm_hour
,
7994 else if (uptime1
< ONE_YEAR_SECOND
)
7995 snprintf(buf
, len
, "%02dw%dd%02dh", tm
.tm_yday
/ 7,
7996 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7), tm
.tm_hour
);
7998 snprintf(buf
, len
, "%02dy%02dw%dd", tm
.tm_year
- 70,
8000 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7));
8003 epoch_tbuf
= time(NULL
) - uptime1
;
8004 json_object_string_add(json
, "peerUptime", buf
);
8005 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
8006 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
8013 void bgp_master_init(struct thread_master
*master
, const int buffer_size
,
8014 struct list
*addresses
)
8018 memset(&bgp_master
, 0, sizeof(bgp_master
));
8021 bm
->bgp
= list_new();
8022 bm
->listen_sockets
= list_new();
8023 bm
->port
= BGP_PORT_DEFAULT
;
8024 bm
->addresses
= addresses
;
8025 bm
->master
= master
;
8026 bm
->start_time
= monotime(NULL
);
8027 bm
->t_rmap_update
= NULL
;
8028 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
8029 bm
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
8030 bm
->v_establish_wait
= BGP_UPDATE_DELAY_DEF
;
8031 bm
->terminating
= false;
8032 bm
->socket_buffer
= buffer_size
;
8033 bm
->wait_for_fib
= false;
8034 bm
->tcp_dscp
= IPTOS_PREC_INTERNETCONTROL
;
8035 bm
->inq_limit
= BM_DEFAULT_Q_LIMIT
;
8036 bm
->outq_limit
= BM_DEFAULT_Q_LIMIT
;
8039 /* init the rd id space.
8040 assign 0th index in the bitfield,
8041 so that we start with id 1
8043 bf_init(bm
->rd_idspace
, UINT16_MAX
);
8044 bf_assign_zero_index(bm
->rd_idspace
);
8046 /* mpls label dynamic allocation pool */
8047 bgp_lp_init(bm
->master
, &bm
->labelpool
);
8051 QOBJ_REG(bm
, bgp_master
);
8055 * Free up connected routes and interfaces for a BGP instance. Invoked upon
8056 * instance delete (non-default only) or BGP exit.
8058 static void bgp_if_finish(struct bgp
*bgp
)
8061 struct interface
*ifp
;
8063 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
8065 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
8068 FOR_ALL_INTERFACES (vrf
, ifp
) {
8069 struct listnode
*c_node
, *c_nnode
;
8070 struct connected
*c
;
8072 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
8073 bgp_connected_delete(bgp
, c
);
8077 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
8079 struct vrf
*vrf
= NULL
;
8080 struct listnode
*next
;
8083 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
8084 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
8086 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8087 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
8090 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
8094 static void bgp_instasn_autocomplete(vector comps
, struct cmd_token
*token
)
8096 struct listnode
*next
, *next2
;
8097 struct bgp
*bgp
, *bgp2
;
8098 char buf
[ASN_STRING_MAX_SIZE
];
8100 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8102 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next2
, bgp2
)) {
8103 if (bgp2
->as
== bgp
->as
)
8111 snprintf(buf
, sizeof(buf
), "%s", bgp
->as_pretty
);
8112 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, buf
));
8116 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
8117 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
8118 {.varname
= "instasn", .completions
= bgp_instasn_autocomplete
},
8119 {.completions
= NULL
},
8122 struct frr_pthread
*bgp_pth_io
;
8123 struct frr_pthread
*bgp_pth_ka
;
8125 static void bgp_pthreads_init(void)
8127 assert(!bgp_pth_io
);
8128 assert(!bgp_pth_ka
);
8130 struct frr_pthread_attr io
= {
8131 .start
= frr_pthread_attr_default
.start
,
8132 .stop
= frr_pthread_attr_default
.stop
,
8134 struct frr_pthread_attr ka
= {
8135 .start
= bgp_keepalives_start
,
8136 .stop
= bgp_keepalives_stop
,
8138 bgp_pth_io
= frr_pthread_new(&io
, "BGP I/O thread", "bgpd_io");
8139 bgp_pth_ka
= frr_pthread_new(&ka
, "BGP Keepalives thread", "bgpd_ka");
8142 void bgp_pthreads_run(void)
8144 frr_pthread_run(bgp_pth_io
, NULL
);
8145 frr_pthread_run(bgp_pth_ka
, NULL
);
8147 /* Wait until threads are ready. */
8148 frr_pthread_wait_running(bgp_pth_io
);
8149 frr_pthread_wait_running(bgp_pth_ka
);
8152 void bgp_pthreads_finish(void)
8154 frr_pthread_stop_all();
8157 static int peer_unshut_after_cfg(struct bgp
*bgp
)
8159 struct listnode
*node
;
8162 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
8163 if (!peer
->shut_during_cfg
)
8166 if (bgp_debug_neighbor_events(peer
))
8167 zlog_debug("%s: released from config-pending hold",
8170 peer
->shut_during_cfg
= false;
8171 if (peer_active(peer
) && peer
->status
!= Established
) {
8172 if (peer
->status
!= Idle
)
8173 BGP_EVENT_ADD(peer
, BGP_Stop
);
8174 BGP_EVENT_ADD(peer
, BGP_Start
);
8181 void bgp_init(unsigned short instance
)
8183 hook_register(bgp_config_end
, peer_unshut_after_cfg
);
8185 /* allocates some vital data structures used by peer commands in
8188 /* pre-init pthreads */
8189 bgp_pthreads_init();
8192 bgp_zebra_init(bm
->master
, instance
);
8194 #ifdef ENABLE_BGP_VNC
8195 vnc_zebra_init(bm
->master
);
8198 /* BGP VTY commands installation. */
8204 bgp_community_alias_init();
8207 bgp_route_map_init();
8208 bgp_scan_vty_init();
8210 #ifdef ENABLE_BGP_VNC
8213 bgp_ethernetvpn_init();
8214 bgp_flowspec_vty_init();
8216 /* Access list initialize. */
8218 access_list_add_hook(peer_distribute_update
);
8219 access_list_delete_hook(peer_distribute_update
);
8221 /* Filter list initialize. */
8223 as_list_add_hook(peer_aslist_add
);
8224 as_list_delete_hook(peer_aslist_del
);
8226 /* Prefix list initialize.*/
8228 prefix_list_add_hook(peer_prefix_list_update
);
8229 prefix_list_delete_hook(peer_prefix_list_update
);
8231 /* Community list initialize. */
8232 bgp_clist
= community_list_init();
8235 bgp_bfd_init(bm
->master
);
8239 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
8242 void bgp_terminate(void)
8246 struct listnode
*node
, *nnode
;
8247 struct listnode
*mnode
, *mnnode
;
8251 /* Close the listener sockets first as this prevents peers from
8253 * to reconnect on receiving the peer unconfig message. In the presence
8254 * of a large number of peers this will ensure that no peer is left with
8255 * a dangling connection
8259 /* reverse bgp_master_init */
8260 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
8261 bgp_close_vrf_socket(bgp
);
8262 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8263 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
8264 if (bgp_debug_neighbor_events(peer
))
8266 "%pBP configured Graceful-Restart, skipping unconfig notification",
8270 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
8271 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
8272 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
8276 if (bm
->listen_sockets
)
8277 list_delete(&bm
->listen_sockets
);
8279 THREAD_OFF(bm
->t_rmap_update
);
8284 struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
8285 const char *ip_str
, bool use_json
)
8291 /* Get peer sockunion. */
8292 ret
= str2sockunion(ip_str
, &su
);
8294 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
8296 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
8300 json_object
*json_no
= NULL
;
8301 json_no
= json_object_new_object();
8302 json_object_string_add(
8304 "malformedAddressOrName",
8306 vty_json(vty
, json_no
);
8309 "%% Malformed address or name: %s\n",
8317 /* Peer structure lookup. */
8318 peer
= peer_lookup(bgp
, &su
);
8321 json_object
*json_no
= NULL
;
8322 json_no
= json_object_new_object();
8323 json_object_string_add(json_no
, "warning",
8324 "No such neighbor in this view/vrf");
8325 vty_json(vty
, json_no
);
8327 vty_out(vty
, "No such neighbor in this view/vrf\n");
8334 void bgp_gr_apply_running_config(void)
8336 struct peer
*peer
= NULL
;
8337 struct bgp
*bgp
= NULL
;
8338 struct listnode
*node
, *nnode
;
8339 bool gr_router_detected
= false;
8341 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
8342 zlog_debug("[BGP_GR] %s called !", __func__
);
8344 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
8345 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8346 bgp_peer_gr_flags_update(peer
);
8347 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
))
8348 gr_router_detected
= true;
8351 if (gr_router_detected
8352 && bgp
->present_zebra_gr_state
== ZEBRA_GR_DISABLE
) {
8353 bgp_zebra_send_capabilities(bgp
, true);
8354 } else if (!gr_router_detected
8355 && bgp
->present_zebra_gr_state
== ZEBRA_GR_ENABLE
) {
8356 bgp_zebra_send_capabilities(bgp
, false);
8359 gr_router_detected
= false;
8363 printfrr_ext_autoreg_p("BP", printfrr_bp
);
8364 static ssize_t
printfrr_bp(struct fbuf
*buf
, struct printfrr_eargs
*ea
,
8367 const struct peer
*peer
= ptr
;
8370 return bputs(buf
, "(null)");
8372 return bprintfrr(buf
, "%s(%s)", peer
->host
,
8373 peer
->hostname
? peer
->hostname
: "Unknown");