1 /* BGP-4, BGP-4+ daemon program
2 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "sockunion.h"
38 #include "workqueue.h"
46 #include "lib/sockopt.h"
47 #include "frr_pthread.h"
50 #include "bgpd/bgpd.h"
51 #include "bgpd/bgp_table.h"
52 #include "bgpd/bgp_aspath.h"
53 #include "bgpd/bgp_route.h"
54 #include "bgpd/bgp_dump.h"
55 #include "bgpd/bgp_debug.h"
56 #include "bgpd/bgp_errors.h"
57 #include "bgpd/bgp_community.h"
58 #include "bgpd/bgp_community_alias.h"
59 #include "bgpd/bgp_conditional_adv.h"
60 #include "bgpd/bgp_attr.h"
61 #include "bgpd/bgp_regex.h"
62 #include "bgpd/bgp_clist.h"
63 #include "bgpd/bgp_fsm.h"
64 #include "bgpd/bgp_packet.h"
65 #include "bgpd/bgp_zebra.h"
66 #include "bgpd/bgp_open.h"
67 #include "bgpd/bgp_filter.h"
68 #include "bgpd/bgp_nexthop.h"
69 #include "bgpd/bgp_damp.h"
70 #include "bgpd/bgp_mplsvpn.h"
72 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
73 #include "bgpd/rfapi/rfapi_backend.h"
75 #include "bgpd/bgp_evpn.h"
76 #include "bgpd/bgp_advertise.h"
77 #include "bgpd/bgp_network.h"
78 #include "bgpd/bgp_vty.h"
79 #include "bgpd/bgp_mpath.h"
80 #include "bgpd/bgp_nht.h"
81 #include "bgpd/bgp_updgrp.h"
82 #include "bgpd/bgp_bfd.h"
83 #include "bgpd/bgp_memory.h"
84 #include "bgpd/bgp_evpn_vty.h"
85 #include "bgpd/bgp_keepalives.h"
86 #include "bgpd/bgp_io.h"
87 #include "bgpd/bgp_ecommunity.h"
88 #include "bgpd/bgp_flowspec.h"
89 #include "bgpd/bgp_labelpool.h"
90 #include "bgpd/bgp_pbr.h"
91 #include "bgpd/bgp_addpath.h"
92 #include "bgpd/bgp_evpn_private.h"
93 #include "bgpd/bgp_evpn_mh.h"
94 #include "bgpd/bgp_mac.h"
95 #include "bgp_trace.h"
97 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
98 DEFINE_MTYPE_STATIC(BGPD
, BGP_EVPN_INFO
, "BGP EVPN instance information");
99 DEFINE_QOBJ_TYPE(bgp_master
);
100 DEFINE_QOBJ_TYPE(bgp
);
101 DEFINE_QOBJ_TYPE(peer
);
102 DEFINE_HOOK(bgp_inst_delete
, (struct bgp
*bgp
), (bgp
));
104 /* BGP process wide configuration. */
105 static struct bgp_master bgp_master
;
107 /* BGP process wide configuration pointer to export. */
108 struct bgp_master
*bm
;
110 /* BGP community-list. */
111 struct community_list_handler
*bgp_clist
;
113 unsigned int multipath_num
= MULTIPATH_NUM
;
115 /* Number of bgp instances configured for suppress fib config */
116 unsigned int bgp_suppress_fib_count
;
118 static void bgp_if_finish(struct bgp
*bgp
);
119 static void peer_drop_dynamic_neighbor(struct peer
*peer
);
121 extern struct zclient
*zclient
;
123 /* handle main socket creation or deletion */
124 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
126 static int bgp_server_main_created
;
127 struct listnode
*node
;
131 if (bgp_server_main_created
)
133 if (list_isempty(bm
->addresses
)) {
134 if (bgp_socket(bgp
, bm
->port
, NULL
) < 0)
135 return BGP_ERR_INVALID_VALUE
;
137 for (ALL_LIST_ELEMENTS_RO(bm
->addresses
, node
, address
))
138 if (bgp_socket(bgp
, bm
->port
, address
) < 0)
139 return BGP_ERR_INVALID_VALUE
;
141 bgp_server_main_created
= 1;
144 if (!bgp_server_main_created
)
147 bgp_server_main_created
= 0;
151 void bgp_session_reset(struct peer
*peer
)
153 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
154 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
155 peer_delete(peer
->doppelganger
);
157 BGP_EVENT_ADD(peer
, BGP_Stop
);
161 * During session reset, we may delete the doppelganger peer, which would
162 * be the next node to the current node. If the session reset was invoked
163 * during walk of peer list, we would end up accessing the freed next
164 * node. This function moves the next node along.
166 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
171 n
= (nnode
) ? *nnode
: NULL
;
172 npeer
= (n
) ? listgetdata(n
) : NULL
;
174 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
175 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
176 PEER_FLAG_CONFIG_NODE
))) {
177 if (peer
->doppelganger
== npeer
)
178 /* nnode and *nnode are confirmed to be non-NULL here */
179 *nnode
= (*nnode
)->next
;
180 peer_delete(peer
->doppelganger
);
183 BGP_EVENT_ADD(peer
, BGP_Stop
);
186 /* BGP global flag manipulation. */
187 int bgp_option_set(int flag
)
191 case BGP_OPT_NO_LISTEN
:
192 case BGP_OPT_NO_ZEBRA
:
193 SET_FLAG(bm
->options
, flag
);
196 return BGP_ERR_INVALID_FLAG
;
201 int bgp_option_unset(int flag
)
205 case BGP_OPT_NO_ZEBRA
:
207 UNSET_FLAG(bm
->options
, flag
);
210 return BGP_ERR_INVALID_FLAG
;
215 int bgp_option_check(int flag
)
217 return CHECK_FLAG(bm
->options
, flag
);
220 /* set the bgp no-rib option during runtime and remove installed routes */
221 void bgp_option_norib_set_runtime(void)
224 struct listnode
*node
;
228 if (bgp_option_check(BGP_OPT_NO_FIB
))
231 bgp_option_set(BGP_OPT_NO_FIB
);
233 zlog_info("Disabled BGP route installation to RIB (Zebra)");
235 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp
)) {
236 FOREACH_AFI_SAFI (afi
, safi
) {
238 * Stop a crash, more work is needed
239 * here to properly add/remove these types of
242 if (!bgp_fibupd_safi(safi
))
245 bgp_zebra_withdraw_table_all_subtypes(bgp
, afi
, safi
);
249 zlog_info("All routes have been withdrawn from RIB (Zebra)");
252 /* unset the bgp no-rib option during runtime and announce routes to Zebra */
253 void bgp_option_norib_unset_runtime(void)
256 struct listnode
*node
;
260 if (!bgp_option_check(BGP_OPT_NO_FIB
))
263 bgp_option_unset(BGP_OPT_NO_FIB
);
265 zlog_info("Enabled BGP route installation to RIB (Zebra)");
267 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp
)) {
268 FOREACH_AFI_SAFI (afi
, safi
) {
270 * Stop a crash, more work is needed
271 * here to properly add/remove these types
272 * of routes from zebra
274 if (!bgp_fibupd_safi(safi
))
277 bgp_zebra_announce_table_all_subtypes(bgp
, afi
, safi
);
281 zlog_info("All routes have been installed in RIB (Zebra)");
284 /* Internal function to set BGP structure configureation flag. */
285 static void bgp_config_set(struct bgp
*bgp
, int config
)
287 SET_FLAG(bgp
->config
, config
);
290 static void bgp_config_unset(struct bgp
*bgp
, int config
)
292 UNSET_FLAG(bgp
->config
, config
);
295 static int bgp_config_check(struct bgp
*bgp
, int config
)
297 return CHECK_FLAG(bgp
->config
, config
);
300 /* Set BGP router identifier; distinguish between explicit config and other
303 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
,
307 struct listnode
*node
, *nnode
;
309 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
312 /* EVPN uses router id in RD, withdraw them */
313 if (is_evpn_enabled())
314 bgp_evpn_handle_router_id_update(bgp
, true);
316 vpn_handle_router_id_update(bgp
, true, is_config
);
318 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
320 /* Set all peer's local identifier with this value. */
321 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
322 IPV4_ADDR_COPY(&peer
->local_id
, id
);
324 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
325 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
326 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
327 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
331 /* EVPN uses router id in RD, update them */
332 if (is_evpn_enabled())
333 bgp_evpn_handle_router_id_update(bgp
, false);
335 vpn_handle_router_id_update(bgp
, false, is_config
);
340 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
342 struct listnode
*node
, *nnode
;
344 struct in_addr
*addr
= NULL
;
346 if (router_id
!= NULL
)
347 addr
= (struct in_addr
*)&(router_id
->u
.prefix4
);
349 if (vrf_id
== VRF_DEFAULT
) {
350 /* Router-id change for default VRF has to also update all
352 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
353 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
357 bgp
->router_id_zebra
= *addr
;
359 addr
= &bgp
->router_id_zebra
;
361 if (!bgp
->router_id_static
.s_addr
) {
362 /* Router ID is updated if there are no active
365 if (bgp
->established_peers
== 0) {
366 if (BGP_DEBUG(zebra
, ZEBRA
))
368 "RID change : vrf %s(%u), RTR ID %pI4",
372 * if old router-id was 0x0, set flag
373 * to use this new value
375 bgp_router_id_set(bgp
, addr
,
376 (bgp
->router_id
.s_addr
384 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
387 bgp
->router_id_zebra
= *addr
;
389 addr
= &bgp
->router_id_zebra
;
391 if (!bgp
->router_id_static
.s_addr
) {
392 /* Router ID is updated if there are no active
395 if (bgp
->established_peers
== 0) {
396 if (BGP_DEBUG(zebra
, ZEBRA
))
398 "RID change : vrf %s(%u), RTR ID %pI4",
402 * if old router-id was 0x0, set flag
403 * to use this new value
405 bgp_router_id_set(bgp
, addr
,
406 (bgp
->router_id
.s_addr
417 void bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
419 bgp
->router_id_static
= id
;
420 bgp_router_id_set(bgp
,
421 id
.s_addr
!= INADDR_ANY
? &id
: &bgp
->router_id_zebra
,
422 true /* is config */);
425 void bm_wait_for_fib_set(bool set
)
427 bool send_msg
= false;
429 if (bm
->wait_for_fib
== set
)
432 bm
->wait_for_fib
= set
;
434 if (bgp_suppress_fib_count
== 0)
436 bgp_suppress_fib_count
++;
438 bgp_suppress_fib_count
--;
439 if (bgp_suppress_fib_count
== 0)
443 if (send_msg
&& zclient
)
444 zebra_route_notify_send(ZEBRA_ROUTE_NOTIFY_REQUEST
,
448 /* Set the suppress fib pending for the bgp configuration */
449 void bgp_suppress_fib_pending_set(struct bgp
*bgp
, bool set
)
451 bool send_msg
= false;
453 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
457 SET_FLAG(bgp
->flags
, BGP_FLAG_SUPPRESS_FIB_PENDING
);
458 /* Send msg to zebra for the first instance of bgp enabled
461 if (bgp_suppress_fib_count
== 0)
463 bgp_suppress_fib_count
++;
465 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SUPPRESS_FIB_PENDING
);
466 bgp_suppress_fib_count
--;
468 /* Send msg to zebra if there are no instances enabled
471 if (bgp_suppress_fib_count
== 0)
474 /* Send route notify request to RIB */
476 if (BGP_DEBUG(zebra
, ZEBRA
))
477 zlog_debug("Sending ZEBRA_ROUTE_NOTIFY_REQUEST");
480 zebra_route_notify_send(ZEBRA_ROUTE_NOTIFY_REQUEST
,
485 /* BGP's cluster-id control. */
486 void bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
489 struct listnode
*node
, *nnode
;
491 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
492 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
495 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
496 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
498 /* Clear all IBGP peer. */
499 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
500 if (peer
->sort
!= BGP_PEER_IBGP
)
503 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
504 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
505 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
506 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
511 void bgp_cluster_id_unset(struct bgp
*bgp
)
514 struct listnode
*node
, *nnode
;
516 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
519 bgp
->cluster_id
.s_addr
= 0;
520 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
522 /* Clear all IBGP peer. */
523 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
524 if (peer
->sort
!= BGP_PEER_IBGP
)
527 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
528 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
529 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
530 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
535 /* BGP timer configuration. */
536 void bgp_timers_set(struct bgp
*bgp
, uint32_t keepalive
, uint32_t holdtime
,
537 uint32_t connect_retry
, uint32_t delayopen
)
539 bgp
->default_keepalive
=
540 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
541 bgp
->default_holdtime
= holdtime
;
542 bgp
->default_connect_retry
= connect_retry
;
543 bgp
->default_delayopen
= delayopen
;
546 /* mostly for completeness - CLI uses its own defaults */
547 void bgp_timers_unset(struct bgp
*bgp
)
549 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
550 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
551 bgp
->default_connect_retry
= BGP_DEFAULT_CONNECT_RETRY
;
552 bgp
->default_delayopen
= BGP_DEFAULT_DELAYOPEN
;
555 void bgp_tcp_keepalive_set(struct bgp
*bgp
, uint16_t keepalive_idle
,
556 uint16_t keepalive_intvl
, uint16_t keepalive_probes
)
558 bgp
->tcp_keepalive_idle
= keepalive_idle
;
559 bgp
->tcp_keepalive_intvl
= keepalive_intvl
;
560 bgp
->tcp_keepalive_probes
= keepalive_probes
;
563 void bgp_tcp_keepalive_unset(struct bgp
*bgp
)
565 bgp
->tcp_keepalive_idle
= 0;
566 bgp
->tcp_keepalive_intvl
= 0;
567 bgp
->tcp_keepalive_probes
= 0;
570 /* BGP confederation configuration. */
571 void bgp_confederation_id_set(struct bgp
*bgp
, as_t as
)
574 struct listnode
*node
, *nnode
;
580 /* Remember - were we doing confederation before? */
581 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
583 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
585 /* If we were doing confederation already, this is just an external
586 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
587 were not doing confederation before, reset all EBGP sessions. */
588 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
589 enum bgp_peer_sort ptype
= peer_sort(peer
);
591 /* We're looking for peers who's AS is not local or part of our
593 if (already_confed
) {
594 if (ptype
== BGP_PEER_EBGP
) {
596 if (BGP_IS_VALID_STATE_FOR_NOTIF(
599 PEER_DOWN_CONFED_ID_CHANGE
;
601 peer
, BGP_NOTIFY_CEASE
,
602 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
604 bgp_session_reset_safe(peer
, &nnode
);
607 /* Not doign confederation before, so reset every
610 if (ptype
!= BGP_PEER_IBGP
) {
611 /* Reset the local_as to be our EBGP one */
612 if (ptype
== BGP_PEER_EBGP
)
614 if (BGP_IS_VALID_STATE_FOR_NOTIF(
617 PEER_DOWN_CONFED_ID_CHANGE
;
619 peer
, BGP_NOTIFY_CEASE
,
620 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
622 bgp_session_reset_safe(peer
, &nnode
);
629 void bgp_confederation_id_unset(struct bgp
*bgp
)
632 struct listnode
*node
, *nnode
;
635 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
637 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
638 /* We're looking for peers who's AS is not local */
639 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
640 peer
->local_as
= bgp
->as
;
641 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
642 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
643 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
644 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
648 bgp_session_reset_safe(peer
, &nnode
);
653 /* Is an AS part of the confed or not? */
654 bool bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
661 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
662 if (bgp
->confed_peers
[i
] == as
)
668 /* Add an AS to the confederation set. */
669 void bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
)
672 struct listnode
*node
, *nnode
;
677 if (bgp_confederation_peers_check(bgp
, as
))
681 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
682 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
684 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
685 bgp
->confed_peers_cnt
++;
687 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
688 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
689 if (peer
->as
== as
) {
690 peer
->local_as
= bgp
->as
;
691 (void)peer_sort(peer
);
692 if (BGP_IS_VALID_STATE_FOR_NOTIF(
695 PEER_DOWN_CONFED_PEER_CHANGE
;
697 peer
, BGP_NOTIFY_CEASE
,
698 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
700 bgp_session_reset_safe(peer
, &nnode
);
706 /* Delete an AS from the confederation set. */
707 void bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
712 struct listnode
*node
, *nnode
;
717 if (!bgp_confederation_peers_check(bgp
, as
))
720 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
721 if (bgp
->confed_peers
[i
] == as
)
722 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
723 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
725 bgp
->confed_peers_cnt
--;
727 if (bgp
->confed_peers_cnt
== 0) {
728 if (bgp
->confed_peers
)
729 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
730 bgp
->confed_peers
= NULL
;
733 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
734 bgp
->confed_peers_cnt
* sizeof(as_t
));
736 /* Now reset any peer who's remote AS has just been removed from the
738 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
739 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
740 if (peer
->as
== as
) {
741 peer
->local_as
= bgp
->confed_id
;
742 (void)peer_sort(peer
);
743 if (BGP_IS_VALID_STATE_FOR_NOTIF(
746 PEER_DOWN_CONFED_PEER_CHANGE
;
748 peer
, BGP_NOTIFY_CEASE
,
749 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
751 bgp_session_reset_safe(peer
, &nnode
);
757 /* Local preference configuration. */
758 void bgp_default_local_preference_set(struct bgp
*bgp
, uint32_t local_pref
)
763 bgp
->default_local_pref
= local_pref
;
766 void bgp_default_local_preference_unset(struct bgp
*bgp
)
771 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
774 /* Local preference configuration. */
775 void bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
,
781 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
784 void bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
788 bgp
->default_subgroup_pkt_queue_max
=
789 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
792 /* Listen limit configuration. */
793 void bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
798 bgp
->dynamic_neighbors_limit
= listen_limit
;
801 void bgp_listen_limit_unset(struct bgp
*bgp
)
806 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
809 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
810 afi_t
*afi
, safi_t
*safi
)
812 /* Map from IANA values to internal values, return error if
813 * values are unrecognized.
815 *afi
= afi_iana2int(pkt_afi
);
816 *safi
= safi_iana2int(pkt_safi
);
817 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
823 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
824 iana_safi_t
*pkt_safi
)
826 /* Map from internal values to IANA values, return error if
827 * internal values are bad (unexpected).
829 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
831 *pkt_afi
= afi_int2iana(afi
);
832 *pkt_safi
= safi_int2iana(safi
);
836 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
845 afid
= afindex(afi
, safi
);
846 if (afid
>= BGP_AF_MAX
)
850 assert(peer
->peer_af_array
[afid
] == NULL
);
852 /* Allocate new peer af */
853 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
855 peer
->peer_af_array
[afid
] = af
;
860 bgp
->af_peer_count
[afi
][safi
]++;
865 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
872 afid
= afindex(afi
, safi
);
873 if (afid
>= BGP_AF_MAX
)
876 return peer
->peer_af_array
[afid
];
879 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
888 afid
= afindex(afi
, safi
);
889 if (afid
>= BGP_AF_MAX
)
892 af
= peer
->peer_af_array
[afid
];
897 bgp_soft_reconfig_table_task_cancel(bgp
, bgp
->rib
[afi
][safi
], peer
);
899 bgp_stop_announce_route_timer(af
);
901 if (PAF_SUBGRP(af
)) {
902 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
903 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
904 af
->subgroup
->update_group
->id
,
905 af
->subgroup
->id
, peer
->host
);
909 update_subgroup_remove_peer(af
->subgroup
, af
);
911 if (bgp
->af_peer_count
[afi
][safi
])
912 bgp
->af_peer_count
[afi
][safi
]--;
914 peer
->peer_af_array
[afid
] = NULL
;
915 XFREE(MTYPE_BGP_PEER_AF
, af
);
919 /* Peer comparison function for sorting. */
920 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
922 if (p1
->group
&& !p2
->group
)
925 if (!p1
->group
&& p2
->group
)
928 if (p1
->group
== p2
->group
) {
929 if (p1
->conf_if
&& !p2
->conf_if
)
932 if (!p1
->conf_if
&& p2
->conf_if
)
935 if (p1
->conf_if
&& p2
->conf_if
)
936 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
938 return strcmp(p1
->group
->name
, p2
->group
->name
);
940 return sockunion_cmp(&p1
->su
, &p2
->su
);
943 static unsigned int peer_hash_key_make(const void *p
)
945 const struct peer
*peer
= p
;
946 return sockunion_hash(&peer
->su
);
949 static bool peer_hash_same(const void *p1
, const void *p2
)
951 const struct peer
*peer1
= p1
;
952 const struct peer
*peer2
= p2
;
954 return (sockunion_same(&peer1
->su
, &peer2
->su
)
955 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
956 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
959 void peer_flag_inherit(struct peer
*peer
, uint64_t flag
)
963 /* Skip if peer is not a peer-group member. */
964 if (!peer_group_active(peer
))
967 /* Unset override flag to signal inheritance from peer-group. */
968 UNSET_FLAG(peer
->flags_override
, flag
);
971 * Inherit flag state from peer-group. If the flag of the peer-group is
972 * not being inverted, the peer must inherit the inverse of the current
973 * peer-group flag state.
975 group_val
= CHECK_FLAG(peer
->group
->conf
->flags
, flag
);
976 if (!CHECK_FLAG(peer
->group
->conf
->flags_invert
, flag
)
977 && CHECK_FLAG(peer
->flags_invert
, flag
))
978 COND_FLAG(peer
->flags
, flag
, !group_val
);
980 COND_FLAG(peer
->flags
, flag
, group_val
);
983 int peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
985 return CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
988 void peer_af_flag_inherit(struct peer
*peer
, afi_t afi
, safi_t safi
,
993 /* Skip if peer is not a peer-group member. */
994 if (!peer_group_active(peer
))
997 /* Unset override flag to signal inheritance from peer-group. */
998 UNSET_FLAG(peer
->af_flags_override
[afi
][safi
], flag
);
1001 * Inherit flag state from peer-group. If the flag of the peer-group is
1002 * not being inverted, the peer must inherit the inverse of the current
1003 * peer-group flag state.
1005 group_val
= CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
], flag
);
1006 if (!CHECK_FLAG(peer
->group
->conf
->af_flags_invert
[afi
][safi
], flag
)
1007 && CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
1008 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, !group_val
);
1010 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, group_val
);
1013 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
1014 static inline enum bgp_peer_sort
peer_calc_sort(struct peer
*peer
)
1021 if (peer
->change_local_as
)
1022 local_as
= peer
->change_local_as
;
1024 local_as
= peer
->local_as
;
1027 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1028 if (peer
->as_type
== AS_INTERNAL
)
1029 return BGP_PEER_IBGP
;
1031 else if (peer
->as_type
== AS_EXTERNAL
)
1032 return BGP_PEER_EBGP
;
1034 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
) {
1036 return (local_as
== peer
->as
? BGP_PEER_IBGP
1043 assert(peer
->group
);
1044 peer1
= listnode_head(peer
->group
->peer
);
1049 return BGP_PEER_INTERNAL
;
1053 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
1055 return BGP_PEER_INTERNAL
;
1057 if (local_as
== peer
->as
) {
1058 if (bgp
->as
== bgp
->confed_id
) {
1059 if (local_as
== bgp
->as
)
1060 return BGP_PEER_IBGP
;
1062 return BGP_PEER_EBGP
;
1064 if (local_as
== bgp
->confed_id
)
1065 return BGP_PEER_EBGP
;
1067 return BGP_PEER_IBGP
;
1071 if (bgp_confederation_peers_check(bgp
, peer
->as
))
1072 return BGP_PEER_CONFED
;
1074 return BGP_PEER_EBGP
;
1076 if (peer
->as_type
== AS_UNSPECIFIED
) {
1077 /* check if in peer-group with AS information */
1079 && (peer
->group
->conf
->as_type
!= AS_UNSPECIFIED
)) {
1080 if (peer
->group
->conf
->as_type
1082 if (local_as
== peer
->group
->conf
->as
)
1083 return BGP_PEER_IBGP
;
1085 return BGP_PEER_EBGP
;
1086 } else if (peer
->group
->conf
->as_type
1088 return BGP_PEER_IBGP
;
1090 return BGP_PEER_EBGP
;
1092 /* no AS information anywhere, let caller know */
1093 return BGP_PEER_UNSPECIFIED
;
1094 } else if (peer
->as_type
!= AS_SPECIFIED
)
1095 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
1098 return (local_as
== 0 ? BGP_PEER_INTERNAL
1099 : local_as
== peer
->as
? BGP_PEER_IBGP
1104 /* Calculate and cache the peer "sort" */
1105 enum bgp_peer_sort
peer_sort(struct peer
*peer
)
1107 peer
->sort
= peer_calc_sort(peer
);
1111 enum bgp_peer_sort
peer_sort_lookup(struct peer
*peer
)
1116 static void peer_free(struct peer
*peer
)
1121 assert(peer
->status
== Deleted
);
1125 /* this /ought/ to have been done already through bgp_stop earlier,
1126 * but just to be sure..
1128 bgp_timer_set(peer
);
1129 bgp_reads_off(peer
);
1130 bgp_writes_off(peer
);
1131 thread_cancel_event_ready(bm
->master
, peer
);
1132 FOREACH_AFI_SAFI (afi
, safi
)
1133 THREAD_OFF(peer
->t_revalidate_all
[afi
][safi
]);
1134 assert(!peer
->t_write
);
1135 assert(!peer
->t_read
);
1136 BGP_EVENT_FLUSH(peer
);
1138 pthread_mutex_destroy(&peer
->io_mtx
);
1140 /* Free connected nexthop, if present */
1141 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1142 && !peer_dynamic_neighbor(peer
))
1143 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
1146 FOREACH_AFI_SAFI (afi
, safi
) {
1147 if (peer
->filter
[afi
][safi
].advmap
.aname
)
1148 XFREE(MTYPE_BGP_FILTER_NAME
,
1149 peer
->filter
[afi
][safi
].advmap
.aname
);
1150 if (peer
->filter
[afi
][safi
].advmap
.cname
)
1151 XFREE(MTYPE_BGP_FILTER_NAME
,
1152 peer
->filter
[afi
][safi
].advmap
.cname
);
1155 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1157 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
1158 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1159 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
1160 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1161 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1163 /* Update source configuration. */
1164 if (peer
->update_source
) {
1165 sockunion_free(peer
->update_source
);
1166 peer
->update_source
= NULL
;
1169 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1171 XFREE(MTYPE_BGP_NOTIFICATION
, peer
->notify
.data
);
1172 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1174 if (peer
->clear_node_queue
)
1175 work_queue_free_and_null(&peer
->clear_node_queue
);
1177 bgp_sync_delete(peer
);
1179 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
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 bgp_unlock(peer
->bgp
);
1190 memset(peer
, 0, sizeof(struct peer
));
1192 XFREE(MTYPE_BGP_PEER
, peer
);
1195 /* increase reference count on a struct peer */
1196 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1198 frrtrace(2, frr_bgp
, bgp_peer_lock
, peer
, name
);
1199 assert(peer
&& (peer
->lock
>= 0));
1206 /* decrease reference count on a struct peer
1207 * struct peer is freed and NULL returned if last reference
1209 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1211 frrtrace(2, frr_bgp
, bgp_peer_unlock
, peer
, name
);
1212 assert(peer
&& (peer
->lock
> 0));
1216 if (peer
->lock
== 0) {
1223 /* BGP GR changes */
1225 int bgp_global_gr_init(struct bgp
*bgp
)
1227 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1228 zlog_debug("%s called ..", __func__
);
1230 int local_GLOBAL_GR_FSM
[BGP_GLOBAL_GR_MODE
][BGP_GLOBAL_GR_EVENT_CMD
] = {
1231 /* GLOBAL_HELPER Mode */
1234 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1235 GLOBAL_GR
, GLOBAL_INVALID
,
1236 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1237 GLOBAL_DISABLE
, GLOBAL_INVALID
1239 /* GLOBAL_GR Mode */
1242 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1243 GLOBAL_GR
, GLOBAL_HELPER
,
1244 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1245 GLOBAL_DISABLE
, GLOBAL_INVALID
1247 /* GLOBAL_DISABLE Mode */
1250 /*GLOBAL_GR_cmd */ /*no_Global_GR_cmd*/
1251 GLOBAL_GR
, GLOBAL_INVALID
,
1252 /*GLOBAL_DISABLE_cmd*//*no_Global_Disable_cmd*/
1253 GLOBAL_INVALID
, GLOBAL_HELPER
1255 /* GLOBAL_INVALID Mode */
1258 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1259 GLOBAL_INVALID
, GLOBAL_INVALID
,
1260 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1261 GLOBAL_INVALID
, GLOBAL_INVALID
1264 memcpy(bgp
->GLOBAL_GR_FSM
, local_GLOBAL_GR_FSM
,
1265 sizeof(local_GLOBAL_GR_FSM
));
1267 bgp
->global_gr_present_state
= GLOBAL_HELPER
;
1268 bgp
->present_zebra_gr_state
= ZEBRA_GR_DISABLE
;
1270 return BGP_GR_SUCCESS
;
1273 int bgp_peer_gr_init(struct peer
*peer
)
1275 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1276 zlog_debug("%s called ..", __func__
);
1278 struct bgp_peer_gr local_Peer_GR_FSM
[BGP_PEER_GR_MODE
]
1279 [BGP_PEER_GR_EVENT_CMD
] = {
1281 /* PEER_HELPER Mode */
1282 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1283 { PEER_GR
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1284 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1285 {PEER_DISABLE
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1286 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1287 { PEER_INVALID
, NULL
}, {PEER_GLOBAL_INHERIT
,
1288 bgp_peer_gr_action
}
1292 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1293 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1294 bgp_peer_gr_action
},
1295 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1296 {PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1297 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1298 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1301 /* PEER_DISABLE Mode */
1302 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1303 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1304 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1305 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1306 bgp_peer_gr_action
},
1307 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1308 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1311 /* PEER_INVALID Mode */
1312 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1313 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1314 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1315 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1316 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1317 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1320 /* PEER_GLOBAL_INHERIT Mode */
1321 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1322 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1323 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1324 { PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1325 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1326 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1329 memcpy(&peer
->PEER_GR_FSM
, local_Peer_GR_FSM
,
1330 sizeof(local_Peer_GR_FSM
));
1331 peer
->peer_gr_present_state
= PEER_GLOBAL_INHERIT
;
1332 bgp_peer_move_to_gr_mode(peer
, PEER_GLOBAL_INHERIT
);
1334 return BGP_GR_SUCCESS
;
1337 static void bgp_srv6_init(struct bgp
*bgp
)
1339 bgp
->srv6_enabled
= false;
1340 memset(bgp
->srv6_locator_name
, 0, sizeof(bgp
->srv6_locator_name
));
1341 bgp
->srv6_locator_chunks
= list_new();
1342 bgp
->srv6_functions
= list_new();
1345 static void bgp_srv6_cleanup(struct bgp
*bgp
)
1347 if (bgp
->srv6_locator_chunks
)
1348 list_delete(&bgp
->srv6_locator_chunks
);
1349 if (bgp
->srv6_functions
)
1350 list_delete(&bgp
->srv6_functions
);
1353 /* Allocate new peer object, implicitely locked. */
1354 struct peer
*peer_new(struct bgp
*bgp
)
1361 /* bgp argument is absolutely required */
1364 /* Allocate new peer. */
1365 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1367 /* Set default value. */
1369 peer
->v_start
= BGP_INIT_START_TIMER
;
1370 peer
->v_connect
= bgp
->default_connect_retry
;
1371 peer
->status
= Idle
;
1372 peer
->ostatus
= Idle
;
1373 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1374 peer
->bgp
= bgp_lock(bgp
);
1375 peer
= peer_lock(peer
); /* initial reference */
1376 peer
->local_role
= ROLE_UNDEFINED
;
1377 peer
->remote_role
= ROLE_UNDEFINED
;
1378 peer
->password
= NULL
;
1379 peer
->max_packet_size
= BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE
;
1381 /* Set default flags. */
1382 FOREACH_AFI_SAFI (afi
, safi
) {
1383 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1384 SET_FLAG(peer
->af_flags
[afi
][safi
],
1385 PEER_FLAG_SEND_EXT_COMMUNITY
);
1386 SET_FLAG(peer
->af_flags
[afi
][safi
],
1387 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1389 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1390 PEER_FLAG_SEND_COMMUNITY
);
1391 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1392 PEER_FLAG_SEND_EXT_COMMUNITY
);
1393 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1394 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1395 peer
->addpath_type
[afi
][safi
] = BGP_ADDPATH_NONE
;
1396 peer
->soo
[afi
][safi
] = NULL
;
1399 /* set nexthop-unchanged for l2vpn evpn by default */
1400 SET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1401 PEER_FLAG_NEXTHOP_UNCHANGED
);
1403 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1405 /* Initialize per peer bgp GR FSM */
1406 bgp_peer_gr_init(peer
);
1408 /* Create buffers. */
1409 peer
->ibuf
= stream_fifo_new();
1410 peer
->obuf
= stream_fifo_new();
1411 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1413 /* We use a larger buffer for peer->obuf_work in the event that:
1414 * - We RX a BGP_UPDATE where the attributes alone are just
1415 * under BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE.
1416 * - The user configures an outbound route-map that does many as-path
1417 * prepends or adds many communities. At most they can have
1418 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1419 * large they can make the attributes.
1421 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1422 * bounds checking for every single attribute as we construct an
1426 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1428 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1430 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1432 bgp_sync_init(peer
);
1434 /* Get service port number. */
1435 sp
= getservbyname("bgp", "tcp");
1436 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1438 QOBJ_REG(peer
, peer
);
1443 * This function is invoked when a duplicate peer structure associated with
1444 * a neighbor is being deleted. If this about-to-be-deleted structure is
1445 * the one with all the config, then we have to copy over the info.
1447 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1449 struct peer_af
*paf
;
1457 /* The following function is used by both peer group config copy to
1458 * individual peer and when we transfer config
1460 if (peer_src
->change_local_as
)
1461 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1463 /* peer flags apply */
1464 peer_dst
->flags
= peer_src
->flags
;
1466 * The doppelganger *must* not have a config node stored
1468 UNSET_FLAG(peer_dst
->flags
, PEER_FLAG_CONFIG_NODE
);
1469 peer_dst
->peer_gr_present_state
= peer_src
->peer_gr_present_state
;
1470 peer_dst
->peer_gr_new_status_flag
= peer_src
->peer_gr_new_status_flag
;
1472 peer_dst
->local_as
= peer_src
->local_as
;
1473 peer_dst
->port
= peer_src
->port
;
1474 /* copy tcp_mss value */
1475 peer_dst
->tcp_mss
= peer_src
->tcp_mss
;
1476 (void)peer_sort(peer_dst
);
1477 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1478 peer_dst
->local_role
= peer_src
->local_role
;
1480 peer_dst
->max_packet_size
= peer_src
->max_packet_size
;
1483 peer_dst
->holdtime
= peer_src
->holdtime
;
1484 peer_dst
->keepalive
= peer_src
->keepalive
;
1485 peer_dst
->connect
= peer_src
->connect
;
1486 peer_dst
->delayopen
= peer_src
->delayopen
;
1487 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1488 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1489 peer_dst
->routeadv
= peer_src
->routeadv
;
1490 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1491 peer_dst
->v_delayopen
= peer_src
->v_delayopen
;
1493 /* password apply */
1494 if (peer_src
->password
&& !peer_dst
->password
)
1495 peer_dst
->password
=
1496 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1498 FOREACH_AFI_SAFI (afi
, safi
) {
1499 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1500 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1501 peer_dst
->allowas_in
[afi
][safi
] =
1502 peer_src
->allowas_in
[afi
][safi
];
1503 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1504 peer_dst
->addpath_type
[afi
][safi
] =
1505 peer_src
->addpath_type
[afi
][safi
];
1508 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1509 paf
= peer_src
->peer_af_array
[afidx
];
1511 if (!peer_af_find(peer_dst
, paf
->afi
, paf
->safi
))
1512 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1516 /* update-source apply */
1517 if (peer_src
->update_source
) {
1518 if (peer_dst
->update_source
)
1519 sockunion_free(peer_dst
->update_source
);
1520 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1521 peer_dst
->update_source
=
1522 sockunion_dup(peer_src
->update_source
);
1523 } else if (peer_src
->update_if
) {
1524 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1525 if (peer_dst
->update_source
) {
1526 sockunion_free(peer_dst
->update_source
);
1527 peer_dst
->update_source
= NULL
;
1529 peer_dst
->update_if
=
1530 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1533 if (peer_src
->ifname
) {
1534 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1537 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1541 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1542 struct interface
*ifp
)
1544 struct connected
*ifc
;
1547 struct listnode
*node
;
1549 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1550 * IPv4 address of the other end.
1552 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1553 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1554 prefix_copy(&p
, CONNECTED_PREFIX(ifc
));
1555 if (p
.prefixlen
== 30) {
1556 peer
->su
.sa
.sa_family
= AF_INET
;
1557 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1559 peer
->su
.sin
.sin_addr
.s_addr
=
1561 else if (addr
% 4 == 2)
1562 peer
->su
.sin
.sin_addr
.s_addr
=
1564 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1565 peer
->su
.sin
.sin_len
=
1566 sizeof(struct sockaddr_in
);
1567 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1569 } else if (p
.prefixlen
== 31) {
1570 peer
->su
.sa
.sa_family
= AF_INET
;
1571 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1573 peer
->su
.sin
.sin_addr
.s_addr
=
1576 peer
->su
.sin
.sin_addr
.s_addr
=
1578 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1579 peer
->su
.sin
.sin_len
=
1580 sizeof(struct sockaddr_in
);
1581 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1583 } else if (bgp_debug_neighbor_events(peer
))
1585 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1593 static bool bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1594 struct interface
*ifp
)
1596 struct nbr_connected
*ifc_nbr
;
1598 /* Have we learnt the peer's IPv6 link-local address? */
1599 if (ifp
->nbr_connected
1600 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1601 peer
->su
.sa
.sa_family
= AF_INET6
;
1602 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1603 sizeof(struct in6_addr
));
1605 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1607 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1615 * Set or reset the peer address socketunion structure based on the
1616 * learnt/derived peer address. If the address has changed, update the
1617 * password on the listen socket, if needed.
1619 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1621 struct interface
*ifp
;
1623 int peer_addr_updated
= 0;
1624 struct listnode
*node
;
1625 union sockunion old_su
;
1628 * This function is only ever needed when FRR an interface
1629 * based peering, so this simple test will tell us if
1630 * we are in an interface based configuration or not
1637 prev_family
= peer
->su
.sa
.sa_family
;
1638 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1640 /* If BGP unnumbered is not "v6only", we first see if we can
1642 * peer's IPv4 address.
1644 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1646 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1648 /* If "v6only" or we can't derive peer's IPv4 address, see if
1650 * learnt the peer's IPv6 link-local address. This is from the
1652 * IPv6 address in router advertisement.
1654 if (!peer_addr_updated
)
1656 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1658 /* If we could derive the peer address, we may need to install the
1660 * configured for the peer, if any, on the listen socket. Otherwise,
1662 * that peer's address is not available and uninstall the password, if
1665 if (peer_addr_updated
) {
1666 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1667 && prev_family
== AF_UNSPEC
)
1670 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1671 && prev_family
!= AF_UNSPEC
)
1672 bgp_md5_unset(peer
);
1673 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1674 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1678 * If they are the same, nothing to do here, move along
1680 if (!sockunion_same(&old_su
, &peer
->su
)) {
1681 union sockunion new_su
= peer
->su
;
1682 struct bgp
*bgp
= peer
->bgp
;
1685 * Our peer structure is stored in the bgp->peerhash
1686 * release it before we modify anything in both the
1687 * hash and the list. But *only* if the peer
1688 * is in the bgp->peerhash as that on deletion
1689 * we call bgp_stop which calls this function :(
1690 * so on deletion let's remove from the list first
1691 * and then do the deletion preventing this from
1692 * being added back on the list below when we
1693 * fail to remove it up here.
1697 * listnode_lookup just scans the list
1698 * for the peer structure so it's safe
1699 * to use without modifying the su
1701 node
= listnode_lookup(bgp
->peer
, peer
);
1704 * Let's reset the peer->su release and
1705 * reset it and put it back. We have to
1706 * do this because hash_release will
1707 * scan through looking for a matching
1711 hash_release(peer
->bgp
->peerhash
, peer
);
1712 listnode_delete(peer
->bgp
->peer
, peer
);
1715 (void)hash_get(peer
->bgp
->peerhash
, peer
,
1717 listnode_add_sort(peer
->bgp
->peer
, peer
);
1722 void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1724 struct bgp_dest
*dest
, *ndest
;
1725 struct bgp_table
*table
;
1727 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
1728 dest
= bgp_route_next(dest
)) {
1729 table
= bgp_dest_get_bgp_table_info(dest
);
1730 if (table
!= NULL
) {
1731 /* Special handling for 2-level routing
1733 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1734 || safi
== SAFI_EVPN
) {
1735 for (ndest
= bgp_table_top(table
); ndest
;
1736 ndest
= bgp_route_next(ndest
))
1737 bgp_process(bgp
, ndest
, afi
, safi
);
1739 bgp_process(bgp
, dest
, afi
, safi
);
1744 /* Force a bestpath recalculation for all prefixes. This is used
1745 * when 'bgp bestpath' commands are entered.
1747 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1752 FOREACH_AFI_SAFI (afi
, safi
) {
1753 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1758 * Create new BGP peer.
1760 * conf_if and su are mutually exclusive if configuring from the cli.
1761 * If we are handing a doppelganger, then we *must* pass in both
1762 * the original peer's su and conf_if, so that we can appropriately
1763 * track the bgp->peerhash( ie we don't want to remove the current
1764 * one from the config ).
1766 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1767 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1768 int as_type
, struct peer_group
*group
,
1773 char buf
[SU_ADDRSTRLEN
];
1777 peer
= peer_new(bgp
);
1779 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1783 bgp_peer_conf_if_to_su_update(peer
);
1784 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1785 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1788 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1789 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1790 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1792 peer
->local_as
= local_as
;
1793 peer
->as
= remote_as
;
1794 peer
->as_type
= as_type
;
1795 peer
->local_id
= bgp
->router_id
;
1796 peer
->v_holdtime
= bgp
->default_holdtime
;
1797 peer
->v_keepalive
= bgp
->default_keepalive
;
1798 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1799 ? BGP_DEFAULT_IBGP_ROUTEADV
1800 : BGP_DEFAULT_EBGP_ROUTEADV
;
1801 if (bgp_config_inprocess())
1802 peer
->shut_during_cfg
= true;
1804 peer
= peer_lock(peer
); /* bgp peer list reference */
1805 peer
->group
= group
;
1806 listnode_add_sort(bgp
->peer
, peer
);
1809 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1811 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1813 /* Adjust update-group coalesce timer heuristics for # peers. */
1814 if (bgp
->heuristic_coalesce
) {
1815 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1817 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1818 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1821 active
= peer_active(peer
);
1823 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
)
1824 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1826 peer
->last_reset
= PEER_DOWN_NOAFI_ACTIVATED
;
1829 /* Last read and reset time set */
1830 peer
->readtime
= peer
->resettime
= monotime(NULL
);
1832 /* Default TTL set. */
1833 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: BGP_DEFAULT_TTL
;
1835 /* Default configured keepalives count for shutdown rtt command */
1836 peer
->rtt_keepalive_conf
= 1;
1838 /* If 'bgp default <afi>-<safi>' is configured, then activate the
1839 * neighbor for the corresponding address family. IPv4 Unicast is
1840 * the only address family enabled by default without expliict
1843 FOREACH_AFI_SAFI (afi
, safi
) {
1844 if (bgp
->default_af
[afi
][safi
]) {
1845 peer
->afc
[afi
][safi
] = 1;
1846 peer_af_create(peer
, afi
, safi
);
1850 /* auto shutdown if configured */
1851 if (bgp
->autoshutdown
)
1852 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1853 /* Set up peer's events and timers. */
1854 else if (!active
&& peer_active(peer
))
1855 bgp_timer_set(peer
);
1857 bgp_peer_gr_flags_update(peer
);
1858 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp
, bgp
->peer
);
1863 /* Make accept BGP peer. This function is only called from the test code */
1864 struct peer
*peer_create_accept(struct bgp
*bgp
)
1868 peer
= peer_new(bgp
);
1870 peer
= peer_lock(peer
); /* bgp peer list reference */
1871 listnode_add_sort(bgp
->peer
, peer
);
1872 (void)hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1878 * Return true if we have a peer configured to use this afi/safi
1880 bool bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1882 struct listnode
*node
;
1885 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1886 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1889 if (peer
->afc
[afi
][safi
])
1896 /* Change peer's AS number. */
1897 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
)
1899 enum bgp_peer_sort origtype
, newtype
;
1902 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1903 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1904 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1905 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1906 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1908 bgp_session_reset(peer
);
1910 origtype
= peer_sort_lookup(peer
);
1912 peer
->as_type
= as_specified
;
1914 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1915 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1916 && peer
->bgp
->as
!= as
)
1917 peer
->local_as
= peer
->bgp
->confed_id
;
1919 peer
->local_as
= peer
->bgp
->as
;
1921 newtype
= peer_sort(peer
);
1922 /* Advertisement-interval reset */
1923 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1924 peer
->v_routeadv
= (newtype
== BGP_PEER_IBGP
)
1925 ? BGP_DEFAULT_IBGP_ROUTEADV
1926 : BGP_DEFAULT_EBGP_ROUTEADV
;
1930 if (newtype
== BGP_PEER_IBGP
)
1932 else if (origtype
== BGP_PEER_IBGP
)
1933 peer
->ttl
= BGP_DEFAULT_TTL
;
1935 /* reflector-client reset */
1936 if (newtype
!= BGP_PEER_IBGP
) {
1937 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1938 PEER_FLAG_REFLECTOR_CLIENT
);
1939 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1940 PEER_FLAG_REFLECTOR_CLIENT
);
1941 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1942 PEER_FLAG_REFLECTOR_CLIENT
);
1943 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1944 PEER_FLAG_REFLECTOR_CLIENT
);
1945 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1946 PEER_FLAG_REFLECTOR_CLIENT
);
1947 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1948 PEER_FLAG_REFLECTOR_CLIENT
);
1949 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1950 PEER_FLAG_REFLECTOR_CLIENT
);
1951 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1952 PEER_FLAG_REFLECTOR_CLIENT
);
1953 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1954 PEER_FLAG_REFLECTOR_CLIENT
);
1955 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1956 PEER_FLAG_REFLECTOR_CLIENT
);
1957 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1958 PEER_FLAG_REFLECTOR_CLIENT
);
1959 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1960 PEER_FLAG_REFLECTOR_CLIENT
);
1961 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1962 PEER_FLAG_REFLECTOR_CLIENT
);
1966 /* If peer does not exist, create new one. If peer already exists,
1967 set AS number to the peer. */
1968 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1969 as_t
*as
, int as_type
)
1975 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1977 peer
= peer_lookup(bgp
, su
);
1980 /* Not allowed for a dynamic peer. */
1981 if (peer_dynamic_neighbor(peer
)) {
1983 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1986 /* When this peer is a member of peer-group. */
1988 /* peer-group already has AS number/internal/external */
1989 if (peer
->group
->conf
->as
1990 || peer
->group
->conf
->as_type
) {
1991 /* Return peer group's AS number. */
1992 *as
= peer
->group
->conf
->as
;
1993 return BGP_ERR_PEER_GROUP_MEMBER
;
1996 enum bgp_peer_sort peer_sort_type
=
1997 peer_sort(peer
->group
->conf
);
1999 /* Explicit AS numbers used, compare AS numbers */
2000 if (as_type
== AS_SPECIFIED
) {
2001 if (((peer_sort_type
== BGP_PEER_IBGP
)
2002 && (bgp
->as
!= *as
))
2003 || ((peer_sort_type
== BGP_PEER_EBGP
)
2004 && (bgp
->as
== *as
))) {
2006 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2009 /* internal/external used, compare as-types */
2010 if (((peer_sort_type
== BGP_PEER_IBGP
)
2011 && (as_type
!= AS_INTERNAL
))
2012 || ((peer_sort_type
== BGP_PEER_EBGP
)
2013 && (as_type
!= AS_EXTERNAL
))) {
2015 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2020 /* Existing peer's AS number change. */
2021 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2022 || (peer
->as_type
!= as_type
))
2023 peer_as_change(peer
, *as
, as_type
);
2026 return BGP_ERR_NO_INTERFACE_CONFIG
;
2028 /* If the peer is not part of our confederation, and its not an
2029 iBGP peer then spoof the source AS */
2030 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)
2031 && !bgp_confederation_peers_check(bgp
, *as
)
2033 local_as
= bgp
->confed_id
;
2037 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, NULL
,
2044 const char *bgp_get_name_by_role(uint8_t role
)
2049 case ROLE_RS_SERVER
:
2051 case ROLE_RS_CLIENT
:
2057 case ROLE_UNDEFINED
:
2063 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
2064 struct peer
*peer
, afi_t afi
,
2068 int out
= FILTER_OUT
;
2070 uint64_t pflags_ovrd
;
2071 uint8_t *pfilter_ovrd
;
2075 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
2076 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
2078 /* peer af_flags apply */
2079 flags_tmp
= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
2080 flags_tmp
^= conf
->af_flags_invert
[afi
][safi
]
2081 ^ peer
->af_flags_invert
[afi
][safi
];
2082 flags_tmp
&= ~pflags_ovrd
;
2084 UNSET_FLAG(peer
->af_flags
[afi
][safi
], ~pflags_ovrd
);
2085 SET_FLAG(peer
->af_flags
[afi
][safi
], flags_tmp
);
2086 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
2087 conf
->af_flags_invert
[afi
][safi
]);
2089 /* maximum-prefix */
2090 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
2091 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
2092 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
2093 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
2096 /* maximum-prefix-out */
2097 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX_OUT
))
2098 PEER_ATTR_INHERIT(peer
, group
, pmax_out
[afi
][safi
]);
2101 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
2102 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
2105 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_SOO
))
2106 PEER_ATTR_INHERIT(peer
, group
, soo
[afi
][safi
]);
2109 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
2110 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
2112 /* default-originate route-map */
2113 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
2114 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
2115 MTYPE_ROUTE_MAP_NAME
);
2116 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
2119 /* inbound filter apply */
2120 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
2121 PEER_STR_ATTR_INHERIT(peer
, group
,
2122 filter
[afi
][safi
].dlist
[in
].name
,
2123 MTYPE_BGP_FILTER_NAME
);
2124 PEER_ATTR_INHERIT(peer
, group
,
2125 filter
[afi
][safi
].dlist
[in
].alist
);
2128 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
2129 PEER_STR_ATTR_INHERIT(peer
, group
,
2130 filter
[afi
][safi
].plist
[in
].name
,
2131 MTYPE_BGP_FILTER_NAME
);
2132 PEER_ATTR_INHERIT(peer
, group
,
2133 filter
[afi
][safi
].plist
[in
].plist
);
2136 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
2137 PEER_STR_ATTR_INHERIT(peer
, group
,
2138 filter
[afi
][safi
].aslist
[in
].name
,
2139 MTYPE_BGP_FILTER_NAME
);
2140 PEER_ATTR_INHERIT(peer
, group
,
2141 filter
[afi
][safi
].aslist
[in
].aslist
);
2144 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
2145 PEER_STR_ATTR_INHERIT(peer
, group
,
2146 filter
[afi
][safi
].map
[in
].name
,
2147 MTYPE_BGP_FILTER_NAME
);
2148 PEER_ATTR_INHERIT(peer
, group
,
2149 filter
[afi
][safi
].map
[RMAP_IN
].map
);
2152 /* outbound filter apply */
2153 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
2154 PEER_STR_ATTR_INHERIT(peer
, group
,
2155 filter
[afi
][safi
].dlist
[out
].name
,
2156 MTYPE_BGP_FILTER_NAME
);
2157 PEER_ATTR_INHERIT(peer
, group
,
2158 filter
[afi
][safi
].dlist
[out
].alist
);
2161 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
2162 PEER_STR_ATTR_INHERIT(peer
, group
,
2163 filter
[afi
][safi
].plist
[out
].name
,
2164 MTYPE_BGP_FILTER_NAME
);
2165 PEER_ATTR_INHERIT(peer
, group
,
2166 filter
[afi
][safi
].plist
[out
].plist
);
2169 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
2170 PEER_STR_ATTR_INHERIT(peer
, group
,
2171 filter
[afi
][safi
].aslist
[out
].name
,
2172 MTYPE_BGP_FILTER_NAME
);
2173 PEER_ATTR_INHERIT(peer
, group
,
2174 filter
[afi
][safi
].aslist
[out
].aslist
);
2177 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
2178 PEER_STR_ATTR_INHERIT(peer
, group
,
2179 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
2180 MTYPE_BGP_FILTER_NAME
);
2181 PEER_ATTR_INHERIT(peer
, group
,
2182 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
2185 /* nondirectional filter apply */
2186 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
2187 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
2188 MTYPE_BGP_FILTER_NAME
);
2189 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
2192 /* Conditional Advertisements */
2193 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ADVERTISE_MAP
)) {
2194 PEER_STR_ATTR_INHERIT(peer
, group
,
2195 filter
[afi
][safi
].advmap
.aname
,
2196 MTYPE_BGP_FILTER_NAME
);
2197 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.amap
);
2198 PEER_STR_ATTR_INHERIT(peer
, group
,
2199 filter
[afi
][safi
].advmap
.cname
,
2200 MTYPE_BGP_FILTER_NAME
);
2201 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].advmap
.cmap
);
2202 PEER_ATTR_INHERIT(peer
, group
,
2203 filter
[afi
][safi
].advmap
.condition
);
2206 if (peer
->addpath_type
[afi
][safi
] == BGP_ADDPATH_NONE
) {
2207 peer
->addpath_type
[afi
][safi
] = conf
->addpath_type
[afi
][safi
];
2208 bgp_addpath_type_changed(conf
->bgp
);
2212 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
2217 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2218 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2219 __func__
, peer
->host
);
2223 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
2225 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2226 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
2227 return BGP_ERR_PEER_SAFI_CONFLICT
;
2229 /* Nothing to do if we've already activated this peer */
2230 if (peer
->afc
[afi
][safi
])
2233 if (peer_af_create(peer
, afi
, safi
) == NULL
)
2236 active
= peer_active(peer
);
2237 peer
->afc
[afi
][safi
] = 1;
2240 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
2242 if (!active
&& peer_active(peer
)) {
2243 bgp_timer_set(peer
);
2245 if (peer_established(peer
)) {
2246 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2247 peer
->afc_adv
[afi
][safi
] = 1;
2248 bgp_capability_send(peer
, afi
, safi
,
2250 CAPABILITY_ACTION_SET
);
2251 if (peer
->afc_recv
[afi
][safi
]) {
2252 peer
->afc_nego
[afi
][safi
] = 1;
2253 bgp_announce_route(peer
, afi
, safi
,
2257 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2258 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2259 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2262 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
2263 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2264 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2265 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2268 * If we are turning on a AFI/SAFI locally and we've
2269 * started bringing a peer up, we need to tell
2270 * the other peer to restart because we might loose
2271 * configuration here because when the doppelganger
2272 * gets to a established state due to how
2273 * we resolve we could just overwrite the afi/safi
2276 other
= peer
->doppelganger
;
2278 && (other
->status
== OpenSent
2279 || other
->status
== OpenConfirm
)) {
2280 other
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2281 bgp_notify_send(other
, BGP_NOTIFY_CEASE
,
2282 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2289 /* Activate the peer or peer group for specified AFI and SAFI. */
2290 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2293 struct peer_group
*group
;
2294 struct listnode
*node
, *nnode
;
2295 struct peer
*tmp_peer
;
2298 /* Nothing to do if we've already activated this peer */
2299 if (peer
->afc
[afi
][safi
])
2304 /* This is a peer-group so activate all of the members of the
2305 * peer-group as well */
2306 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2308 /* Do not activate a peer for both SAFI_UNICAST and
2309 * SAFI_LABELED_UNICAST */
2310 if ((safi
== SAFI_UNICAST
2311 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2312 || (safi
== SAFI_LABELED_UNICAST
2313 && peer
->afc
[afi
][SAFI_UNICAST
]))
2314 return BGP_ERR_PEER_SAFI_CONFLICT
;
2316 peer
->afc
[afi
][safi
] = 1;
2317 group
= peer
->group
;
2319 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2320 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2323 ret
|= peer_activate_af(peer
, afi
, safi
);
2326 /* If this is the first peer to be activated for this
2327 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2328 if (ret
!= BGP_ERR_PEER_SAFI_CONFLICT
&& safi
== SAFI_LABELED_UNICAST
2329 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2331 if (BGP_DEBUG(zebra
, ZEBRA
))
2333 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2335 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2336 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2339 if (safi
== SAFI_FLOWSPEC
) {
2340 /* connect to table manager */
2341 bgp_zebra_init_tm_connect(bgp
);
2346 static bool non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2349 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2350 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2351 __func__
, peer
->host
);
2355 /* Nothing to do if we've already deactivated this peer */
2356 if (!peer
->afc
[afi
][safi
])
2359 /* De-activate the address family configuration. */
2360 peer
->afc
[afi
][safi
] = 0;
2362 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2363 flog_err(EC_BGP_PEER_DELETE
,
2364 "couldn't delete af structure for peer %s(%s, %s)",
2365 peer
->host
, afi2str(afi
), safi2str(safi
));
2369 if (peer_established(peer
)) {
2370 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2371 peer
->afc_adv
[afi
][safi
] = 0;
2372 peer
->afc_nego
[afi
][safi
] = 0;
2374 if (peer_active_nego(peer
)) {
2375 bgp_capability_send(peer
, afi
, safi
,
2377 CAPABILITY_ACTION_UNSET
);
2378 bgp_clear_route(peer
, afi
, safi
);
2379 peer
->pcount
[afi
][safi
] = 0;
2381 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2382 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2383 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2386 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2387 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2388 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2395 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2398 struct peer_group
*group
;
2399 struct peer
*tmp_peer
;
2400 struct listnode
*node
, *nnode
;
2403 /* Nothing to do if we've already de-activated this peer */
2404 if (!peer
->afc
[afi
][safi
])
2407 /* This is a peer-group so de-activate all of the members of the
2408 * peer-group as well */
2409 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2410 peer
->afc
[afi
][safi
] = 0;
2411 group
= peer
->group
;
2413 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2414 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2417 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2422 /* If this is the last peer to be deactivated for this
2423 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2424 if (safi
== SAFI_LABELED_UNICAST
2425 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2426 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2428 if (BGP_DEBUG(zebra
, ZEBRA
))
2430 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2432 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2433 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2438 void peer_nsf_stop(struct peer
*peer
)
2443 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2444 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2446 FOREACH_AFI_SAFI_NSF (afi
, safi
) {
2447 peer
->nsf
[afi
][safi
] = 0;
2448 THREAD_OFF(peer
->t_llgr_stale
[afi
][safi
]);
2451 if (peer
->t_gr_restart
) {
2452 THREAD_OFF(peer
->t_gr_restart
);
2453 if (bgp_debug_neighbor_events(peer
))
2454 zlog_debug("%pBP graceful restart timer stopped", peer
);
2456 if (peer
->t_gr_stale
) {
2457 THREAD_OFF(peer
->t_gr_stale
);
2458 if (bgp_debug_neighbor_events(peer
))
2460 "%pBP graceful restart stalepath timer stopped",
2463 bgp_clear_route_all(peer
);
2466 /* Delete peer from confguration.
2468 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2469 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2471 * This function /should/ take care to be idempotent, to guard against
2472 * it being called multiple times through stray events that come in
2473 * that happen to result in this function being called again. That
2474 * said, getting here for a "Deleted" peer is a bug in the neighbour
2477 int peer_delete(struct peer
*peer
)
2483 struct bgp_filter
*filter
;
2484 struct listnode
*pn
;
2487 assert(peer
->status
!= Deleted
);
2490 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2492 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, peer
);
2494 bgp_keepalives_off(peer
);
2495 bgp_reads_off(peer
);
2496 bgp_writes_off(peer
);
2497 thread_cancel_event_ready(bm
->master
, peer
);
2498 FOREACH_AFI_SAFI (afi
, safi
)
2499 THREAD_OFF(peer
->t_revalidate_all
[afi
][safi
]);
2500 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2501 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2502 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_KEEPALIVES_ON
));
2504 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2505 peer_nsf_stop(peer
);
2507 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2509 /* Remove BFD settings. */
2510 if (peer
->bfd_config
)
2511 bgp_peer_remove_bfd_config(peer
);
2513 /* If this peer belongs to peer group, clear up the
2516 if (peer_dynamic_neighbor(peer
))
2517 peer_drop_dynamic_neighbor(peer
);
2519 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2521 peer
); /* group->peer list reference */
2522 list_delete_node(peer
->group
->peer
, pn
);
2527 /* Withdraw all information from routing table. We can not use
2528 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2529 * executed after peer structure is deleted.
2531 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2533 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2535 if (peer
->doppelganger
) {
2536 peer
->doppelganger
->doppelganger
= NULL
;
2537 peer
->doppelganger
= NULL
;
2540 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2541 bgp_fsm_change_status(peer
, Deleted
);
2543 /* Remove from NHT */
2544 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2545 bgp_unlink_nexthop_by_peer(peer
);
2547 /* Password configuration */
2548 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)) {
2549 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2550 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2551 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2552 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
))
2553 bgp_md5_unset(peer
);
2556 bgp_timer_set(peer
); /* stops all timers for Deleted */
2558 /* Delete from all peer list. */
2559 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2560 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2562 * Removing from the list node first because
2563 * peer_unlock *can* call peer_delete( I know,
2564 * I know ). So let's remove it and in
2565 * the su recalculate function we'll ensure
2566 * it's in there or not.
2568 list_delete_node(bgp
->peer
, pn
);
2569 hash_release(bgp
->peerhash
, peer
);
2570 peer_unlock(peer
); /* bgp peer list reference */
2575 stream_fifo_free(peer
->ibuf
);
2580 stream_fifo_free(peer
->obuf
);
2584 if (peer
->ibuf_work
) {
2585 ringbuf_del(peer
->ibuf_work
);
2586 peer
->ibuf_work
= NULL
;
2589 if (peer
->obuf_work
) {
2590 stream_free(peer
->obuf_work
);
2591 peer
->obuf_work
= NULL
;
2594 if (peer
->scratch
) {
2595 stream_free(peer
->scratch
);
2596 peer
->scratch
= NULL
;
2599 /* Local and remote addresses. */
2600 if (peer
->su_local
) {
2601 sockunion_free(peer
->su_local
);
2602 peer
->su_local
= NULL
;
2605 if (peer
->su_remote
) {
2606 sockunion_free(peer
->su_remote
);
2607 peer
->su_remote
= NULL
;
2610 /* Free filter related memory. */
2611 FOREACH_AFI_SAFI (afi
, safi
) {
2612 filter
= &peer
->filter
[afi
][safi
];
2614 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2615 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2616 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2617 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2620 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2621 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2624 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2625 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2626 ecommunity_free(&peer
->soo
[afi
][safi
]);
2629 FOREACH_AFI_SAFI (afi
, safi
)
2630 peer_af_delete(peer
, afi
, safi
);
2632 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2633 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2635 peer_unlock(peer
); /* initial reference */
2640 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2642 return strcmp(g1
->name
, g2
->name
);
2645 /* Peer group cofiguration. */
2646 static struct peer_group
*peer_group_new(void)
2648 return XCALLOC(MTYPE_PEER_GROUP
, sizeof(struct peer_group
));
2651 static void peer_group_free(struct peer_group
*group
)
2653 XFREE(MTYPE_PEER_GROUP
, group
);
2656 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2658 struct peer_group
*group
;
2659 struct listnode
*node
, *nnode
;
2661 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2662 if (strcmp(group
->name
, name
) == 0)
2668 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2670 struct peer_group
*group
;
2674 group
= peer_group_lookup(bgp
, name
);
2678 group
= peer_group_new();
2680 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2681 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2682 group
->peer
= list_new();
2683 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2684 group
->listen_range
[afi
] = list_new();
2685 group
->conf
= peer_new(bgp
);
2686 FOREACH_AFI_SAFI (afi
, safi
) {
2687 if (bgp
->default_af
[afi
][safi
])
2688 group
->conf
->afc
[afi
][safi
] = 1;
2690 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2691 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2692 group
->conf
->group
= group
;
2693 group
->conf
->as
= 0;
2694 group
->conf
->ttl
= BGP_DEFAULT_TTL
;
2695 group
->conf
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
2696 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2697 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2698 listnode_add_sort(bgp
->group
, group
);
2703 static void peer_group2peer_config_copy(struct peer_group
*group
,
2708 bool config_node
= !!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2714 peer
->as
= conf
->as
;
2717 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_LOCAL_AS
))
2718 peer
->change_local_as
= conf
->change_local_as
;
2720 /* If peer-group has configured TTL then override it */
2721 if (conf
->ttl
!= BGP_DEFAULT_TTL
)
2722 peer
->ttl
= conf
->ttl
;
2725 peer
->gtsm_hops
= conf
->gtsm_hops
;
2727 /* peer flags apply */
2728 flags_tmp
= conf
->flags
& ~peer
->flags_override
;
2729 flags_tmp
^= conf
->flags_invert
^ peer
->flags_invert
;
2730 flags_tmp
&= ~peer
->flags_override
;
2732 UNSET_FLAG(peer
->flags
, ~peer
->flags_override
);
2733 SET_FLAG(peer
->flags
, flags_tmp
);
2734 SET_FLAG(peer
->flags_invert
, conf
->flags_invert
);
2737 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2739 /* peer timers apply */
2740 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2741 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2742 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2745 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2746 PEER_ATTR_INHERIT(peer
, group
, connect
);
2747 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2748 peer
->v_connect
= conf
->connect
;
2750 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
2753 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_DELAYOPEN
)) {
2754 PEER_ATTR_INHERIT(peer
, group
, delayopen
);
2755 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_DELAYOPEN
))
2756 peer
->v_delayopen
= conf
->delayopen
;
2758 peer
->v_delayopen
= peer
->bgp
->default_delayopen
;
2761 /* advertisement-interval apply */
2762 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2763 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2764 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2765 peer
->v_routeadv
= conf
->routeadv
;
2767 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2768 ? BGP_DEFAULT_IBGP_ROUTEADV
2769 : BGP_DEFAULT_EBGP_ROUTEADV
;
2772 /* capability extended-nexthop apply */
2773 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_CAPABILITY_ENHE
))
2774 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2775 SET_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
);
2777 /* password apply */
2778 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_PASSWORD
))
2779 PEER_STR_ATTR_INHERIT(peer
, group
, password
,
2780 MTYPE_PEER_PASSWORD
);
2782 if (!BGP_PEER_SU_UNSPEC(peer
))
2785 /* update-source apply */
2786 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_UPDATE_SOURCE
)) {
2787 if (conf
->update_source
) {
2788 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2789 PEER_SU_ATTR_INHERIT(peer
, group
, update_source
);
2790 } else if (conf
->update_if
) {
2791 sockunion_free(peer
->update_source
);
2792 PEER_STR_ATTR_INHERIT(peer
, group
, update_if
,
2793 MTYPE_PEER_UPDATE_SOURCE
);
2798 PEER_ATTR_INHERIT(peer
, group
, local_role
);
2800 /* Update GR flags for the peer. */
2801 bgp_peer_gr_flags_update(peer
);
2803 /* Apply BFD settings from group to peer if it exists. */
2804 if (conf
->bfd_config
) {
2805 bgp_peer_configure_bfd(peer
, false);
2806 bgp_peer_config_apply(peer
, group
);
2810 /* Peer group's remote AS configuration. */
2811 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2814 struct peer_group
*group
;
2816 struct listnode
*node
, *nnode
;
2818 group
= peer_group_lookup(bgp
, group_name
);
2822 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2826 /* When we setup peer-group AS number all peer group member's AS
2827 number must be updated to same number. */
2828 peer_as_change(group
->conf
, *as
, as_type
);
2830 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2831 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2832 || (peer
->as_type
!= as_type
))
2833 peer_as_change(peer
, *as
, as_type
);
2839 void peer_notify_unconfig(struct peer
*peer
)
2841 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2842 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2843 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
2846 static void peer_notify_shutdown(struct peer
*peer
)
2848 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
2849 if (bgp_debug_neighbor_events(peer
))
2851 "%pBP configured Graceful-Restart, skipping shutdown notification",
2856 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2857 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2858 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
2861 void peer_group_notify_unconfig(struct peer_group
*group
)
2863 struct peer
*peer
, *other
;
2864 struct listnode
*node
, *nnode
;
2866 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2867 other
= peer
->doppelganger
;
2868 if (other
&& other
->status
!= Deleted
) {
2869 other
->group
= NULL
;
2870 peer_notify_unconfig(other
);
2872 peer_notify_unconfig(peer
);
2876 int peer_group_delete(struct peer_group
*group
)
2880 struct prefix
*prefix
;
2882 struct listnode
*node
, *nnode
;
2887 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2888 other
= peer
->doppelganger
;
2890 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2891 bgp_zebra_terminate_radv(bgp
, peer
);
2894 if (other
&& other
->status
!= Deleted
) {
2895 other
->group
= NULL
;
2899 list_delete(&group
->peer
);
2901 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2902 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2904 prefix_free(&prefix
);
2906 list_delete(&group
->listen_range
[afi
]);
2909 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2912 if (group
->conf
->bfd_config
)
2913 bgp_peer_remove_bfd_config(group
->conf
);
2915 group
->conf
->group
= NULL
;
2916 peer_delete(group
->conf
);
2918 /* Delete from all peer_group list. */
2919 listnode_delete(bgp
->group
, group
);
2921 peer_group_free(group
);
2926 int peer_group_remote_as_delete(struct peer_group
*group
)
2928 struct peer
*peer
, *other
;
2929 struct listnode
*node
, *nnode
;
2931 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2932 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2935 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2936 other
= peer
->doppelganger
;
2938 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2939 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
2943 if (other
&& other
->status
!= Deleted
) {
2944 other
->group
= NULL
;
2948 list_delete_all_node(group
->peer
);
2950 group
->conf
->as
= 0;
2951 group
->conf
->as_type
= AS_UNSPECIFIED
;
2956 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2958 struct prefix
*prefix
;
2959 struct listnode
*node
, *nnode
;
2962 afi
= family2afi(range
->family
);
2964 /* Group needs remote AS configured. */
2965 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2966 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2968 /* Ensure no duplicates. Currently we don't care about overlaps. */
2969 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2970 if (prefix_same(range
, prefix
))
2974 prefix
= prefix_new();
2975 prefix_copy(prefix
, range
);
2976 listnode_add(group
->listen_range
[afi
], prefix
);
2978 /* Update passwords for new ranges */
2979 if (group
->conf
->password
)
2980 bgp_md5_set_prefix(group
->bgp
, prefix
, group
->conf
->password
);
2985 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
2987 struct prefix
*prefix
, prefix2
;
2988 struct listnode
*node
, *nnode
;
2992 afi
= family2afi(range
->family
);
2994 /* Identify the listen range. */
2995 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2996 if (prefix_same(range
, prefix
))
3001 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
3003 /* Dispose off any dynamic neighbors that exist due to this listen range
3005 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
3006 if (!peer_dynamic_neighbor(peer
))
3009 if (sockunion2hostprefix(&peer
->su
, &prefix2
)
3010 && prefix_match(prefix
, &prefix2
)) {
3011 if (bgp_debug_neighbor_events(peer
))
3013 "Deleting dynamic neighbor %s group %s upon delete of listen range %pFX",
3014 peer
->host
, group
->name
, prefix
);
3019 /* Get rid of the listen range */
3020 listnode_delete(group
->listen_range
[afi
], prefix
);
3022 /* Remove passwords for deleted ranges */
3023 if (group
->conf
->password
)
3024 bgp_md5_unset_prefix(group
->bgp
, prefix
);
3029 /* Bind specified peer to peer group. */
3030 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
3031 struct peer_group
*group
, as_t
*as
)
3033 int first_member
= 0;
3036 enum bgp_peer_sort ptype
, gtype
;
3038 /* Lookup the peer. */
3040 peer
= peer_lookup(bgp
, su
);
3042 /* The peer exist, bind it to the peer-group */
3044 /* When the peer already belongs to a peer-group, check the
3046 if (peer_group_active(peer
)) {
3048 /* The peer is already bound to the peer-group,
3051 if (strcmp(peer
->group
->name
, group
->name
) == 0)
3054 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
3057 /* The peer has not specified a remote-as, inherit it from the
3059 if (peer
->as_type
== AS_UNSPECIFIED
) {
3060 peer
->as_type
= group
->conf
->as_type
;
3061 peer
->as
= group
->conf
->as
;
3062 peer
->sort
= group
->conf
->sort
;
3065 ptype
= peer_sort(peer
);
3066 if (!group
->conf
->as
&& ptype
!= BGP_PEER_UNSPECIFIED
) {
3067 gtype
= peer_sort(group
->conf
);
3068 if ((gtype
!= BGP_PEER_INTERNAL
) && (gtype
!= ptype
)) {
3071 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
3074 if (gtype
== BGP_PEER_INTERNAL
)
3078 peer_group2peer_config_copy(group
, peer
);
3080 FOREACH_AFI_SAFI (afi
, safi
) {
3081 if (group
->conf
->afc
[afi
][safi
]) {
3082 peer
->afc
[afi
][safi
] = 1;
3084 if (peer_af_find(peer
, afi
, safi
)
3085 || peer_af_create(peer
, afi
, safi
)) {
3086 peer_group2peer_config_copy_af(
3087 group
, peer
, afi
, safi
);
3089 } else if (peer
->afc
[afi
][safi
])
3090 peer_deactivate(peer
, afi
, safi
);
3094 assert(group
&& peer
->group
== group
);
3096 listnode_delete(bgp
->peer
, peer
);
3098 peer
->group
= group
;
3099 listnode_add_sort(bgp
->peer
, peer
);
3101 peer
= peer_lock(peer
); /* group->peer list reference */
3102 listnode_add(group
->peer
, peer
);
3106 gtype
= peer_sort(group
->conf
);
3107 /* Advertisement-interval reset */
3108 if (!CHECK_FLAG(group
->conf
->flags
,
3109 PEER_FLAG_ROUTEADV
)) {
3110 group
->conf
->v_routeadv
=
3111 (gtype
== BGP_PEER_IBGP
)
3112 ? BGP_DEFAULT_IBGP_ROUTEADV
3113 : BGP_DEFAULT_EBGP_ROUTEADV
;
3116 /* ebgp-multihop reset */
3117 if (gtype
== BGP_PEER_IBGP
)
3118 group
->conf
->ttl
= MAXTTL
;
3121 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3123 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3124 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
3125 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3126 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3128 bgp_session_reset(peer
);
3132 /* Create a new peer. */
3134 if ((group
->conf
->as_type
== AS_SPECIFIED
)
3135 && (!group
->conf
->as
)) {
3136 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
3139 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3140 group
->conf
->as_type
, group
, true);
3142 peer
= peer_lock(peer
); /* group->peer list reference */
3143 listnode_add(group
->peer
, peer
);
3145 peer_group2peer_config_copy(group
, peer
);
3147 /* If the peer-group is active for this afi/safi then activate
3149 FOREACH_AFI_SAFI (afi
, safi
) {
3150 if (group
->conf
->afc
[afi
][safi
]) {
3151 peer
->afc
[afi
][safi
] = 1;
3153 if (!peer_af_find(peer
, afi
, safi
))
3154 peer_af_create(peer
, afi
, safi
);
3156 peer_group2peer_config_copy_af(group
, peer
, afi
,
3158 } else if (peer
->afc
[afi
][safi
])
3159 peer_deactivate(peer
, afi
, safi
);
3162 /* Set up peer's events and timers. */
3163 if (peer_active(peer
))
3164 bgp_timer_set(peer
);
3170 static void bgp_startup_timer_expire(struct thread
*thread
)
3174 bgp
= THREAD_ARG(thread
);
3175 bgp
->t_startup
= NULL
;
3179 * On shutdown we call the cleanup function which
3180 * does a free of the link list nodes, free up
3181 * the data we are pointing at too.
3183 static void bgp_vrf_string_name_delete(void *data
)
3187 XFREE(MTYPE_TMP
, vname
);
3190 /* BGP instance creation by `router bgp' commands. */
3191 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
3192 enum bgp_instance_type inst_type
)
3198 bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
));
3200 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3201 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3202 zlog_debug("Creating Default VRF, AS %u", *as
);
3204 zlog_debug("Creating %s %s, AS %u",
3205 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
3211 /* Default the EVPN VRF to the default one */
3212 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
&& !bgp_master
.bgp_evpn
) {
3219 bgp
->allow_martian
= false;
3220 bgp_process_queue_init(bgp
);
3221 bgp
->heuristic_coalesce
= true;
3222 bgp
->inst_type
= inst_type
;
3223 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
3225 bgp
->peer_self
= peer_new(bgp
);
3226 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
3227 bgp
->peer_self
->host
=
3228 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
3229 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
3230 if (cmd_hostname_get())
3231 bgp
->peer_self
->hostname
=
3232 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
3234 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
3235 if (cmd_domainname_get())
3236 bgp
->peer_self
->domainname
=
3237 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
3238 bgp
->peer
= list_new();
3239 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
3240 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
3242 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
3244 bgp
->group
= list_new();
3245 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
3247 FOREACH_AFI_SAFI (afi
, safi
) {
3248 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3249 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3250 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
3252 /* Enable maximum-paths */
3253 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
3255 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
3257 /* Initialize graceful restart info */
3258 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
3259 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
3260 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
3261 bgp
->gr_info
[afi
][safi
].t_route_select
= NULL
;
3262 bgp
->gr_info
[afi
][safi
].gr_deferred
= 0;
3265 bgp
->v_update_delay
= bm
->v_update_delay
;
3266 bgp
->v_establish_wait
= bm
->v_establish_wait
;
3267 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
3268 bgp
->default_subgroup_pkt_queue_max
=
3269 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
3270 bgp_tcp_keepalive_unset(bgp
);
3271 bgp_timers_unset(bgp
);
3272 bgp
->default_min_holdtime
= 0;
3273 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
3274 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
3275 bgp
->select_defer_time
= BGP_DEFAULT_SELECT_DEFERRAL_TIME
;
3276 bgp
->rib_stale_time
= BGP_DEFAULT_RIB_STALE_TIME
;
3277 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
3278 bgp
->dynamic_neighbors_count
= 0;
3279 bgp
->lb_ref_bw
= BGP_LINK_BW_REF_BW
;
3280 bgp
->lb_handling
= BGP_LINK_BW_ECMP
;
3281 bgp
->reject_as_sets
= false;
3282 bgp
->condition_check_period
= DEFAULT_CONDITIONAL_ROUTES_POLL_TIME
;
3283 bgp_addpath_init_bgp_data(&bgp
->tx_addpath
);
3284 bgp
->fast_convergence
= false;
3286 bgp
->llgr_stale_time
= BGP_DEFAULT_LLGR_STALE_TIME
;
3288 #ifdef ENABLE_BGP_VNC
3289 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
3290 bgp
->rfapi
= bgp_rfapi_new(bgp
);
3292 assert(bgp
->rfapi_cfg
);
3294 #endif /* ENABLE_BGP_VNC */
3296 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3297 bgp
->vpn_policy
[afi
].bgp
= bgp
;
3298 bgp
->vpn_policy
[afi
].afi
= afi
;
3299 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
3300 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
3303 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
3304 bgp
->vpn_policy
[afi
].import_vrf
->del
=
3305 bgp_vrf_string_name_delete
;
3306 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
3307 bgp
->vpn_policy
[afi
].export_vrf
->del
=
3308 bgp_vrf_string_name_delete
;
3309 SET_FLAG(bgp
->af_flags
[afi
][SAFI_MPLS_VPN
],
3310 BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL
);
3313 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
3315 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
3316 bgp
->restart_time
, &bgp
->t_startup
);
3318 /* printable name we can use in debug messages */
3319 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3320 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3330 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3332 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3333 snprintf(bgp
->name_pretty
, len
, "%s %s",
3334 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3340 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3341 memory_order_relaxed
);
3342 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3343 memory_order_relaxed
);
3344 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3345 bgp
->default_af
[AFI_IP
][SAFI_UNICAST
] = true;
3349 update_bgp_group_init(bgp
);
3351 /* assign a unique rd id for auto derivation of vrf's RD */
3352 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3354 bgp
->evpn_info
= XCALLOC(MTYPE_BGP_EVPN_INFO
,
3355 sizeof(struct bgp_evpn_info
));
3357 bgp_evpn_vrf_es_init(bgp
);
3361 /*initilize global GR FSM */
3362 bgp_global_gr_init(bgp
);
3364 memset(&bgp
->ebgprequirespolicywarning
, 0,
3365 sizeof(bgp
->ebgprequirespolicywarning
));
3370 /* Return the "default VRF" instance of BGP. */
3371 struct bgp
*bgp_get_default(void)
3374 struct listnode
*node
, *nnode
;
3376 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3377 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3382 /* Lookup BGP entry. */
3383 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3386 struct listnode
*node
, *nnode
;
3388 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3390 && ((bgp
->name
== NULL
&& name
== NULL
)
3391 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3396 /* Lookup BGP structure by view name. */
3397 struct bgp
*bgp_lookup_by_name(const char *name
)
3400 struct listnode
*node
, *nnode
;
3402 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3403 if ((bgp
->name
== NULL
&& name
== NULL
)
3404 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3409 /* Lookup BGP instance based on VRF id. */
3410 /* Note: Only to be used for incoming messages from Zebra. */
3411 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3415 /* Lookup VRF (in tree) and follow link. */
3416 vrf
= vrf_lookup_by_id(vrf_id
);
3419 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3422 /* Sets the BGP instance where EVPN is enabled */
3423 void bgp_set_evpn(struct bgp
*bgp
)
3425 if (bm
->bgp_evpn
== bgp
)
3428 /* First, release the reference count we hold on the instance */
3430 bgp_unlock(bm
->bgp_evpn
);
3434 /* Increase the reference count on this new VRF */
3436 bgp_lock(bm
->bgp_evpn
);
3439 /* Returns the BGP instance where EVPN is enabled, if any */
3440 struct bgp
*bgp_get_evpn(void)
3442 return bm
->bgp_evpn
;
3445 /* handle socket creation or deletion, if necessary
3446 * this is called for all new BGP instances
3448 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3451 struct listnode
*node
;
3454 /* Create BGP server socket, if listen mode not disabled */
3455 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3457 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3459 * suppress vrf socket
3462 bgp_close_vrf_socket(bgp
);
3466 return BGP_ERR_INVALID_VALUE
;
3468 * if vrf_id did not change
3470 if (vrf
->vrf_id
== old_vrf_id
)
3472 if (old_vrf_id
!= VRF_UNKNOWN
) {
3473 /* look for old socket. close it. */
3474 bgp_close_vrf_socket(bgp
);
3476 /* if backend is not yet identified ( VRF_UNKNOWN) then
3477 * creation will be done later
3479 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3481 if (list_isempty(bm
->addresses
)) {
3482 if (bgp_socket(bgp
, bm
->port
, NULL
) < 0)
3483 return BGP_ERR_INVALID_VALUE
;
3485 for (ALL_LIST_ELEMENTS_RO(bm
->addresses
, node
, address
))
3486 if (bgp_socket(bgp
, bm
->port
, address
) < 0)
3487 return BGP_ERR_INVALID_VALUE
;
3491 return bgp_check_main_socket(create
, bgp
);
3494 int bgp_lookup_by_as_name_type(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3495 enum bgp_instance_type inst_type
)
3499 /* Multiple instance check. */
3501 bgp
= bgp_lookup_by_name(name
);
3503 bgp
= bgp_get_default();
3507 if (bgp
->as
!= *as
) {
3509 return BGP_ERR_AS_MISMATCH
;
3511 if (bgp
->inst_type
!= inst_type
)
3512 return BGP_ERR_INSTANCE_MISMATCH
;
3520 /* Called from VTY commands. */
3521 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3522 enum bgp_instance_type inst_type
)
3525 struct vrf
*vrf
= NULL
;
3528 ret
= bgp_lookup_by_as_name_type(bgp_val
, as
, name
, inst_type
);
3529 if (ret
|| *bgp_val
)
3532 bgp
= bgp_create(as
, name
, inst_type
);
3535 * view instances will never work inside of a vrf
3536 * as such they must always be in the VRF_DEFAULT
3537 * Also we must set this to something useful because
3538 * of the vrf socket code needing an actual useful
3539 * default value to send to the underlying OS.
3541 * This code is currently ignoring vrf based
3542 * code using the -Z option( and that is probably
3543 * best addressed elsewhere in the code )
3545 if (inst_type
== BGP_INSTANCE_TYPE_VIEW
)
3546 bgp
->vrf_id
= VRF_DEFAULT
;
3548 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
, true);
3549 bgp_address_init(bgp
);
3550 bgp_tip_hash_init(bgp
);
3554 bgp
->t_rmap_def_originate_eval
= NULL
;
3556 /* If Default instance or VRF, link to the VRF structure, if present. */
3557 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3558 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3559 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3561 bgp_vrf_link(bgp
, vrf
);
3563 /* BGP server socket already processed if BGP instance
3564 * already part of the list
3566 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3567 listnode_add(bm
->bgp
, bgp
);
3569 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3570 if (BGP_DEBUG(zebra
, ZEBRA
))
3571 zlog_debug("%s: Registering BGP instance %s to zebra",
3572 __func__
, bgp
->name_pretty
);
3573 bgp_zebra_instance_register(bgp
);
3579 static void bgp_zclient_set_redist(afi_t afi
, int type
, unsigned short instance
,
3580 vrf_id_t vrf_id
, bool set
)
3584 redist_add_instance(&zclient
->mi_redist
[afi
][type
],
3587 redist_del_instance(&zclient
->mi_redist
[afi
][type
],
3591 vrf_bitmap_set(zclient
->redist
[afi
][type
], vrf_id
);
3593 vrf_bitmap_unset(zclient
->redist
[afi
][type
], vrf_id
);
3597 static void bgp_set_redist_vrf_bitmaps(struct bgp
*bgp
, bool set
)
3601 struct list
*red_list
;
3602 struct listnode
*node
;
3603 struct bgp_redist
*red
;
3605 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3606 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
3608 red_list
= bgp
->redist
[afi
][i
];
3612 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
3613 bgp_zclient_set_redist(afi
, i
, red
->instance
,
3620 * Make BGP instance "up". Applies only to VRFs (non-default) and
3621 * implies the VRF has been learnt from Zebra.
3623 void bgp_instance_up(struct bgp
*bgp
)
3626 struct listnode
*node
, *next
;
3628 bgp_set_redist_vrf_bitmaps(bgp
, true);
3630 /* Register with zebra. */
3631 bgp_zebra_instance_register(bgp
);
3633 /* Kick off any peers that may have been configured. */
3634 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3635 if (!BGP_PEER_START_SUPPRESSED(peer
))
3636 BGP_EVENT_ADD(peer
, BGP_Start
);
3639 /* Process any networks that have been configured. */
3640 bgp_static_add(bgp
);
3644 * Make BGP instance "down". Applies only to VRFs (non-default) and
3645 * implies the VRF has been deleted by Zebra.
3647 void bgp_instance_down(struct bgp
*bgp
)
3650 struct listnode
*node
;
3651 struct listnode
*next
;
3654 if (bgp
->t_rmap_def_originate_eval
) {
3655 THREAD_OFF(bgp
->t_rmap_def_originate_eval
);
3656 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3660 /* Bring down peers, so corresponding routes are purged. */
3661 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3662 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3663 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3664 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3666 bgp_session_reset(peer
);
3669 /* Purge network and redistributed routes. */
3670 bgp_purge_static_redist_routes(bgp
);
3672 /* Cleanup registered nexthops (flags) */
3673 bgp_cleanup_nexthops(bgp
);
3675 bgp_zebra_instance_deregister(bgp
);
3677 bgp_set_redist_vrf_bitmaps(bgp
, false);
3680 /* Delete BGP instance. */
3681 int bgp_delete(struct bgp
*bgp
)
3684 struct peer_group
*group
;
3685 struct listnode
*node
, *next
;
3690 struct graceful_restart_info
*gr_info
;
3694 bgp_soft_reconfig_table_task_cancel(bgp
, NULL
, NULL
);
3696 /* make sure we withdraw any exported routes */
3697 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP
, bgp_get_default(),
3699 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN
, AFI_IP6
, bgp_get_default(),
3702 bgp_vpn_leak_unimport(bgp
);
3704 hook_call(bgp_inst_delete
, bgp
);
3706 FOREACH_AFI_SAFI (afi
, safi
)
3707 THREAD_OFF(bgp
->t_revalidate
[afi
][safi
]);
3709 THREAD_OFF(bgp
->t_condition_check
);
3710 THREAD_OFF(bgp
->t_startup
);
3711 THREAD_OFF(bgp
->t_maxmed_onstartup
);
3712 THREAD_OFF(bgp
->t_update_delay
);
3713 THREAD_OFF(bgp
->t_establish_wait
);
3715 /* Set flag indicating bgp instance delete in progress */
3716 SET_FLAG(bgp
->flags
, BGP_FLAG_DELETE_IN_PROGRESS
);
3718 /* Delete the graceful restart info */
3719 FOREACH_AFI_SAFI (afi
, safi
) {
3722 gr_info
= &bgp
->gr_info
[afi
][safi
];
3725 t
= gr_info
->t_select_deferral
;
3727 void *info
= THREAD_ARG(t
);
3729 XFREE(MTYPE_TMP
, info
);
3731 THREAD_OFF(gr_info
->t_select_deferral
);
3733 t
= gr_info
->t_route_select
;
3735 void *info
= THREAD_ARG(t
);
3737 XFREE(MTYPE_TMP
, info
);
3739 THREAD_OFF(gr_info
->t_route_select
);
3742 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3743 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3744 zlog_debug("Deleting Default VRF");
3746 zlog_debug("Deleting %s %s",
3747 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3753 /* unmap from RT list */
3754 bgp_evpn_vrf_delete(bgp
);
3756 /* unmap bgp vrf label */
3757 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP
);
3758 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP6
);
3761 if (bgp
->t_rmap_def_originate_eval
) {
3762 THREAD_OFF(bgp
->t_rmap_def_originate_eval
);
3763 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3767 /* Inform peers we're going down. */
3768 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3769 peer_notify_shutdown(peer
);
3771 /* Delete static routes (networks). */
3772 bgp_static_delete(bgp
);
3774 /* Unset redistribution. */
3775 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3776 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3777 if (i
!= ZEBRA_ROUTE_BGP
)
3778 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3780 /* Free peers and peer-groups. */
3781 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3782 peer_group_delete(group
);
3784 while (listcount(bgp
->peer
)) {
3785 peer
= listnode_head(bgp
->peer
);
3789 if (bgp
->peer_self
) {
3790 peer_delete(bgp
->peer_self
);
3791 bgp
->peer_self
= NULL
;
3794 update_bgp_group_free(bgp
);
3796 /* TODO - Other memory may need to be freed - e.g., NHT */
3798 #ifdef ENABLE_BGP_VNC
3801 bgp_cleanup_routes(bgp
);
3803 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3804 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3807 &bgp
->vpn_policy
[afi
]
3808 .import_redirect_rtlist
);
3809 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3812 /* Free any memory allocated to holding routemap references */
3813 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3814 for (enum vpn_policy_direction dir
= 0;
3815 dir
< BGP_VPN_POLICY_DIR_MAX
; ++dir
) {
3816 if (bgp
->vpn_policy
[afi
].rmap_name
[dir
])
3817 XFREE(MTYPE_ROUTE_MAP_NAME
,
3818 bgp
->vpn_policy
[afi
].rmap_name
[dir
]);
3819 bgp
->vpn_policy
[afi
].rmap
[dir
] = NULL
;
3823 /* Deregister from Zebra, if needed */
3824 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3825 if (BGP_DEBUG(zebra
, ZEBRA
))
3827 "%s: deregistering this bgp %s instance from zebra",
3828 __func__
, bgp
->name
);
3829 bgp_zebra_instance_deregister(bgp
);
3832 /* Remove visibility via the master list - there may however still be
3833 * routes to be processed still referencing the struct bgp.
3835 listnode_delete(bm
->bgp
, bgp
);
3837 /* Free interfaces in this instance. */
3840 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3841 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3843 bgp_vrf_unlink(bgp
, vrf
);
3845 /* Update EVPN VRF pointer */
3846 if (bm
->bgp_evpn
== bgp
) {
3847 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3850 bgp_set_evpn(bgp_get_default());
3853 if (bgp
->process_queue
)
3854 work_queue_free_and_null(&bgp
->process_queue
);
3856 thread_master_free_unused(bm
->master
);
3857 bgp_unlock(bgp
); /* initial reference */
3862 void bgp_free(struct bgp
*bgp
)
3866 struct bgp_table
*table
;
3867 struct bgp_dest
*dest
;
3868 struct bgp_rmap
*rmap
;
3872 list_delete(&bgp
->group
);
3873 list_delete(&bgp
->peer
);
3875 if (bgp
->peerhash
) {
3876 hash_free(bgp
->peerhash
);
3877 bgp
->peerhash
= NULL
;
3880 FOREACH_AFI_SAFI (afi
, safi
) {
3881 /* Special handling for 2-level routing tables. */
3882 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3883 || safi
== SAFI_EVPN
) {
3884 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
3885 dest
= bgp_route_next(dest
)) {
3886 table
= bgp_dest_get_bgp_table_info(dest
);
3887 bgp_table_finish(&table
);
3890 if (bgp
->route
[afi
][safi
])
3891 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3892 if (bgp
->aggregate
[afi
][safi
])
3893 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3894 if (bgp
->rib
[afi
][safi
])
3895 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3896 rmap
= &bgp
->table_map
[afi
][safi
];
3897 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3900 bgp_scan_finish(bgp
);
3901 bgp_address_destroy(bgp
);
3902 bgp_tip_hash_destroy(bgp
);
3904 /* release the auto RD id */
3905 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3907 bgp_evpn_cleanup(bgp
);
3908 bgp_pbr_cleanup(bgp
);
3909 bgp_srv6_cleanup(bgp
);
3910 XFREE(MTYPE_BGP_EVPN_INFO
, bgp
->evpn_info
);
3912 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3913 enum vpn_policy_direction dir
;
3915 if (bgp
->vpn_policy
[afi
].import_vrf
)
3916 list_delete(&bgp
->vpn_policy
[afi
].import_vrf
);
3917 if (bgp
->vpn_policy
[afi
].export_vrf
)
3918 list_delete(&bgp
->vpn_policy
[afi
].export_vrf
);
3920 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3921 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3922 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3923 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3924 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3925 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3928 XFREE(MTYPE_BGP
, bgp
->name
);
3929 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3930 XFREE(MTYPE_BGP
, bgp
->snmp_stats
);
3932 XFREE(MTYPE_BGP
, bgp
);
3935 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3938 struct listnode
*node
, *nnode
;
3944 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3945 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3946 && !CHECK_FLAG(peer
->sflags
,
3947 PEER_STATUS_ACCEPT_PEER
))
3949 } else if (bm
->bgp
!= NULL
) {
3950 struct listnode
*bgpnode
, *nbgpnode
;
3952 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3953 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3955 && !strcmp(peer
->conf_if
, conf_if
)
3956 && !CHECK_FLAG(peer
->sflags
,
3957 PEER_STATUS_ACCEPT_PEER
))
3963 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
3966 struct listnode
*node
, *nnode
;
3972 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3973 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3974 && !CHECK_FLAG(peer
->sflags
,
3975 PEER_STATUS_ACCEPT_PEER
))
3977 } else if (bm
->bgp
!= NULL
) {
3978 struct listnode
*bgpnode
, *nbgpnode
;
3980 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3981 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3983 && !strcmp(peer
->hostname
, hostname
)
3984 && !CHECK_FLAG(peer
->sflags
,
3985 PEER_STATUS_ACCEPT_PEER
))
3991 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
3993 struct peer
*peer
= NULL
;
3994 struct peer tmp_peer
;
3996 memset(&tmp_peer
, 0, sizeof(struct peer
));
3999 * We do not want to find the doppelganger peer so search for the peer
4001 * the hash that has PEER_FLAG_CONFIG_NODE
4003 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
4008 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4009 } else if (bm
->bgp
!= NULL
) {
4010 struct listnode
*bgpnode
, *nbgpnode
;
4012 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
4013 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
4022 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
4023 union sockunion
*su
,
4024 struct peer_group
*group
)
4030 /* Create peer first; we've already checked group config is valid. */
4031 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
4032 group
->conf
->as_type
, group
, true);
4037 peer
= peer_lock(peer
);
4038 listnode_add(group
->peer
, peer
);
4040 peer_group2peer_config_copy(group
, peer
);
4043 * Bind peer for all AFs configured for the group. We don't call
4044 * peer_group_bind as that is sub-optimal and does some stuff we don't
4047 FOREACH_AFI_SAFI (afi
, safi
) {
4048 if (!group
->conf
->afc
[afi
][safi
])
4050 peer
->afc
[afi
][safi
] = 1;
4052 if (!peer_af_find(peer
, afi
, safi
))
4053 peer_af_create(peer
, afi
, safi
);
4055 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
4058 /* Mark as dynamic, but also as a "config node" for other things to
4060 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
4066 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
4067 struct prefix
*prefix
)
4069 struct listnode
*node
, *nnode
;
4070 struct prefix
*range
;
4073 afi
= family2afi(prefix
->family
);
4075 if (group
->listen_range
[afi
])
4076 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
4078 if (prefix_match(range
, prefix
))
4085 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
4086 struct prefix
**listen_range
)
4088 struct prefix
*range
= NULL
;
4089 struct peer_group
*group
= NULL
;
4090 struct listnode
*node
, *nnode
;
4092 *listen_range
= NULL
;
4094 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4095 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4098 } else if (bm
->bgp
!= NULL
) {
4099 struct listnode
*bgpnode
, *nbgpnode
;
4101 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
4102 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
4103 if ((range
= peer_group_lookup_dynamic_neighbor_range(
4109 *listen_range
= range
;
4110 return (group
&& range
) ? group
: NULL
;
4113 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
4115 struct peer_group
*group
;
4118 struct prefix prefix
;
4119 struct prefix
*listen_range
;
4122 if (!sockunion2hostprefix(su
, &prefix
))
4125 /* See if incoming connection matches a configured listen range. */
4126 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
4137 if (bgp_debug_neighbor_events(NULL
))
4139 "Dynamic Neighbor %pFX matches group %s listen range %pFX",
4140 &prefix
, group
->name
, listen_range
);
4142 /* Are we within the listen limit? */
4143 dncount
= gbgp
->dynamic_neighbors_count
;
4145 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
4146 if (bgp_debug_neighbor_events(NULL
))
4148 "Dynamic Neighbor %pFX rejected - at limit %d",
4149 &prefix
, gbgp
->dynamic_neighbors_limit
);
4153 /* Ensure group is not disabled. */
4154 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
4155 if (bgp_debug_neighbor_events(NULL
))
4157 "Dynamic Neighbor %pFX rejected - group %s disabled",
4158 &prefix
, group
->name
);
4162 /* Check that at least one AF is activated for the group. */
4163 if (!peer_group_af_configured(group
)) {
4164 if (bgp_debug_neighbor_events(NULL
))
4166 "Dynamic Neighbor %pFX rejected - no AF activated for group %s",
4167 &prefix
, group
->name
);
4171 /* Create dynamic peer and bind to associated group. */
4172 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
4175 gbgp
->dynamic_neighbors_count
= ++dncount
;
4177 if (bgp_debug_neighbor_events(peer
))
4178 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
4179 peer
->host
, group
->name
, dncount
);
4184 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
4187 if (peer
->group
->bgp
) {
4188 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
4190 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
4192 if (bgp_debug_neighbor_events(peer
))
4193 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
4194 peer
->group
->name
, dncount
);
4197 bool bgp_path_attribute_discard(struct peer
*peer
, char *buf
, size_t size
)
4204 for (unsigned int i
= 0; i
< BGP_ATTR_MAX
; i
++) {
4205 if (peer
->discard_attrs
[i
])
4206 snprintf(buf
+ strlen(buf
), size
- strlen(buf
), "%s%d",
4207 (strlen(buf
) > 0) ? " " : "", i
);
4210 if (strlen(buf
) > 0)
4216 /* If peer is configured at least one address family return 1. */
4217 bool peer_active(struct peer
*peer
)
4219 if (BGP_PEER_SU_UNSPEC(peer
))
4221 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
4222 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
4223 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
4224 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
4225 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
4226 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
4227 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4228 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
4229 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
4230 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
4231 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
4236 /* If peer is negotiated at least one address family return 1. */
4237 bool peer_active_nego(struct peer
*peer
)
4239 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
4240 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
4241 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
4242 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
4243 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
4244 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
4245 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
4246 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
4247 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
4248 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
4249 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
4250 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
4251 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
4256 /* If peer received at least one address family MP, return true */
4257 bool peer_afc_received(struct peer
*peer
)
4262 FOREACH_AFI_SAFI (afi
, safi
)
4263 if (peer
->afc_recv
[afi
][safi
])
4269 /* If peer advertised at least one address family MP, return true */
4270 bool peer_afc_advertised(struct peer
*peer
)
4275 FOREACH_AFI_SAFI (afi
, safi
)
4276 if (peer
->afc_adv
[afi
][safi
])
4282 void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
4283 enum peer_change_type type
)
4285 struct peer_af
*paf
;
4287 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4290 if (!peer_established(peer
))
4293 if (type
== peer_change_reset
) {
4294 /* If we're resetting session, we've to delete both peer struct
4296 if ((peer
->doppelganger
)
4297 && (peer
->doppelganger
->status
!= Deleted
)
4298 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4299 PEER_FLAG_CONFIG_NODE
)))
4300 peer_delete(peer
->doppelganger
);
4302 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4303 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4304 } else if (type
== peer_change_reset_in
) {
4305 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4306 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4307 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0,
4308 BGP_ROUTE_REFRESH_NORMAL
);
4310 if ((peer
->doppelganger
)
4311 && (peer
->doppelganger
->status
!= Deleted
)
4312 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
4313 PEER_FLAG_CONFIG_NODE
)))
4314 peer_delete(peer
->doppelganger
);
4316 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4317 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4319 } else if (type
== peer_change_reset_out
) {
4320 paf
= peer_af_find(peer
, afi
, safi
);
4321 if (paf
&& paf
->subgroup
)
4322 SET_FLAG(paf
->subgroup
->sflags
,
4323 SUBGRP_STATUS_FORCE_UPDATES
);
4325 update_group_adjust_peer(paf
);
4326 bgp_announce_route(peer
, afi
, safi
, false);
4330 struct peer_flag_action
{
4334 /* This flag can be set for peer-group member. */
4335 uint8_t not_for_member
;
4337 /* Action when the flag is changed. */
4338 enum peer_change_type type
;
4341 static const struct peer_flag_action peer_flag_action_list
[] = {
4342 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
4343 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
4344 {PEER_FLAG_RTT_SHUTDOWN
, 0, peer_change_none
},
4345 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
4346 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
4347 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
4348 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
4349 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
4350 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
4351 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
4352 {PEER_FLAG_IFPEER_V6ONLY
, 0, peer_change_reset
},
4353 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
4354 {PEER_FLAG_TIMER
, 0, peer_change_none
},
4355 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
4356 {PEER_FLAG_TIMER_DELAYOPEN
, 0, peer_change_none
},
4357 {PEER_FLAG_PASSWORD
, 0, peer_change_none
},
4358 {PEER_FLAG_LOCAL_AS
, 0, peer_change_reset
},
4359 {PEER_FLAG_LOCAL_AS_NO_PREPEND
, 0, peer_change_reset
},
4360 {PEER_FLAG_LOCAL_AS_REPLACE_AS
, 0, peer_change_reset
},
4361 {PEER_FLAG_UPDATE_SOURCE
, 0, peer_change_none
},
4362 {PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
, 0, peer_change_none
},
4363 {PEER_FLAG_EXTENDED_OPT_PARAMS
, 0, peer_change_reset
},
4364 {PEER_FLAG_ROLE_STRICT_MODE
, 0, peer_change_reset
},
4365 {PEER_FLAG_ROLE
, 0, peer_change_reset
},
4366 {PEER_FLAG_PORT
, 0, peer_change_reset
},
4367 {PEER_FLAG_AIGP
, 0, peer_change_none
},
4368 {PEER_FLAG_GRACEFUL_SHUTDOWN
, 0, peer_change_none
},
4371 static const struct peer_flag_action peer_af_flag_action_list
[] = {
4372 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
4373 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
4374 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
4375 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4376 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
4377 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
4378 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
4379 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
4380 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
4381 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
4382 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
4383 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
4384 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
4385 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
4386 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
4387 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
4388 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
4389 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
4390 {PEER_FLAG_MAX_PREFIX_FORCE
, 0, peer_change_none
},
4391 {PEER_FLAG_MAX_PREFIX_OUT
, 0, peer_change_none
},
4392 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
4393 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
4394 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
4395 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
4396 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
4397 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
4398 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
4399 {PEER_FLAG_DISABLE_ADDPATH_RX
, 0, peer_change_reset
},
4400 {PEER_FLAG_SOO
, 0, peer_change_reset
},
4401 {PEER_FLAG_ACCEPT_OWN
, 0, peer_change_reset
},
4404 /* Proper action set. */
4405 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
4406 int size
, struct peer_flag_action
*action
,
4413 const struct peer_flag_action
*match
= NULL
;
4415 /* Check peer's frag action. */
4416 for (i
= 0; i
< size
; i
++) {
4417 match
= &action_list
[i
];
4419 if (match
->flag
== 0)
4422 if (match
->flag
& flag
) {
4425 if (match
->type
== peer_change_reset_in
)
4427 if (match
->type
== peer_change_reset_out
)
4429 if (match
->type
== peer_change_reset
) {
4433 if (match
->not_for_member
)
4434 action
->not_for_member
= 1;
4438 /* Set peer clear type. */
4439 if (reset_in
&& reset_out
)
4440 action
->type
= peer_change_reset
;
4442 action
->type
= peer_change_reset_in
;
4444 action
->type
= peer_change_reset_out
;
4446 action
->type
= peer_change_none
;
4451 static void peer_flag_modify_action(struct peer
*peer
, uint32_t flag
)
4453 if (flag
== PEER_FLAG_SHUTDOWN
) {
4454 if (CHECK_FLAG(peer
->flags
, flag
)) {
4455 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
4456 peer_nsf_stop(peer
);
4458 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
4460 if (peer
->t_pmax_restart
) {
4461 THREAD_OFF(peer
->t_pmax_restart
);
4462 if (bgp_debug_neighbor_events(peer
))
4464 "%pBP Maximum-prefix restart timer canceled",
4468 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4469 char *msg
= peer
->tx_shutdown_message
;
4471 uint8_t msgbuf
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4473 if (!msg
&& peer_group_active(peer
))
4474 msg
= peer
->group
->conf
4475 ->tx_shutdown_message
;
4476 msglen
= msg
? strlen(msg
) : 0;
4477 if (msglen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4478 msglen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4482 memcpy(msgbuf
+ 1, msg
, msglen
);
4484 bgp_notify_send_with_data(
4485 peer
, BGP_NOTIFY_CEASE
,
4486 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
4487 msgbuf
, msglen
+ 1);
4490 peer
, BGP_NOTIFY_CEASE
,
4491 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4493 bgp_session_reset(peer
);
4495 peer
->v_start
= BGP_INIT_START_TIMER
;
4496 BGP_EVENT_ADD(peer
, BGP_Stop
);
4498 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4499 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
4500 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4501 else if (flag
== PEER_FLAG_PASSIVE
)
4502 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
4503 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
4504 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
4506 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4507 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4509 bgp_session_reset(peer
);
4512 /* Enable global administrative shutdown of all peers of BGP instance */
4513 void bgp_shutdown_enable(struct bgp
*bgp
, const char *msg
)
4516 struct listnode
*node
;
4517 /* length(1) + message(N) */
4518 uint8_t data
[BGP_ADMIN_SHUTDOWN_MSG_LEN
+ 1];
4520 /* do nothing if already shut down */
4521 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4524 /* informational log message */
4525 zlog_info("Enabled administrative shutdown on BGP instance AS %u",
4528 /* iterate through peers of BGP instance */
4529 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
4530 /* continue, if peer is already in administrative shutdown. */
4531 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
))
4534 /* send a RFC 4486 notification message if necessary */
4535 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4537 size_t datalen
= strlen(msg
);
4539 if (datalen
> BGP_ADMIN_SHUTDOWN_MSG_LEN
)
4540 datalen
= BGP_ADMIN_SHUTDOWN_MSG_LEN
;
4543 memcpy(data
+ 1, msg
, datalen
);
4545 bgp_notify_send_with_data(
4546 peer
, BGP_NOTIFY_CEASE
,
4547 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
, data
,
4551 peer
, BGP_NOTIFY_CEASE
,
4552 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4556 /* reset start timer to initial value */
4557 peer
->v_start
= BGP_INIT_START_TIMER
;
4559 /* trigger a RFC 4271 ManualStop event */
4560 BGP_EVENT_ADD(peer
, BGP_Stop
);
4563 /* set the BGP instances shutdown flag */
4564 SET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4567 /* Disable global administrative shutdown of all peers of BGP instance */
4568 void bgp_shutdown_disable(struct bgp
*bgp
)
4570 /* do nothing if not shut down. */
4571 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4574 /* informational log message */
4575 zlog_info("Disabled administrative shutdown on BGP instance AS %u",
4578 /* clear the BGP instances shutdown flag */
4579 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4582 /* Change specified peer flag. */
4583 static int peer_flag_modify(struct peer
*peer
, uint64_t flag
, int set
)
4587 bool invert
, member_invert
;
4588 struct peer
*member
;
4589 struct listnode
*node
, *nnode
;
4590 struct peer_flag_action action
;
4592 memset(&action
, 0, sizeof(struct peer_flag_action
));
4593 size
= sizeof(peer_flag_action_list
) / sizeof(struct peer_flag_action
);
4595 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4596 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4599 /* Abort if no flag action exists. */
4601 return BGP_ERR_INVALID_FLAG
;
4603 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4604 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4605 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4606 return BGP_ERR_PEER_FLAG_CONFLICT
;
4608 /* Handle flag updates where desired state matches current state. */
4609 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4610 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4611 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4615 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4616 COND_FLAG(peer
->flags_override
, flag
, invert
);
4621 /* Inherit from peer-group or set/unset flags accordingly. */
4622 if (peer_group_active(peer
) && set
== invert
)
4623 peer_flag_inherit(peer
, flag
);
4625 COND_FLAG(peer
->flags
, flag
, set
);
4627 /* Check if handling a regular peer. */
4628 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4629 /* Update flag override state accordingly. */
4630 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4633 * For the extended next-hop encoding flag we need to turn RAs
4634 * on if flag is being set, but only turn RAs off if the flag
4635 * is being unset on this peer and if this peer is a member of a
4636 * peer-group, the peer-group also doesn't have the flag set.
4638 if (flag
== PEER_FLAG_CAPABILITY_ENHE
) {
4640 bgp_zebra_initiate_radv(peer
->bgp
, peer
);
4641 } else if (peer_group_active(peer
)) {
4642 if (!CHECK_FLAG(peer
->group
->conf
->flags
,
4645 bgp_zebra_terminate_radv(peer
->bgp
,
4648 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
4651 /* Execute flag action on peer. */
4652 if (action
.type
== peer_change_reset
)
4653 peer_flag_modify_action(peer
, flag
);
4655 /* Skip peer-group mechanics for regular peers. */
4660 * Update peer-group members, unless they are explicitly overriding
4661 * peer-group configuration.
4663 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4664 /* Skip peers with overridden configuration. */
4665 if (CHECK_FLAG(member
->flags_override
, flag
))
4668 /* Check if only member without group is inverted. */
4670 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4672 /* Skip peers with equivalent configuration. */
4673 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4676 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4679 /* Update flag on peer-group member. */
4680 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4682 if (flag
== PEER_FLAG_CAPABILITY_ENHE
&& !member
->conf_if
)
4683 set
? bgp_zebra_initiate_radv(member
->bgp
, member
)
4684 : bgp_zebra_terminate_radv(member
->bgp
, member
);
4686 /* Execute flag action on peer-group member. */
4687 if (action
.type
== peer_change_reset
)
4688 peer_flag_modify_action(member
, flag
);
4694 int peer_flag_set(struct peer
*peer
, uint64_t flag
)
4696 return peer_flag_modify(peer
, flag
, 1);
4699 int peer_flag_unset(struct peer
*peer
, uint64_t flag
)
4701 return peer_flag_modify(peer
, flag
, 0);
4704 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4705 uint64_t flag
, bool set
)
4709 bool invert
, member_invert
;
4710 struct peer
*member
;
4711 struct listnode
*node
, *nnode
;
4712 struct peer_flag_action action
;
4713 enum bgp_peer_sort ptype
;
4715 memset(&action
, 0, sizeof(struct peer_flag_action
));
4716 size
= sizeof(peer_af_flag_action_list
)
4717 / sizeof(struct peer_flag_action
);
4719 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4720 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4723 /* Abort if flag action exists. */
4725 return BGP_ERR_INVALID_FLAG
;
4727 ptype
= peer_sort(peer
);
4728 /* Special check for reflector client. */
4729 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
&& ptype
!= BGP_PEER_IBGP
)
4730 return BGP_ERR_NOT_INTERNAL_PEER
;
4732 /* Special check for remove-private-AS. */
4733 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
&& ptype
== BGP_PEER_IBGP
)
4734 return BGP_ERR_REMOVE_PRIVATE_AS
;
4736 /* as-override is not allowed for IBGP peers */
4737 if (flag
& PEER_FLAG_AS_OVERRIDE
&& ptype
== BGP_PEER_IBGP
)
4738 return BGP_ERR_AS_OVERRIDE
;
4740 /* Handle flag updates where desired state matches current state. */
4741 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4742 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4743 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4748 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4749 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4756 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4757 * if we are setting/unsetting flags which conflict with this flag
4758 * handle accordingly
4760 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4764 * if we are setting NEXTHOP_SELF, we need to unset the
4765 * NEXTHOP_UNCHANGED flag
4767 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4768 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4769 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4770 PEER_FLAG_NEXTHOP_UNCHANGED
);
4774 * if we are unsetting NEXTHOP_SELF, we need to set the
4775 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4777 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4778 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4779 SET_FLAG(peer
->af_flags
[afi
][safi
],
4780 PEER_FLAG_NEXTHOP_UNCHANGED
);
4785 * If the peer is a route server client let's not
4786 * muck with the nexthop on the way out the door
4788 if (flag
& PEER_FLAG_RSERVER_CLIENT
) {
4790 SET_FLAG(peer
->af_flags
[afi
][safi
],
4791 PEER_FLAG_NEXTHOP_UNCHANGED
);
4793 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4794 PEER_FLAG_NEXTHOP_UNCHANGED
);
4797 /* Inherit from peer-group or set/unset flags accordingly. */
4798 if (peer_group_active(peer
) && set
== invert
)
4799 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4801 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4803 /* Execute action when peer is established. */
4804 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4805 && peer_established(peer
)) {
4806 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4807 bgp_clear_adj_in(peer
, afi
, safi
);
4809 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4810 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4811 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4812 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4813 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4814 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4815 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4816 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4818 peer_change_action(peer
, afi
, safi
, action
.type
);
4822 /* Check if handling a regular peer. */
4823 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4824 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4828 * Update peer-group members, unless they are explicitly
4829 * overriding peer-group configuration.
4831 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4833 /* Skip peers with overridden configuration. */
4834 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4838 /* Check if only member without group is inverted. */
4840 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4844 /* Skip peers with equivalent configuration. */
4845 if (set
!= member_invert
4846 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4849 if (set
== member_invert
4850 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4853 /* Update flag on peer-group member. */
4854 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4855 set
!= member_invert
);
4857 /* Execute flag action on peer-group member. */
4858 if (peer_established(member
)) {
4859 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4860 bgp_clear_adj_in(member
, afi
, safi
);
4862 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4863 member
->last_reset
=
4864 PEER_DOWN_RR_CLIENT_CHANGE
;
4866 == PEER_FLAG_RSERVER_CLIENT
)
4867 member
->last_reset
=
4868 PEER_DOWN_RS_CLIENT_CHANGE
;
4870 == PEER_FLAG_ORF_PREFIX_SM
)
4871 member
->last_reset
=
4872 PEER_DOWN_CAPABILITY_CHANGE
;
4874 == PEER_FLAG_ORF_PREFIX_RM
)
4875 member
->last_reset
=
4876 PEER_DOWN_CAPABILITY_CHANGE
;
4878 peer_change_action(member
, afi
, safi
,
4888 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4890 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4893 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint64_t flag
)
4895 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4899 void peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4901 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4902 peer
->tx_shutdown_message
=
4903 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4906 void peer_tx_shutdown_message_unset(struct peer
*peer
)
4908 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4912 /* EBGP multihop configuration. */
4913 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4915 struct peer_group
*group
;
4916 struct listnode
*node
, *nnode
;
4919 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4922 /* is there anything to do? */
4923 if (peer
->ttl
== ttl
)
4926 /* see comment in peer_ttl_security_hops_set() */
4927 if (ttl
!= MAXTTL
) {
4928 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4929 group
= peer
->group
;
4930 if (group
->conf
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4931 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4933 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4935 if (peer1
->sort
== BGP_PEER_IBGP
)
4938 if (peer1
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4939 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4942 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4943 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4949 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4950 if (peer
->sort
!= BGP_PEER_IBGP
) {
4951 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4952 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4953 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4955 bgp_session_reset(peer
);
4957 /* Reconfigure BFD peer with new TTL. */
4958 if (peer
->bfd_config
)
4959 bgp_peer_bfd_update_source(peer
);
4962 group
= peer
->group
;
4963 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4964 if (peer
->sort
== BGP_PEER_IBGP
)
4967 peer
->ttl
= group
->conf
->ttl
;
4969 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4970 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4971 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4973 bgp_session_reset(peer
);
4975 /* Reconfigure BFD peer with new TTL. */
4976 if (peer
->bfd_config
)
4977 bgp_peer_bfd_update_source(peer
);
4983 int peer_ebgp_multihop_unset(struct peer
*peer
)
4985 struct peer_group
*group
;
4986 struct listnode
*node
, *nnode
;
4989 if (peer
->sort
== BGP_PEER_IBGP
)
4992 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
&& peer
->ttl
!= MAXTTL
)
4993 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4995 if (peer_group_active(peer
))
4996 ttl
= peer
->group
->conf
->ttl
;
4998 ttl
= BGP_DEFAULT_TTL
;
5000 if (ttl
== peer
->ttl
)
5005 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5006 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5007 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5008 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5010 bgp_session_reset(peer
);
5012 /* Reconfigure BFD peer with new TTL. */
5013 if (peer
->bfd_config
)
5014 bgp_peer_bfd_update_source(peer
);
5016 group
= peer
->group
;
5017 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5018 if (peer
->sort
== BGP_PEER_IBGP
)
5021 peer
->ttl
= BGP_DEFAULT_TTL
;
5023 if (peer
->fd
>= 0) {
5024 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5026 peer
, BGP_NOTIFY_CEASE
,
5027 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5029 bgp_session_reset(peer
);
5032 /* Reconfigure BFD peer with new TTL. */
5033 if (peer
->bfd_config
)
5034 bgp_peer_bfd_update_source(peer
);
5040 /* Set Open Policy Role and check its correctness */
5041 int peer_role_set(struct peer
*peer
, uint8_t role
, bool strict_mode
)
5043 struct peer
*member
;
5044 struct listnode
*node
, *nnode
;
5046 peer_flag_set(peer
, PEER_FLAG_ROLE
);
5048 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5049 if (peer
->sort
!= BGP_PEER_EBGP
)
5050 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5052 if (peer
->local_role
== role
) {
5053 if (CHECK_FLAG(peer
->flags
,
5054 PEER_FLAG_ROLE_STRICT_MODE
) &&
5056 /* TODO: Is session restart needed if it was
5059 UNSET_FLAG(peer
->flags
,
5060 PEER_FLAG_ROLE_STRICT_MODE
);
5061 if (!CHECK_FLAG(peer
->flags
,
5062 PEER_FLAG_ROLE_STRICT_MODE
) &&
5064 SET_FLAG(peer
->flags
,
5065 PEER_FLAG_ROLE_STRICT_MODE
);
5066 /* Restart session to throw Role Mismatch
5069 if (peer
->remote_role
== ROLE_UNDEFINED
)
5070 bgp_session_reset(peer
);
5073 peer
->local_role
= role
;
5075 SET_FLAG(peer
->flags
,
5076 PEER_FLAG_ROLE_STRICT_MODE
);
5078 UNSET_FLAG(peer
->flags
,
5079 PEER_FLAG_ROLE_STRICT_MODE
);
5080 bgp_session_reset(peer
);
5086 peer
->local_role
= role
;
5087 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5088 if (member
->sort
!= BGP_PEER_EBGP
)
5089 return BGP_ERR_INVALID_INTERNAL_ROLE
;
5091 if (member
->local_role
== role
) {
5092 if (CHECK_FLAG(member
->flags
,
5093 PEER_FLAG_ROLE_STRICT_MODE
) &&
5095 /* TODO: Is session restart needed if it was
5098 UNSET_FLAG(member
->flags
,
5099 PEER_FLAG_ROLE_STRICT_MODE
);
5100 if (!CHECK_FLAG(member
->flags
,
5101 PEER_FLAG_ROLE_STRICT_MODE
) &&
5103 SET_FLAG(peer
->flags
,
5104 PEER_FLAG_ROLE_STRICT_MODE
);
5105 SET_FLAG(member
->flags
,
5106 PEER_FLAG_ROLE_STRICT_MODE
);
5107 /* Restart session to throw Role Mismatch
5110 if (member
->remote_role
== ROLE_UNDEFINED
)
5111 bgp_session_reset(member
);
5114 member
->local_role
= role
;
5117 SET_FLAG(peer
->flags
,
5118 PEER_FLAG_ROLE_STRICT_MODE
);
5119 SET_FLAG(member
->flags
,
5120 PEER_FLAG_ROLE_STRICT_MODE
);
5122 UNSET_FLAG(member
->flags
,
5123 PEER_FLAG_ROLE_STRICT_MODE
);
5125 bgp_session_reset(member
);
5132 int peer_role_unset(struct peer
*peer
)
5134 struct peer
*member
;
5135 struct listnode
*node
, *nnode
;
5137 peer_flag_unset(peer
, PEER_FLAG_ROLE
);
5139 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5140 return peer_role_set(peer
, ROLE_UNDEFINED
, 0);
5142 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
))
5143 peer_role_set(member
, ROLE_UNDEFINED
, 0);
5148 /* Neighbor description. */
5149 void peer_description_set(struct peer
*peer
, const char *desc
)
5151 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5153 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
5156 void peer_description_unset(struct peer
*peer
)
5158 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
5161 /* Neighbor update-source. */
5162 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
5164 struct peer
*member
;
5165 struct listnode
*node
, *nnode
;
5167 /* Set flag and configuration on peer. */
5168 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5169 if (peer
->update_if
) {
5170 if (strcmp(peer
->update_if
, ifname
) == 0)
5172 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5174 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5175 sockunion_free(peer
->update_source
);
5176 peer
->update_source
= NULL
;
5178 /* Check if handling a regular peer. */
5179 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5180 /* Send notification or reset peer depending on state. */
5181 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5182 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5183 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5184 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5186 bgp_session_reset(peer
);
5188 /* Apply new source configuration to BFD session. */
5189 if (peer
->bfd_config
)
5190 bgp_peer_bfd_update_source(peer
);
5192 /* Skip peer-group mechanics for regular peers. */
5197 * Set flag and configuration on all peer-group members, unless they are
5198 * explicitly overriding peer-group configuration.
5200 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5201 /* Skip peers with overridden configuration. */
5202 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5205 /* Skip peers with the same configuration. */
5206 if (member
->update_if
) {
5207 if (strcmp(member
->update_if
, ifname
) == 0)
5209 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5212 /* Set flag and configuration on peer-group member. */
5213 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5214 member
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
5215 sockunion_free(member
->update_source
);
5216 member
->update_source
= NULL
;
5218 /* Send notification or reset peer depending on state. */
5219 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5220 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5221 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5222 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5224 bgp_session_reset(member
);
5226 /* Apply new source configuration to BFD session. */
5227 if (member
->bfd_config
)
5228 bgp_peer_bfd_update_source(member
);
5234 void peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
5236 struct peer
*member
;
5237 struct listnode
*node
, *nnode
;
5239 /* Set flag and configuration on peer. */
5240 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
5241 if (peer
->update_source
) {
5242 if (sockunion_cmp(peer
->update_source
, su
) == 0)
5244 sockunion_free(peer
->update_source
);
5246 peer
->update_source
= sockunion_dup(su
);
5247 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5249 /* Check if handling a regular peer. */
5250 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5251 /* Send notification or reset peer depending on state. */
5252 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5253 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5254 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5255 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5257 bgp_session_reset(peer
);
5259 /* Apply new source configuration to BFD session. */
5260 if (peer
->bfd_config
)
5261 bgp_peer_bfd_update_source(peer
);
5263 /* Skip peer-group mechanics for regular peers. */
5268 * Set flag and configuration on all peer-group members, unless they are
5269 * explicitly overriding peer-group configuration.
5271 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5272 /* Skip peers with overridden configuration. */
5273 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5276 /* Skip peers with the same configuration. */
5277 if (member
->update_source
) {
5278 if (sockunion_cmp(member
->update_source
, su
) == 0)
5280 sockunion_free(member
->update_source
);
5283 /* Set flag and configuration on peer-group member. */
5284 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5285 member
->update_source
= sockunion_dup(su
);
5286 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5288 /* Send notification or reset peer depending on state. */
5289 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5290 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5291 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5292 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5294 bgp_session_reset(member
);
5296 /* Apply new source configuration to BFD session. */
5297 if (member
->bfd_config
)
5298 bgp_peer_bfd_update_source(member
);
5302 void peer_update_source_unset(struct peer
*peer
)
5304 struct peer
*member
;
5305 struct listnode
*node
, *nnode
;
5307 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_UPDATE_SOURCE
))
5310 /* Inherit configuration from peer-group if peer is member. */
5311 if (peer_group_active(peer
)) {
5312 peer_flag_inherit(peer
, PEER_FLAG_UPDATE_SOURCE
);
5313 PEER_SU_ATTR_INHERIT(peer
, peer
->group
, update_source
);
5314 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, update_if
,
5315 MTYPE_PEER_UPDATE_SOURCE
);
5317 /* Otherwise remove flag and configuration from peer. */
5318 peer_flag_unset(peer
, PEER_FLAG_UPDATE_SOURCE
);
5319 sockunion_free(peer
->update_source
);
5320 peer
->update_source
= NULL
;
5321 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
5324 /* Check if handling a regular peer. */
5325 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5326 /* Send notification or reset peer depending on state. */
5327 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5328 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5329 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5330 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5332 bgp_session_reset(peer
);
5334 /* Apply new source configuration to BFD session. */
5335 if (peer
->bfd_config
)
5336 bgp_peer_bfd_update_source(peer
);
5338 /* Skip peer-group mechanics for regular peers. */
5343 * Set flag and configuration on all peer-group members, unless they are
5344 * explicitly overriding peer-group configuration.
5346 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5347 /* Skip peers with overridden configuration. */
5348 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
5351 /* Skip peers with the same configuration. */
5352 if (!CHECK_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
)
5353 && !member
->update_source
&& !member
->update_if
)
5356 /* Remove flag and configuration on peer-group member. */
5357 UNSET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
5358 sockunion_free(member
->update_source
);
5359 member
->update_source
= NULL
;
5360 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
5362 /* Send notification or reset peer depending on state. */
5363 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5364 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
5365 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5366 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5368 bgp_session_reset(member
);
5370 /* Apply new source configuration to BFD session. */
5371 if (member
->bfd_config
)
5372 bgp_peer_bfd_update_source(member
);
5376 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5377 const char *rmap
, struct route_map
*route_map
)
5379 struct peer
*member
;
5380 struct listnode
*node
, *nnode
;
5381 struct update_subgroup
*subgrp
;
5383 /* Set flag and configuration on peer. */
5384 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
5386 subgrp
= peer_subgroup(peer
, afi
, safi
);
5389 if (!peer
->default_rmap
[afi
][safi
].name
5390 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
5391 if (peer
->default_rmap
[afi
][safi
].name
)
5392 XFREE(MTYPE_ROUTE_MAP_NAME
,
5393 peer
->default_rmap
[afi
][safi
].name
);
5396 * When there is a change in route-map policy,
5397 * this flow gets triggered. Since, the default
5398 * route is already originated, the flag is set.
5399 * The flag should be unset here,
5400 * to trigger the flow of sending update message.
5403 UNSET_FLAG(subgrp
->sflags
,
5404 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5406 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5407 peer
->default_rmap
[afi
][safi
].name
=
5408 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5409 peer
->default_rmap
[afi
][safi
].map
= route_map
;
5410 route_map_counter_increment(route_map
);
5413 if (peer
->default_rmap
[afi
][safi
].name
)
5414 XFREE(MTYPE_ROUTE_MAP_NAME
,
5415 peer
->default_rmap
[afi
][safi
].name
);
5418 * This is triggered in case of route-map deletion.
5419 * The flag needs to be unset, to trigger the flow
5420 * of sending an update message.
5423 UNSET_FLAG(subgrp
->sflags
,
5424 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
5426 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
5427 peer
->default_rmap
[afi
][safi
].name
= NULL
;
5428 peer
->default_rmap
[afi
][safi
].map
= NULL
;
5431 /* Check if handling a regular peer. */
5432 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5433 /* Update peer route announcements. */
5434 if (peer_established(peer
) && peer
->afc_nego
[afi
][safi
]) {
5435 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5436 bgp_default_originate(peer
, afi
, safi
, 0);
5437 bgp_announce_route(peer
, afi
, safi
, false);
5440 /* Skip peer-group mechanics for regular peers. */
5445 * Set flag and configuration on all peer-group members, unless they are
5446 * explicitly overriding peer-group configuration.
5448 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5449 /* Skip peers with overridden configuration. */
5450 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5451 PEER_FLAG_DEFAULT_ORIGINATE
))
5454 /* Set flag and configuration on peer-group member. */
5455 SET_FLAG(member
->af_flags
[afi
][safi
],
5456 PEER_FLAG_DEFAULT_ORIGINATE
);
5458 if (member
->default_rmap
[afi
][safi
].name
)
5459 XFREE(MTYPE_ROUTE_MAP_NAME
,
5460 member
->default_rmap
[afi
][safi
].name
);
5461 route_map_counter_decrement(
5462 member
->default_rmap
[afi
][safi
].map
);
5463 member
->default_rmap
[afi
][safi
].name
=
5464 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
5465 member
->default_rmap
[afi
][safi
].map
= route_map
;
5466 route_map_counter_increment(route_map
);
5469 /* Update peer route announcements. */
5470 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5471 update_group_adjust_peer(
5472 peer_af_find(member
, afi
, safi
));
5473 bgp_default_originate(member
, afi
, safi
, 0);
5474 bgp_announce_route(member
, afi
, safi
, false);
5481 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5483 struct peer
*member
;
5484 struct listnode
*node
, *nnode
;
5486 /* Inherit configuration from peer-group if peer is member. */
5487 if (peer_group_active(peer
)) {
5488 peer_af_flag_inherit(peer
, afi
, safi
,
5489 PEER_FLAG_DEFAULT_ORIGINATE
);
5490 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5491 default_rmap
[afi
][safi
].name
,
5492 MTYPE_ROUTE_MAP_NAME
);
5493 PEER_ATTR_INHERIT(peer
, peer
->group
,
5494 default_rmap
[afi
][safi
].map
);
5496 /* Otherwise remove flag and configuration from peer. */
5497 peer_af_flag_unset(peer
, afi
, safi
,
5498 PEER_FLAG_DEFAULT_ORIGINATE
);
5499 if (peer
->default_rmap
[afi
][safi
].name
)
5500 XFREE(MTYPE_ROUTE_MAP_NAME
,
5501 peer
->default_rmap
[afi
][safi
].name
);
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
, 1);
5513 bgp_announce_route(peer
, afi
, safi
, false);
5516 /* Skip peer-group mechanics for regular peers. */
5521 * Remove flag and configuration from all peer-group members, unless
5522 * they are 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 /* Remove flag and configuration on peer-group member. */
5531 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5532 PEER_FLAG_DEFAULT_ORIGINATE
);
5533 if (member
->default_rmap
[afi
][safi
].name
)
5534 XFREE(MTYPE_ROUTE_MAP_NAME
,
5535 member
->default_rmap
[afi
][safi
].name
);
5536 route_map_counter_decrement(member
->default_rmap
[afi
][safi
].map
);
5537 member
->default_rmap
[afi
][safi
].name
= NULL
;
5538 member
->default_rmap
[afi
][safi
].map
= NULL
;
5540 /* Update peer route announcements. */
5541 if (peer_established(member
) && member
->afc_nego
[afi
][safi
]) {
5542 update_group_adjust_peer(peer_af_find(member
, afi
, safi
));
5543 bgp_default_originate(member
, afi
, safi
, 1);
5544 bgp_announce_route(member
, afi
, safi
, false);
5551 void peer_port_set(struct peer
*peer
, uint16_t port
)
5554 peer_flag_set(peer
, PEER_FLAG_PORT
);
5557 void peer_port_unset(struct peer
*peer
)
5559 peer
->port
= BGP_PORT_DEFAULT
;
5560 peer_flag_unset(peer
, PEER_FLAG_PORT
);
5563 /* Set the TCP-MSS value in the peer structure,
5564 * This gets applied only after connection reset
5565 * So this value will be used in bgp_connect.
5567 void peer_tcp_mss_set(struct peer
*peer
, uint32_t tcp_mss
)
5569 peer
->tcp_mss
= tcp_mss
;
5570 SET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5573 /* Reset the TCP-MSS value in the peer structure,
5574 * This gets applied only after connection reset
5575 * So this value will be used in bgp_connect.
5577 void peer_tcp_mss_unset(struct peer
*peer
)
5579 UNSET_FLAG(peer
->flags
, PEER_FLAG_TCP_MSS
);
5584 * Helper function that is called after the name of the policy
5585 * being used by a peer has changed (AF specific). Automatically
5586 * initiates inbound or outbound processing as needed.
5588 void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
5592 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
5593 if (peer_established(peer
))
5594 bgp_announce_route(peer
, afi
, safi
, false);
5596 if (!peer_established(peer
))
5599 if (bgp_soft_reconfig_in(peer
, afi
, safi
))
5602 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
) ||
5603 CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
)) {
5604 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5605 PEER_CAP_ORF_PREFIX_SM_ADV
) &&
5606 (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5607 PEER_CAP_ORF_PREFIX_RM_RCV
) ||
5608 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
5609 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
5610 peer_clear_soft(peer
, afi
, safi
,
5611 BGP_CLEAR_SOFT_IN_ORF_PREFIX
);
5613 bgp_route_refresh_send(
5614 peer
, afi
, safi
, 0, 0, 0,
5615 BGP_ROUTE_REFRESH_NORMAL
);
5621 /* neighbor weight. */
5622 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
5624 struct peer
*member
;
5625 struct listnode
*node
, *nnode
;
5627 /* Set flag and configuration on peer. */
5628 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5629 if (peer
->weight
[afi
][safi
] != weight
) {
5630 peer
->weight
[afi
][safi
] = weight
;
5631 peer_on_policy_change(peer
, afi
, safi
, 0);
5634 /* Skip peer-group mechanics for regular peers. */
5635 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5639 * Set flag and configuration on all peer-group members, unless they are
5640 * explicitly overriding peer-group configuration.
5642 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5643 /* Skip peers with overridden configuration. */
5644 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5648 /* Set flag and configuration on peer-group member. */
5649 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5650 if (member
->weight
[afi
][safi
] != weight
) {
5651 member
->weight
[afi
][safi
] = weight
;
5652 peer_on_policy_change(member
, afi
, safi
, 0);
5659 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5661 struct peer
*member
;
5662 struct listnode
*node
, *nnode
;
5664 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5667 /* Inherit configuration from peer-group if peer is member. */
5668 if (peer_group_active(peer
)) {
5669 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5670 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
5672 peer_on_policy_change(peer
, afi
, safi
, 0);
5676 /* Remove flag and configuration from peer. */
5677 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
5678 peer
->weight
[afi
][safi
] = 0;
5679 peer_on_policy_change(peer
, afi
, safi
, 0);
5681 /* Skip peer-group mechanics for regular peers. */
5682 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5686 * Remove flag and configuration from all peer-group members, unless
5687 * they are explicitly overriding peer-group configuration.
5689 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5690 /* Skip peers with overridden configuration. */
5691 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5695 /* Skip peers where flag is already disabled. */
5696 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
5699 /* Remove flag and configuration on peer-group member. */
5700 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
5701 member
->weight
[afi
][safi
] = 0;
5702 peer_on_policy_change(member
, afi
, safi
, 0);
5708 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
5710 struct peer
*member
;
5711 struct listnode
*node
, *nnode
;
5713 if (keepalive
> UINT16_MAX
)
5714 return BGP_ERR_INVALID_VALUE
;
5716 if (holdtime
> UINT16_MAX
)
5717 return BGP_ERR_INVALID_VALUE
;
5719 if (holdtime
< 3 && holdtime
!= 0)
5720 return BGP_ERR_INVALID_VALUE
;
5722 /* Set flag and configuration on peer. */
5723 peer_flag_set(peer
, PEER_FLAG_TIMER
);
5724 peer
->holdtime
= holdtime
;
5725 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
5727 /* Skip peer-group mechanics for regular peers. */
5728 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5732 * Set flag and configuration on all peer-group members, unless they are
5733 * explicitly overriding peer-group configuration.
5735 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5736 /* Skip peers with overridden configuration. */
5737 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5740 /* Set flag and configuration on peer-group member. */
5741 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5742 PEER_ATTR_INHERIT(member
, peer
->group
, holdtime
);
5743 PEER_ATTR_INHERIT(member
, peer
->group
, keepalive
);
5749 int peer_timers_unset(struct peer
*peer
)
5751 struct peer
*member
;
5752 struct listnode
*node
, *nnode
;
5754 /* Inherit configuration from peer-group if peer is member. */
5755 if (peer_group_active(peer
)) {
5756 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
5757 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
5758 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
5760 /* Otherwise remove flag and configuration from peer. */
5761 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
5763 peer
->keepalive
= 0;
5766 /* Skip peer-group mechanics for regular peers. */
5767 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5771 * Remove flag and configuration from all peer-group members, unless
5772 * they are explicitly overriding peer-group configuration.
5774 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5775 /* Skip peers with overridden configuration. */
5776 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5779 /* Remove flag and configuration on peer-group member. */
5780 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5781 member
->holdtime
= 0;
5782 member
->keepalive
= 0;
5788 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
5790 struct peer
*member
;
5791 struct listnode
*node
, *nnode
;
5793 if (connect
> UINT16_MAX
)
5794 return BGP_ERR_INVALID_VALUE
;
5796 /* Set flag and configuration on peer. */
5797 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
5798 peer
->connect
= connect
;
5799 peer
->v_connect
= connect
;
5801 /* Skip peer-group mechanics for regular peers. */
5802 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5803 if (!peer_established(peer
)) {
5804 if (peer_active(peer
))
5805 BGP_EVENT_ADD(peer
, BGP_Stop
);
5806 BGP_EVENT_ADD(peer
, BGP_Start
);
5811 * Set flag and configuration on all peer-group members, unless they are
5812 * explicitly overriding peer-group configuration.
5814 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5815 /* Skip peers with overridden configuration. */
5816 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5819 /* Set flag and configuration on peer-group member. */
5820 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5821 member
->connect
= connect
;
5822 member
->v_connect
= connect
;
5824 if (!peer_established(member
)) {
5825 if (peer_active(member
))
5826 BGP_EVENT_ADD(member
, BGP_Stop
);
5827 BGP_EVENT_ADD(member
, BGP_Start
);
5834 int peer_timers_connect_unset(struct peer
*peer
)
5836 struct peer
*member
;
5837 struct listnode
*node
, *nnode
;
5839 /* Inherit configuration from peer-group if peer is member. */
5840 if (peer_group_active(peer
)) {
5841 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5842 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5844 /* Otherwise remove flag and configuration from peer. */
5845 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5849 /* Set timer with fallback to default value. */
5851 peer
->v_connect
= peer
->connect
;
5853 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
5855 /* Skip peer-group mechanics for regular peers. */
5856 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5857 if (!peer_established(peer
)) {
5858 if (peer_active(peer
))
5859 BGP_EVENT_ADD(peer
, BGP_Stop
);
5860 BGP_EVENT_ADD(peer
, BGP_Start
);
5865 * Remove flag and configuration from all peer-group members, unless
5866 * they are explicitly overriding peer-group configuration.
5868 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5869 /* Skip peers with overridden configuration. */
5870 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5873 /* Remove flag and configuration on peer-group member. */
5874 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5875 member
->connect
= 0;
5876 member
->v_connect
= peer
->bgp
->default_connect_retry
;
5878 if (!peer_established(member
)) {
5879 if (peer_active(member
))
5880 BGP_EVENT_ADD(member
, BGP_Stop
);
5881 BGP_EVENT_ADD(member
, BGP_Start
);
5888 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5890 struct peer
*member
;
5891 struct listnode
*node
, *nnode
;
5894 return BGP_ERR_INVALID_VALUE
;
5896 /* Set flag and configuration on peer. */
5897 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5898 peer
->routeadv
= routeadv
;
5899 peer
->v_routeadv
= routeadv
;
5901 /* Check if handling a regular peer. */
5902 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5903 /* Update peer route announcements. */
5904 update_group_adjust_peer_afs(peer
);
5905 if (peer_established(peer
))
5906 bgp_announce_route_all(peer
);
5908 /* Skip peer-group mechanics for regular peers. */
5913 * Set flag and configuration on all peer-group members, unless they are
5914 * explicitly overriding peer-group configuration.
5916 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5917 /* Skip peers with overridden configuration. */
5918 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5921 /* Set flag and configuration on peer-group member. */
5922 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5923 member
->routeadv
= routeadv
;
5924 member
->v_routeadv
= routeadv
;
5926 /* Update peer route announcements. */
5927 update_group_adjust_peer_afs(member
);
5928 if (peer_established(member
))
5929 bgp_announce_route_all(member
);
5935 int peer_advertise_interval_unset(struct peer
*peer
)
5937 struct peer
*member
;
5938 struct listnode
*node
, *nnode
;
5940 /* Inherit configuration from peer-group if peer is member. */
5941 if (peer_group_active(peer
)) {
5942 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
5943 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
5945 /* Otherwise remove flag and configuration from peer. */
5946 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
5950 /* Set timer with fallback to default value. */
5952 peer
->v_routeadv
= peer
->routeadv
;
5954 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
5955 ? BGP_DEFAULT_IBGP_ROUTEADV
5956 : BGP_DEFAULT_EBGP_ROUTEADV
;
5958 /* Check if handling a regular peer. */
5959 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5960 /* Update peer route announcements. */
5961 update_group_adjust_peer_afs(peer
);
5962 if (peer_established(peer
))
5963 bgp_announce_route_all(peer
);
5965 /* Skip peer-group mechanics for regular peers. */
5970 * Remove flag and configuration from all peer-group members, unless
5971 * they are explicitly overriding peer-group configuration.
5973 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5974 /* Skip peers with overridden configuration. */
5975 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5978 /* Remove flag and configuration on peer-group member. */
5979 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5980 member
->routeadv
= 0;
5981 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
5982 ? BGP_DEFAULT_IBGP_ROUTEADV
5983 : BGP_DEFAULT_EBGP_ROUTEADV
;
5985 /* Update peer route announcements. */
5986 update_group_adjust_peer_afs(member
);
5987 if (peer_established(member
))
5988 bgp_announce_route_all(member
);
5994 /* set the peers RFC 4271 DelayOpen session attribute flag and DelayOpenTimer
5997 int peer_timers_delayopen_set(struct peer
*peer
, uint32_t delayopen
)
5999 struct peer
*member
;
6000 struct listnode
*node
;
6002 /* Set peers session attribute flag and timer interval. */
6003 peer_flag_set(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6004 peer
->delayopen
= delayopen
;
6005 peer
->v_delayopen
= delayopen
;
6007 /* Skip group mechanics for regular peers. */
6008 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6011 /* Set flag and configuration on all peer-group members, unless they are
6012 * explicitly overriding peer-group configuration.
6014 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6015 /* Skip peers with overridden configuration. */
6016 if (CHECK_FLAG(member
->flags_override
,
6017 PEER_FLAG_TIMER_DELAYOPEN
))
6020 /* Set session attribute flag and timer intervals on peer-group
6023 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6024 member
->delayopen
= delayopen
;
6025 member
->v_delayopen
= delayopen
;
6031 /* unset the peers RFC 4271 DelayOpen session attribute flag and reset the
6032 * DelayOpenTimer interval to the default value.
6034 int peer_timers_delayopen_unset(struct peer
*peer
)
6036 struct peer
*member
;
6037 struct listnode
*node
;
6039 /* Inherit configuration from peer-group if peer is member. */
6040 if (peer_group_active(peer
)) {
6041 peer_flag_inherit(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6042 PEER_ATTR_INHERIT(peer
, peer
->group
, delayopen
);
6044 /* Otherwise remove session attribute flag and set timer
6045 * interval to default value.
6047 peer_flag_unset(peer
, PEER_FLAG_TIMER_DELAYOPEN
);
6048 peer
->delayopen
= peer
->bgp
->default_delayopen
;
6051 /* Set timer value to zero */
6052 peer
->v_delayopen
= 0;
6054 /* Skip peer-group mechanics for regular peers. */
6055 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6058 /* Remove flag and configuration from all peer-group members, unless
6059 * they are explicitly overriding peer-group configuration.
6061 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6062 /* Skip peers with overridden configuration. */
6063 if (CHECK_FLAG(member
->flags_override
,
6064 PEER_FLAG_TIMER_DELAYOPEN
))
6067 /* Remove session attribute flag, reset the timer interval to
6068 * the default value and set the timer value to zero.
6070 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_DELAYOPEN
);
6071 member
->delayopen
= peer
->bgp
->default_delayopen
;
6072 member
->v_delayopen
= 0;
6078 /* neighbor interface */
6079 void peer_interface_set(struct peer
*peer
, const char *str
)
6081 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6082 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
6085 void peer_interface_unset(struct peer
*peer
)
6087 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
6091 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6092 int allow_num
, int origin
)
6094 struct peer
*member
;
6095 struct listnode
*node
, *nnode
;
6097 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
6098 return BGP_ERR_INVALID_VALUE
;
6100 /* Set flag and configuration on peer. */
6101 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6103 if (peer
->allowas_in
[afi
][safi
] != 0
6104 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6105 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6106 peer_af_flag_set(peer
, afi
, safi
,
6107 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6108 peer
->allowas_in
[afi
][safi
] = 0;
6109 peer_on_policy_change(peer
, afi
, safi
, 0);
6112 if (peer
->allowas_in
[afi
][safi
] != allow_num
6113 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6114 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6116 peer_af_flag_unset(peer
, afi
, safi
,
6117 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6118 peer
->allowas_in
[afi
][safi
] = allow_num
;
6119 peer_on_policy_change(peer
, afi
, safi
, 0);
6123 /* Skip peer-group mechanics for regular peers. */
6124 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6128 * Set flag and configuration on all peer-group members, unless
6129 * they are explicitly overriding peer-group configuration.
6131 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6132 /* Skip peers with overridden configuration. */
6133 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6134 PEER_FLAG_ALLOWAS_IN
))
6137 /* Set flag and configuration on peer-group member. */
6138 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6140 if (member
->allowas_in
[afi
][safi
] != 0
6141 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
6142 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6143 SET_FLAG(member
->af_flags
[afi
][safi
],
6144 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6145 member
->allowas_in
[afi
][safi
] = 0;
6146 peer_on_policy_change(peer
, afi
, safi
, 0);
6149 if (member
->allowas_in
[afi
][safi
] != allow_num
6150 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
6151 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
6152 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6153 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6154 member
->allowas_in
[afi
][safi
] = allow_num
;
6155 peer_on_policy_change(peer
, afi
, safi
, 0);
6163 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6165 struct peer
*member
;
6166 struct listnode
*node
, *nnode
;
6168 /* Skip peer if flag is already disabled. */
6169 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
6172 /* Inherit configuration from peer-group if peer is member. */
6173 if (peer_group_active(peer
)) {
6174 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6175 peer_af_flag_inherit(peer
, afi
, safi
,
6176 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6177 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
6178 peer_on_policy_change(peer
, afi
, safi
, 0);
6183 /* Remove flag and configuration from peer. */
6184 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
6185 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6186 peer
->allowas_in
[afi
][safi
] = 0;
6187 peer_on_policy_change(peer
, afi
, safi
, 0);
6189 /* Skip peer-group mechanics if handling a regular peer. */
6190 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6194 * Remove flags and configuration from all peer-group members, unless
6195 * they are explicitly overriding peer-group configuration.
6197 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6198 /* Skip peers with overridden configuration. */
6199 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6200 PEER_FLAG_ALLOWAS_IN
))
6203 /* Remove flags and configuration on peer-group member. */
6204 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
6205 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6206 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
6207 member
->allowas_in
[afi
][safi
] = 0;
6208 peer_on_policy_change(member
, afi
, safi
, 0);
6214 int peer_local_as_set(struct peer
*peer
, as_t as
, bool no_prepend
,
6217 bool old_no_prepend
, old_replace_as
;
6218 struct bgp
*bgp
= peer
->bgp
;
6219 struct peer
*member
;
6220 struct listnode
*node
, *nnode
;
6223 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
6225 /* Save previous flag states. */
6227 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6229 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6231 /* Set flag and configuration on peer. */
6232 peer_flag_set(peer
, PEER_FLAG_LOCAL_AS
);
6233 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
, no_prepend
);
6234 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
, replace_as
);
6236 if (peer
->change_local_as
== as
&& old_no_prepend
== no_prepend
6237 && old_replace_as
== replace_as
)
6239 peer
->change_local_as
= as
;
6240 (void)peer_sort(peer
);
6242 /* Check if handling a regular peer. */
6243 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
6247 * Set flag and configuration on all peer-group members, unless they are
6248 * explicitly overriding peer-group configuration.
6250 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6251 /* Skip peers with overridden configuration. */
6252 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6255 /* Skip peers with the same configuration. */
6256 old_no_prepend
= CHECK_FLAG(member
->flags
,
6257 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6258 old_replace_as
= CHECK_FLAG(member
->flags
,
6259 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6260 if (member
->change_local_as
== as
6261 && CHECK_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
)
6262 && old_no_prepend
== no_prepend
6263 && old_replace_as
== replace_as
)
6266 /* Set flag and configuration on peer-group member. */
6267 SET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6268 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
,
6270 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
,
6272 member
->change_local_as
= as
;
6278 int peer_local_as_unset(struct peer
*peer
)
6280 struct peer
*member
;
6281 struct listnode
*node
, *nnode
;
6283 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS
))
6286 /* Inherit configuration from peer-group if peer is member. */
6287 if (peer_group_active(peer
)) {
6288 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS
);
6289 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6290 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6291 PEER_ATTR_INHERIT(peer
, peer
->group
, change_local_as
);
6293 /* Otherwise remove flag and configuration from peer. */
6294 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
6295 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6296 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6297 peer
->change_local_as
= 0;
6300 /* Check if handling a regular peer. */
6301 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6302 /* Send notification or stop peer depending on state. */
6303 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
6304 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6305 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6306 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6308 BGP_EVENT_ADD(peer
, BGP_Stop
);
6310 /* Skip peer-group mechanics for regular peers. */
6315 * Remove flag and configuration from all peer-group members, unless
6316 * they are explicitly overriding peer-group configuration.
6318 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6319 /* Skip peers with overridden configuration. */
6320 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
6323 /* Remove flag and configuration on peer-group member. */
6324 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
6325 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
6326 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
6327 member
->change_local_as
= 0;
6329 /* Send notification or stop peer depending on state. */
6330 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
6331 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
6332 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6333 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6335 bgp_session_reset(member
);
6341 /* Set password for authenticating with the peer. */
6342 int peer_password_set(struct peer
*peer
, const char *password
)
6344 struct peer
*member
;
6345 struct listnode
*node
, *nnode
;
6346 int len
= password
? strlen(password
) : 0;
6347 int ret
= BGP_SUCCESS
;
6349 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
6350 return BGP_ERR_INVALID_VALUE
;
6352 /* Set flag and configuration on peer. */
6353 peer_flag_set(peer
, PEER_FLAG_PASSWORD
);
6354 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
6356 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6357 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6359 /* Check if handling a regular peer. */
6360 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6361 /* Send notification or reset peer depending on state. */
6362 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6363 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6364 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6366 bgp_session_reset(peer
);
6369 * Attempt to install password on socket and skip peer-group
6372 if (BGP_PEER_SU_UNSPEC(peer
))
6374 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
6375 : BGP_ERR_TCPSIG_FAILED
;
6379 * Set flag and configuration on all peer-group members, unless they are
6380 * explicitly overriding peer-group configuration.
6382 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6383 /* Skip peers with overridden configuration. */
6384 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6387 /* Skip peers with the same password. */
6388 if (member
->password
&& strcmp(member
->password
, password
) == 0)
6391 /* Set flag and configuration on peer-group member. */
6392 SET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6393 if (member
->password
)
6394 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6395 member
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
6397 /* Send notification or reset peer depending on state. */
6398 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6399 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6400 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6402 bgp_session_reset(member
);
6404 /* Attempt to install password on socket. */
6405 if (!BGP_PEER_SU_UNSPEC(member
) && bgp_md5_set(member
) < 0)
6406 ret
= BGP_ERR_TCPSIG_FAILED
;
6409 /* Set flag and configuration on all peer-group listen ranges */
6410 struct listnode
*ln
;
6413 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6414 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6415 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6416 bgp_md5_set_prefix(peer
->bgp
, lr
, password
);
6421 int peer_password_unset(struct peer
*peer
)
6423 struct peer
*member
;
6424 struct listnode
*node
, *nnode
;
6426 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
))
6429 /* Inherit configuration from peer-group if peer is member. */
6430 if (peer_group_active(peer
)) {
6431 peer_flag_inherit(peer
, PEER_FLAG_PASSWORD
);
6432 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, password
,
6433 MTYPE_PEER_PASSWORD
);
6435 /* Otherwise remove flag and configuration from peer. */
6436 peer_flag_unset(peer
, PEER_FLAG_PASSWORD
);
6437 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
6440 /* Check if handling a regular peer. */
6441 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6442 /* Send notification or reset peer depending on state. */
6443 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6444 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6445 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6447 bgp_session_reset(peer
);
6449 /* Attempt to uninstall password on socket. */
6450 if (!BGP_PEER_SU_UNSPEC(peer
))
6451 bgp_md5_unset(peer
);
6452 /* Skip peer-group mechanics for regular peers. */
6457 * Remove flag and configuration from all peer-group members, unless
6458 * they are explicitly overriding peer-group configuration.
6460 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6461 /* Skip peers with overridden configuration. */
6462 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
6465 /* Remove flag and configuration on peer-group member. */
6466 UNSET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
6467 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
6469 /* Send notification or reset peer depending on state. */
6470 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
6471 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
6472 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
6474 bgp_session_reset(member
);
6476 /* Attempt to uninstall password on socket. */
6477 if (!BGP_PEER_SU_UNSPEC(member
))
6478 bgp_md5_unset(member
);
6481 /* Set flag and configuration on all peer-group listen ranges */
6482 struct listnode
*ln
;
6485 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
6486 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6487 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
6488 bgp_md5_unset_prefix(peer
->bgp
, lr
);
6494 /* Set distribute list to the peer. */
6495 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6498 struct peer
*member
;
6499 struct bgp_filter
*filter
;
6500 struct listnode
*node
, *nnode
;
6502 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6503 return BGP_ERR_INVALID_VALUE
;
6505 /* Set configuration on peer. */
6506 filter
= &peer
->filter
[afi
][safi
];
6507 if (filter
->plist
[direct
].name
)
6508 return BGP_ERR_PEER_FILTER_CONFLICT
;
6509 if (filter
->dlist
[direct
].name
)
6510 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
6511 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6512 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6514 /* Check if handling a regular peer. */
6515 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6516 /* Set override-flag and process peer route updates. */
6517 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6518 PEER_FT_DISTRIBUTE_LIST
);
6519 peer_on_policy_change(peer
, afi
, safi
,
6520 (direct
== FILTER_OUT
) ? 1 : 0);
6522 /* Skip peer-group mechanics for regular peers. */
6527 * Set configuration on all peer-group members, un less they are
6528 * explicitly overriding peer-group configuration.
6530 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6531 /* Skip peers with overridden configuration. */
6532 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6533 PEER_FT_DISTRIBUTE_LIST
))
6536 /* Set configuration on peer-group member. */
6537 filter
= &member
->filter
[afi
][safi
];
6538 if (filter
->dlist
[direct
].name
)
6539 XFREE(MTYPE_BGP_FILTER_NAME
,
6540 filter
->dlist
[direct
].name
);
6541 filter
->dlist
[direct
].name
=
6542 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6543 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
6545 /* Process peer route updates. */
6546 peer_on_policy_change(member
, afi
, safi
,
6547 (direct
== FILTER_OUT
) ? 1 : 0);
6553 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6555 struct peer
*member
;
6556 struct bgp_filter
*filter
;
6557 struct listnode
*node
, *nnode
;
6559 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6560 return BGP_ERR_INVALID_VALUE
;
6562 /* Unset override-flag unconditionally. */
6563 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6564 PEER_FT_DISTRIBUTE_LIST
);
6566 /* Inherit configuration from peer-group if peer is member. */
6567 if (peer_group_active(peer
)) {
6568 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6569 filter
[afi
][safi
].dlist
[direct
].name
,
6570 MTYPE_BGP_FILTER_NAME
);
6571 PEER_ATTR_INHERIT(peer
, peer
->group
,
6572 filter
[afi
][safi
].dlist
[direct
].alist
);
6574 /* Otherwise remove configuration from peer. */
6575 filter
= &peer
->filter
[afi
][safi
];
6576 if (filter
->dlist
[direct
].name
)
6577 XFREE(MTYPE_BGP_FILTER_NAME
,
6578 filter
->dlist
[direct
].name
);
6579 filter
->dlist
[direct
].name
= NULL
;
6580 filter
->dlist
[direct
].alist
= NULL
;
6583 /* Check if handling a regular peer. */
6584 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6585 /* Process peer route updates. */
6586 peer_on_policy_change(peer
, afi
, safi
,
6587 (direct
== FILTER_OUT
) ? 1 : 0);
6589 /* Skip peer-group mechanics for regular peers. */
6594 * Remove configuration on all peer-group members, unless they are
6595 * explicitly overriding peer-group configuration.
6597 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6598 /* Skip peers with overridden configuration. */
6599 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6600 PEER_FT_DISTRIBUTE_LIST
))
6603 /* Remove configuration on peer-group member. */
6604 filter
= &member
->filter
[afi
][safi
];
6605 if (filter
->dlist
[direct
].name
)
6606 XFREE(MTYPE_BGP_FILTER_NAME
,
6607 filter
->dlist
[direct
].name
);
6608 filter
->dlist
[direct
].name
= NULL
;
6609 filter
->dlist
[direct
].alist
= NULL
;
6611 /* Process peer route updates. */
6612 peer_on_policy_change(member
, afi
, safi
,
6613 (direct
== FILTER_OUT
) ? 1 : 0);
6619 /* Update distribute list. */
6620 static void peer_distribute_update(struct access_list
*access
)
6625 struct listnode
*mnode
, *mnnode
;
6626 struct listnode
*node
, *nnode
;
6629 struct peer_group
*group
;
6630 struct bgp_filter
*filter
;
6632 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6634 update_group_policy_update(bgp
,
6635 BGP_POLICY_DISTRIBUTE_LIST
,
6636 access
->name
, true, 0);
6637 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6638 FOREACH_AFI_SAFI (afi
, safi
) {
6639 filter
= &peer
->filter
[afi
][safi
];
6641 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6643 if (filter
->dlist
[direct
].name
)
6644 filter
->dlist
[direct
]
6645 .alist
= access_list_lookup(
6647 filter
->dlist
[direct
]
6650 filter
->dlist
[direct
].alist
=
6655 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6656 FOREACH_AFI_SAFI (afi
, safi
) {
6657 filter
= &group
->conf
->filter
[afi
][safi
];
6659 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6661 if (filter
->dlist
[direct
].name
)
6662 filter
->dlist
[direct
]
6663 .alist
= access_list_lookup(
6665 filter
->dlist
[direct
]
6668 filter
->dlist
[direct
].alist
=
6673 #ifdef ENABLE_BGP_VNC
6674 vnc_prefix_list_update(bgp
);
6679 /* Set prefix list to the peer. */
6680 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6683 struct peer
*member
;
6684 struct bgp_filter
*filter
;
6685 struct listnode
*node
, *nnode
;
6687 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6688 return BGP_ERR_INVALID_VALUE
;
6690 /* Set configuration on peer. */
6691 filter
= &peer
->filter
[afi
][safi
];
6692 if (filter
->dlist
[direct
].name
)
6693 return BGP_ERR_PEER_FILTER_CONFLICT
;
6694 if (filter
->plist
[direct
].name
)
6695 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
6696 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6697 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6699 /* Check if handling a regular peer. */
6700 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6701 /* Set override-flag and process peer route updates. */
6702 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6703 PEER_FT_PREFIX_LIST
);
6704 peer_on_policy_change(peer
, afi
, safi
,
6705 (direct
== FILTER_OUT
) ? 1 : 0);
6707 /* Skip peer-group mechanics for regular peers. */
6712 * Set configuration on all peer-group members, unless they are
6713 * explicitly overriding peer-group configuration.
6715 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6716 /* Skip peers with overridden configuration. */
6717 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6718 PEER_FT_PREFIX_LIST
))
6721 /* Set configuration on peer-group member. */
6722 filter
= &member
->filter
[afi
][safi
];
6723 if (filter
->plist
[direct
].name
)
6724 XFREE(MTYPE_BGP_FILTER_NAME
,
6725 filter
->plist
[direct
].name
);
6726 filter
->plist
[direct
].name
=
6727 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6728 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
6730 /* Process peer route updates. */
6731 peer_on_policy_change(member
, afi
, safi
,
6732 (direct
== FILTER_OUT
) ? 1 : 0);
6738 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
6741 struct peer
*member
;
6742 struct bgp_filter
*filter
;
6743 struct listnode
*node
, *nnode
;
6745 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6746 return BGP_ERR_INVALID_VALUE
;
6748 /* Unset override-flag unconditionally. */
6749 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6750 PEER_FT_PREFIX_LIST
);
6752 /* Inherit configuration from peer-group if peer is member. */
6753 if (peer_group_active(peer
)) {
6754 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6755 filter
[afi
][safi
].plist
[direct
].name
,
6756 MTYPE_BGP_FILTER_NAME
);
6757 PEER_ATTR_INHERIT(peer
, peer
->group
,
6758 filter
[afi
][safi
].plist
[direct
].plist
);
6760 /* Otherwise remove configuration from peer. */
6761 filter
= &peer
->filter
[afi
][safi
];
6762 if (filter
->plist
[direct
].name
)
6763 XFREE(MTYPE_BGP_FILTER_NAME
,
6764 filter
->plist
[direct
].name
);
6765 filter
->plist
[direct
].name
= NULL
;
6766 filter
->plist
[direct
].plist
= NULL
;
6769 /* Check if handling a regular peer. */
6770 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6771 /* Process peer route updates. */
6772 peer_on_policy_change(peer
, afi
, safi
,
6773 (direct
== FILTER_OUT
) ? 1 : 0);
6775 /* Skip peer-group mechanics for regular peers. */
6780 * Remove configuration on all peer-group members, unless they are
6781 * explicitly overriding peer-group configuration.
6783 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6784 /* Skip peers with overridden configuration. */
6785 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6786 PEER_FT_PREFIX_LIST
))
6789 /* Remove configuration on peer-group member. */
6790 filter
= &member
->filter
[afi
][safi
];
6791 if (filter
->plist
[direct
].name
)
6792 XFREE(MTYPE_BGP_FILTER_NAME
,
6793 filter
->plist
[direct
].name
);
6794 filter
->plist
[direct
].name
= NULL
;
6795 filter
->plist
[direct
].plist
= NULL
;
6797 /* Process peer route updates. */
6798 peer_on_policy_change(member
, afi
, safi
,
6799 (direct
== FILTER_OUT
) ? 1 : 0);
6805 /* Update prefix-list list. */
6806 static void peer_prefix_list_update(struct prefix_list
*plist
)
6808 struct listnode
*mnode
, *mnnode
;
6809 struct listnode
*node
, *nnode
;
6812 struct peer_group
*group
;
6813 struct bgp_filter
*filter
;
6818 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6821 * Update the prefix-list on update groups.
6823 update_group_policy_update(
6824 bgp
, BGP_POLICY_PREFIX_LIST
,
6825 plist
? prefix_list_name(plist
) : NULL
, true, 0);
6827 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6828 FOREACH_AFI_SAFI (afi
, safi
) {
6829 filter
= &peer
->filter
[afi
][safi
];
6831 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6833 if (filter
->plist
[direct
].name
)
6834 filter
->plist
[direct
]
6835 .plist
= prefix_list_lookup(
6837 filter
->plist
[direct
]
6840 filter
->plist
[direct
].plist
=
6844 /* If we touch prefix-list, we need to process
6845 * new updates. This is important for ORF to
6846 * work correctly as well.
6848 if (peer
->afc_nego
[afi
][safi
])
6849 peer_on_policy_change(peer
, afi
, safi
,
6853 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6854 FOREACH_AFI_SAFI (afi
, safi
) {
6855 filter
= &group
->conf
->filter
[afi
][safi
];
6857 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6859 if (filter
->plist
[direct
].name
)
6860 filter
->plist
[direct
]
6861 .plist
= prefix_list_lookup(
6863 filter
->plist
[direct
]
6866 filter
->plist
[direct
].plist
=
6874 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6877 struct peer
*member
;
6878 struct bgp_filter
*filter
;
6879 struct listnode
*node
, *nnode
;
6881 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6882 return BGP_ERR_INVALID_VALUE
;
6884 /* Set configuration on peer. */
6885 filter
= &peer
->filter
[afi
][safi
];
6886 if (filter
->aslist
[direct
].name
)
6887 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
6888 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6889 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6891 /* Check if handling a regular peer. */
6892 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6893 /* Set override-flag and process peer route updates. */
6894 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6895 PEER_FT_FILTER_LIST
);
6896 peer_on_policy_change(peer
, afi
, safi
,
6897 (direct
== FILTER_OUT
) ? 1 : 0);
6899 /* Skip peer-group mechanics for regular peers. */
6904 * Set configuration on all peer-group members, unless they are
6905 * explicitly overriding peer-group configuration.
6907 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6908 /* Skip peers with overridden configuration. */
6909 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6910 PEER_FT_FILTER_LIST
))
6913 /* Set configuration on peer-group member. */
6914 filter
= &member
->filter
[afi
][safi
];
6915 if (filter
->aslist
[direct
].name
)
6916 XFREE(MTYPE_BGP_FILTER_NAME
,
6917 filter
->aslist
[direct
].name
);
6918 filter
->aslist
[direct
].name
=
6919 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6920 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6922 /* Process peer route updates. */
6923 peer_on_policy_change(member
, afi
, safi
,
6924 (direct
== FILTER_OUT
) ? 1 : 0);
6930 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6932 struct peer
*member
;
6933 struct bgp_filter
*filter
;
6934 struct listnode
*node
, *nnode
;
6936 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6937 return BGP_ERR_INVALID_VALUE
;
6939 /* Unset override-flag unconditionally. */
6940 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6941 PEER_FT_FILTER_LIST
);
6943 /* Inherit configuration from peer-group if peer is member. */
6944 if (peer_group_active(peer
)) {
6945 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6946 filter
[afi
][safi
].aslist
[direct
].name
,
6947 MTYPE_BGP_FILTER_NAME
);
6948 PEER_ATTR_INHERIT(peer
, peer
->group
,
6949 filter
[afi
][safi
].aslist
[direct
].aslist
);
6951 /* Otherwise remove configuration from peer. */
6952 filter
= &peer
->filter
[afi
][safi
];
6953 if (filter
->aslist
[direct
].name
)
6954 XFREE(MTYPE_BGP_FILTER_NAME
,
6955 filter
->aslist
[direct
].name
);
6956 filter
->aslist
[direct
].name
= NULL
;
6957 filter
->aslist
[direct
].aslist
= NULL
;
6960 /* Check if handling a regular peer. */
6961 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6962 /* Process peer route updates. */
6963 peer_on_policy_change(peer
, afi
, safi
,
6964 (direct
== FILTER_OUT
) ? 1 : 0);
6966 /* Skip peer-group mechanics for regular peers. */
6971 * Remove configuration on all peer-group members, unless they are
6972 * explicitly overriding peer-group configuration.
6974 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6975 /* Skip peers with overridden configuration. */
6976 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6977 PEER_FT_FILTER_LIST
))
6980 /* Remove configuration on peer-group member. */
6981 filter
= &member
->filter
[afi
][safi
];
6982 if (filter
->aslist
[direct
].name
)
6983 XFREE(MTYPE_BGP_FILTER_NAME
,
6984 filter
->aslist
[direct
].name
);
6985 filter
->aslist
[direct
].name
= NULL
;
6986 filter
->aslist
[direct
].aslist
= NULL
;
6988 /* Process peer route updates. */
6989 peer_on_policy_change(member
, afi
, safi
,
6990 (direct
== FILTER_OUT
) ? 1 : 0);
6996 static void peer_aslist_update(const char *aslist_name
)
7001 struct listnode
*mnode
, *mnnode
;
7002 struct listnode
*node
, *nnode
;
7005 struct peer_group
*group
;
7006 struct bgp_filter
*filter
;
7008 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
7009 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
7010 aslist_name
, true, 0);
7012 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7013 FOREACH_AFI_SAFI (afi
, safi
) {
7014 filter
= &peer
->filter
[afi
][safi
];
7016 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7018 if (filter
->aslist
[direct
].name
)
7019 filter
->aslist
[direct
]
7020 .aslist
= as_list_lookup(
7021 filter
->aslist
[direct
]
7024 filter
->aslist
[direct
].aslist
=
7029 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
7030 FOREACH_AFI_SAFI (afi
, safi
) {
7031 filter
= &group
->conf
->filter
[afi
][safi
];
7033 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
7035 if (filter
->aslist
[direct
].name
)
7036 filter
->aslist
[direct
]
7037 .aslist
= as_list_lookup(
7038 filter
->aslist
[direct
]
7041 filter
->aslist
[direct
].aslist
=
7049 static void peer_aslist_add(char *aslist_name
)
7051 peer_aslist_update(aslist_name
);
7052 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
7055 static void peer_aslist_del(const char *aslist_name
)
7057 peer_aslist_update(aslist_name
);
7058 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
7062 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
7063 const char *name
, struct route_map
*route_map
)
7065 struct peer
*member
;
7066 struct bgp_filter
*filter
;
7067 struct listnode
*node
, *nnode
;
7069 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7070 return BGP_ERR_INVALID_VALUE
;
7072 /* Set configuration on peer. */
7073 filter
= &peer
->filter
[afi
][safi
];
7074 if (filter
->map
[direct
].name
) {
7075 /* If the neighbor is configured with the same route-map
7076 * again then, ignore the duplicate configuration.
7078 if (strcmp(filter
->map
[direct
].name
, name
) == 0)
7081 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7083 route_map_counter_decrement(filter
->map
[direct
].map
);
7084 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7085 filter
->map
[direct
].map
= route_map
;
7086 route_map_counter_increment(route_map
);
7088 /* Check if handling a regular peer. */
7089 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7090 /* Set override-flag and process peer route updates. */
7091 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
7093 peer_on_policy_change(peer
, afi
, safi
,
7094 (direct
== RMAP_OUT
) ? 1 : 0);
7096 /* Skip peer-group mechanics for regular peers. */
7101 * Set configuration on all peer-group members, unless they are
7102 * explicitly overriding peer-group configuration.
7104 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7105 /* Skip peers with overridden configuration. */
7106 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7110 /* Set configuration on peer-group member. */
7111 filter
= &member
->filter
[afi
][safi
];
7112 if (filter
->map
[direct
].name
)
7113 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7114 route_map_counter_decrement(filter
->map
[direct
].map
);
7115 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7116 filter
->map
[direct
].map
= route_map
;
7117 route_map_counter_increment(route_map
);
7119 /* Process peer route updates. */
7120 peer_on_policy_change(member
, afi
, safi
,
7121 (direct
== RMAP_OUT
) ? 1 : 0);
7126 /* Unset route-map from the peer. */
7127 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
7129 struct peer
*member
;
7130 struct bgp_filter
*filter
;
7131 struct listnode
*node
, *nnode
;
7133 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
7134 return BGP_ERR_INVALID_VALUE
;
7136 /* Unset override-flag unconditionally. */
7137 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
7139 /* Inherit configuration from peer-group if peer is member. */
7140 if (peer_group_active(peer
)) {
7141 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7142 filter
[afi
][safi
].map
[direct
].name
,
7143 MTYPE_BGP_FILTER_NAME
);
7144 PEER_ATTR_INHERIT(peer
, peer
->group
,
7145 filter
[afi
][safi
].map
[direct
].map
);
7147 /* Otherwise remove configuration from peer. */
7148 filter
= &peer
->filter
[afi
][safi
];
7149 if (filter
->map
[direct
].name
)
7150 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7151 route_map_counter_decrement(filter
->map
[direct
].map
);
7152 filter
->map
[direct
].name
= NULL
;
7153 filter
->map
[direct
].map
= NULL
;
7156 /* Check if handling a regular peer. */
7157 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7158 /* Process peer route updates. */
7159 peer_on_policy_change(peer
, afi
, safi
,
7160 (direct
== RMAP_OUT
) ? 1 : 0);
7162 /* Skip peer-group mechanics for regular peers. */
7167 * Remove configuration on all peer-group members, unless they are
7168 * explicitly overriding peer-group configuration.
7170 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7171 /* Skip peers with overridden configuration. */
7172 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
7176 /* Remove configuration on peer-group member. */
7177 filter
= &member
->filter
[afi
][safi
];
7178 if (filter
->map
[direct
].name
)
7179 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
7180 route_map_counter_decrement(filter
->map
[direct
].map
);
7181 filter
->map
[direct
].name
= NULL
;
7182 filter
->map
[direct
].map
= NULL
;
7184 /* Process peer route updates. */
7185 peer_on_policy_change(member
, afi
, safi
,
7186 (direct
== RMAP_OUT
) ? 1 : 0);
7192 /* Set unsuppress-map to the peer. */
7193 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7194 const char *name
, struct route_map
*route_map
)
7196 struct peer
*member
;
7197 struct bgp_filter
*filter
;
7198 struct listnode
*node
, *nnode
;
7200 /* Set configuration on peer. */
7201 filter
= &peer
->filter
[afi
][safi
];
7202 if (filter
->usmap
.name
)
7203 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7204 route_map_counter_decrement(filter
->usmap
.map
);
7205 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7206 filter
->usmap
.map
= route_map
;
7207 route_map_counter_increment(route_map
);
7209 /* Check if handling a regular peer. */
7210 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7211 /* Set override-flag and process peer route updates. */
7212 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
7213 PEER_FT_UNSUPPRESS_MAP
);
7214 peer_on_policy_change(peer
, afi
, safi
, 1);
7216 /* Skip peer-group mechanics for regular peers. */
7221 * Set configuration on all peer-group members, unless they are
7222 * explicitly overriding peer-group configuration.
7224 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7225 /* Skip peers with overridden configuration. */
7226 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7227 PEER_FT_UNSUPPRESS_MAP
))
7230 /* Set configuration on peer-group member. */
7231 filter
= &member
->filter
[afi
][safi
];
7232 if (filter
->usmap
.name
)
7233 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7234 route_map_counter_decrement(filter
->usmap
.map
);
7235 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
7236 filter
->usmap
.map
= route_map
;
7237 route_map_counter_increment(route_map
);
7239 /* Process peer route updates. */
7240 peer_on_policy_change(member
, afi
, safi
, 1);
7246 /* Unset route-map from the peer. */
7247 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7249 struct peer
*member
;
7250 struct bgp_filter
*filter
;
7251 struct listnode
*node
, *nnode
;
7253 /* Unset override-flag unconditionally. */
7254 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
7256 /* Inherit configuration from peer-group if peer is member. */
7257 if (peer_group_active(peer
)) {
7258 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
7259 filter
[afi
][safi
].usmap
.name
,
7260 MTYPE_BGP_FILTER_NAME
);
7261 PEER_ATTR_INHERIT(peer
, peer
->group
,
7262 filter
[afi
][safi
].usmap
.map
);
7264 /* Otherwise remove configuration from peer. */
7265 filter
= &peer
->filter
[afi
][safi
];
7266 if (filter
->usmap
.name
)
7267 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7268 route_map_counter_decrement(filter
->usmap
.map
);
7269 filter
->usmap
.name
= NULL
;
7270 filter
->usmap
.map
= NULL
;
7273 /* Check if handling a regular peer. */
7274 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7275 /* Process peer route updates. */
7276 peer_on_policy_change(peer
, afi
, safi
, 1);
7278 /* Skip peer-group mechanics for regular peers. */
7283 * Remove configuration on all peer-group members, unless they are
7284 * explicitly overriding peer-group configuration.
7286 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7287 /* Skip peers with overridden configuration. */
7288 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
7289 PEER_FT_UNSUPPRESS_MAP
))
7292 /* Remove configuration on peer-group member. */
7293 filter
= &member
->filter
[afi
][safi
];
7294 if (filter
->usmap
.name
)
7295 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
7296 route_map_counter_decrement(filter
->usmap
.map
);
7297 filter
->usmap
.name
= NULL
;
7298 filter
->usmap
.map
= NULL
;
7300 /* Process peer route updates. */
7301 peer_on_policy_change(member
, afi
, safi
, 1);
7307 static bool peer_maximum_prefix_clear_overflow(struct peer
*peer
)
7309 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
7312 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
7313 if (peer
->t_pmax_restart
) {
7314 THREAD_OFF(peer
->t_pmax_restart
);
7315 if (bgp_debug_neighbor_events(peer
))
7317 "%pBP Maximum-prefix restart timer cancelled",
7320 BGP_EVENT_ADD(peer
, BGP_Start
);
7324 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7325 uint32_t max
, uint8_t threshold
, int warning
,
7326 uint16_t restart
, bool force
)
7328 struct peer
*member
;
7329 struct listnode
*node
, *nnode
;
7331 /* Set flags and configuration on peer. */
7332 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7335 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7337 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7340 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7342 peer_af_flag_unset(peer
, afi
, safi
,
7343 PEER_FLAG_MAX_PREFIX_WARNING
);
7345 peer
->pmax
[afi
][safi
] = max
;
7346 peer
->pmax_threshold
[afi
][safi
] = threshold
;
7347 peer
->pmax_restart
[afi
][safi
] = restart
;
7349 /* Check if handling a regular peer. */
7350 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7351 /* Re-check if peer violates maximum-prefix. */
7352 if ((peer_established(peer
)) && (peer
->afc
[afi
][safi
]))
7353 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
7355 /* Skip peer-group mechanics for regular peers. */
7360 * Set flags and configuration on all peer-group members, unless they
7361 * are explicitly overriding peer-group configuration.
7363 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7364 /* Skip peers with overridden configuration. */
7365 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7366 PEER_FLAG_MAX_PREFIX
))
7369 /* Set flag and configuration on peer-group member. */
7370 member
->pmax
[afi
][safi
] = max
;
7371 member
->pmax_threshold
[afi
][safi
] = threshold
;
7372 member
->pmax_restart
[afi
][safi
] = restart
;
7375 SET_FLAG(member
->af_flags
[afi
][safi
],
7376 PEER_FLAG_MAX_PREFIX_FORCE
);
7378 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7379 PEER_FLAG_MAX_PREFIX_FORCE
);
7382 SET_FLAG(member
->af_flags
[afi
][safi
],
7383 PEER_FLAG_MAX_PREFIX_WARNING
);
7385 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7386 PEER_FLAG_MAX_PREFIX_WARNING
);
7388 /* Re-check if peer violates maximum-prefix. */
7389 if ((peer_established(member
)) && (member
->afc
[afi
][safi
]))
7390 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
7396 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7398 /* Inherit configuration from peer-group if peer is member. */
7399 if (peer_group_active(peer
)) {
7400 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7401 peer_af_flag_inherit(peer
, afi
, safi
,
7402 PEER_FLAG_MAX_PREFIX_FORCE
);
7403 peer_af_flag_inherit(peer
, afi
, safi
,
7404 PEER_FLAG_MAX_PREFIX_WARNING
);
7405 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
7406 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
7407 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
7412 /* Remove flags and configuration from peer. */
7413 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
7414 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
7415 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
7416 peer
->pmax
[afi
][safi
] = 0;
7417 peer
->pmax_threshold
[afi
][safi
] = 0;
7418 peer
->pmax_restart
[afi
][safi
] = 0;
7421 * Remove flags and configuration from all peer-group members, unless
7422 * they are explicitly overriding peer-group configuration.
7424 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7425 struct peer
*member
;
7426 struct listnode
*node
;
7428 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7429 /* Skip peers with overridden configuration. */
7430 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7431 PEER_FLAG_MAX_PREFIX
))
7434 /* Remove flag and configuration on peer-group member.
7436 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7437 PEER_FLAG_MAX_PREFIX
);
7438 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7439 PEER_FLAG_MAX_PREFIX_FORCE
);
7440 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7441 PEER_FLAG_MAX_PREFIX_WARNING
);
7442 member
->pmax
[afi
][safi
] = 0;
7443 member
->pmax_threshold
[afi
][safi
] = 0;
7444 member
->pmax_restart
[afi
][safi
] = 0;
7446 peer_maximum_prefix_clear_overflow(member
);
7449 peer_maximum_prefix_clear_overflow(peer
);
7455 void peer_maximum_prefix_out_refresh_routes(struct peer
*peer
, afi_t afi
,
7458 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
7460 if (peer_established(peer
))
7461 bgp_announce_route(peer
, afi
, safi
, false);
7464 int peer_maximum_prefix_out_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
7467 struct peer
*member
;
7468 struct listnode
*node
, *nnode
;
7470 /* Set flag on peer and peer-group member if any */
7471 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7472 /* Set configuration on peer. */
7473 peer
->pmax_out
[afi
][safi
] = max
;
7475 /* Check if handling a regular peer. */
7476 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7477 /* Skip peer-group mechanics for regular peers. */
7478 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7483 * Set flag and configuration on all peer-group members, unless they
7484 * are explicitly overriding peer-group configuration.
7486 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
7487 /* Skip peers with overridden configuration. */
7488 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7489 PEER_FLAG_MAX_PREFIX_OUT
))
7492 /* Set configuration on peer-group member. */
7493 member
->pmax_out
[afi
][safi
] = max
;
7495 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7500 int peer_maximum_prefix_out_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
7502 struct peer
*member
;
7503 struct listnode
*node
;
7504 /* Inherit configuration from peer-group if peer is member. */
7505 if (peer_group_active(peer
)) {
7506 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7507 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_out
[afi
][safi
]);
7509 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7513 /* Remove flag and configuration from peer. */
7514 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_OUT
);
7515 peer
->pmax_out
[afi
][safi
] = 0;
7517 /* Check if handling a regular peer. */
7518 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7519 /* Skip peer-group mechanics for regular peers. */
7520 peer_maximum_prefix_out_refresh_routes(peer
, afi
, safi
);
7525 * Remove flag and configuration from all peer-group members, unless
7526 * they are explicitly overriding peer-group configuration.
7528 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
7529 /* Skip peers with overridden configuration. */
7530 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
7531 PEER_FLAG_MAX_PREFIX_OUT
))
7534 /* Remove flag and configuration on peer-group member.
7536 UNSET_FLAG(member
->af_flags
[afi
][safi
],
7537 PEER_FLAG_MAX_PREFIX_OUT
);
7538 member
->pmax_out
[afi
][safi
] = 0;
7540 peer_maximum_prefix_out_refresh_routes(member
, afi
, safi
);
7545 int is_ebgp_multihop_configured(struct peer
*peer
)
7547 struct peer_group
*group
;
7548 struct listnode
*node
, *nnode
;
7551 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7552 group
= peer
->group
;
7553 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7554 && (group
->conf
->ttl
!= BGP_DEFAULT_TTL
))
7557 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
7558 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
7559 && (peer1
->ttl
!= BGP_DEFAULT_TTL
))
7563 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
7564 && (peer
->ttl
!= BGP_DEFAULT_TTL
))
7570 /* Set # of hops between us and BGP peer. */
7571 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
7573 struct peer_group
*group
;
7575 struct listnode
*node
, *nnode
;
7578 zlog_debug("%s: set gtsm_hops to %d for %s", __func__
, gtsm_hops
,
7581 /* We cannot configure ttl-security hops when ebgp-multihop is already
7582 set. For non peer-groups, the check is simple. For peer-groups,
7584 slightly messy, because we need to check both the peer-group
7586 and all peer-group members for any trace of ebgp-multihop
7588 before actually applying the ttl-security rules. Cisco really made a
7589 mess of this configuration parameter, and OpenBGPD got it right.
7592 if ((peer
->gtsm_hops
== BGP_GTSM_HOPS_DISABLED
)
7593 && (peer
->sort
!= BGP_PEER_IBGP
)) {
7594 if (is_ebgp_multihop_configured(peer
))
7595 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
7597 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7598 peer
->gtsm_hops
= gtsm_hops
;
7600 /* Calling ebgp multihop also resets the session.
7601 * On restart, NHT will get setup correctly as will the
7602 * min & max ttls on the socket. The return value is
7605 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
7610 group
= peer
->group
;
7611 group
->conf
->gtsm_hops
= gtsm_hops
;
7612 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7614 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7616 /* Calling ebgp multihop also resets the
7618 * On restart, NHT will get setup correctly as
7620 * min & max ttls on the socket. The return
7624 peer_ebgp_multihop_set(gpeer
, MAXTTL
);
7628 /* Post the first gtsm setup or if its ibgp, maxttl setting
7630 * necessary, just set the minttl.
7632 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7633 peer
->gtsm_hops
= gtsm_hops
;
7636 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7637 MAXTTL
+ 1 - gtsm_hops
);
7638 if ((peer
->status
< Established
) && peer
->doppelganger
7639 && (peer
->doppelganger
->fd
>= 0))
7640 sockopt_minttl(peer
->su
.sa
.sa_family
,
7641 peer
->doppelganger
->fd
,
7642 MAXTTL
+ 1 - gtsm_hops
);
7644 group
= peer
->group
;
7645 group
->conf
->gtsm_hops
= gtsm_hops
;
7646 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
7648 gpeer
->gtsm_hops
= group
->conf
->gtsm_hops
;
7650 /* Change setting of existing peer
7651 * established then change value (may break
7653 * not established yet (teardown session and
7655 * no session then do nothing (will get
7656 * handled by next connection)
7660 != BGP_GTSM_HOPS_DISABLED
)
7662 gpeer
->su
.sa
.sa_family
,
7664 MAXTTL
+ 1 - gpeer
->gtsm_hops
);
7665 if ((gpeer
->status
< Established
)
7666 && gpeer
->doppelganger
7667 && (gpeer
->doppelganger
->fd
>= 0))
7668 sockopt_minttl(gpeer
->su
.sa
.sa_family
,
7669 gpeer
->doppelganger
->fd
,
7670 MAXTTL
+ 1 - gtsm_hops
);
7678 int peer_ttl_security_hops_unset(struct peer
*peer
)
7680 struct peer_group
*group
;
7681 struct listnode
*node
, *nnode
;
7684 zlog_debug("%s: set gtsm_hops to zero for %s", __func__
, peer
->host
);
7686 /* if a peer-group member, then reset to peer-group default rather than
7688 if (peer_group_active(peer
))
7689 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
7691 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7693 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
7694 /* Invoking ebgp_multihop_set will set the TTL back to the
7696 * value as well as restting the NHT and such. The session is
7699 if (peer
->sort
== BGP_PEER_EBGP
)
7700 ret
= peer_ebgp_multihop_unset(peer
);
7703 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
7706 if ((peer
->status
< Established
) && peer
->doppelganger
7707 && (peer
->doppelganger
->fd
>= 0))
7708 sockopt_minttl(peer
->su
.sa
.sa_family
,
7709 peer
->doppelganger
->fd
, 0);
7712 group
= peer
->group
;
7713 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
7714 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
7715 if (peer
->sort
== BGP_PEER_EBGP
)
7716 ret
= peer_ebgp_multihop_unset(peer
);
7719 sockopt_minttl(peer
->su
.sa
.sa_family
,
7722 if ((peer
->status
< Established
)
7723 && peer
->doppelganger
7724 && (peer
->doppelganger
->fd
>= 0))
7725 sockopt_minttl(peer
->su
.sa
.sa_family
,
7726 peer
->doppelganger
->fd
,
7735 static void peer_reset_message_stats(struct peer
*peer
)
7738 atomic_store_explicit(&peer
->open_in
, 0, memory_order_relaxed
);
7739 atomic_store_explicit(&peer
->open_out
, 0, memory_order_relaxed
);
7740 atomic_store_explicit(&peer
->update_in
, 0,
7741 memory_order_relaxed
);
7742 atomic_store_explicit(&peer
->update_out
, 0,
7743 memory_order_relaxed
);
7744 atomic_store_explicit(&peer
->keepalive_in
, 0,
7745 memory_order_relaxed
);
7746 atomic_store_explicit(&peer
->keepalive_out
, 0,
7747 memory_order_relaxed
);
7748 atomic_store_explicit(&peer
->notify_in
, 0,
7749 memory_order_relaxed
);
7750 atomic_store_explicit(&peer
->notify_out
, 0,
7751 memory_order_relaxed
);
7752 atomic_store_explicit(&peer
->refresh_in
, 0,
7753 memory_order_relaxed
);
7754 atomic_store_explicit(&peer
->refresh_out
, 0,
7755 memory_order_relaxed
);
7756 atomic_store_explicit(&peer
->dynamic_cap_in
, 0,
7757 memory_order_relaxed
);
7758 atomic_store_explicit(&peer
->dynamic_cap_out
, 0,
7759 memory_order_relaxed
);
7764 * If peer clear is invoked in a loop for all peers on the BGP instance,
7765 * it may end up freeing the doppelganger, and if this was the next node
7766 * to the current node, we would end up accessing the freed next node.
7767 * Pass along additional parameter which can be updated if next node
7768 * is freed; only required when walking the peer list on BGP instance.
7770 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
7772 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)
7773 || !CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_SHUTDOWN
)) {
7774 if (peer_maximum_prefix_clear_overflow(peer
))
7777 peer
->v_start
= BGP_INIT_START_TIMER
;
7778 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
7779 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7780 BGP_NOTIFY_CEASE_ADMIN_RESET
);
7782 bgp_session_reset_safe(peer
, nnode
);
7787 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
7788 enum bgp_clear_type stype
)
7790 struct peer_af
*paf
;
7792 if (!peer_established(peer
))
7795 if (!peer
->afc
[afi
][safi
])
7796 return BGP_ERR_AF_UNCONFIGURED
;
7798 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
7800 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
7801 /* Clear the "neighbor x.x.x.x default-originate" flag */
7802 paf
= peer_af_find(peer
, afi
, safi
);
7803 if (paf
&& paf
->subgroup
7804 && CHECK_FLAG(paf
->subgroup
->sflags
,
7805 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
7806 UNSET_FLAG(paf
->subgroup
->sflags
,
7807 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
7809 bgp_announce_route(peer
, afi
, safi
, false);
7812 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7813 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7814 PEER_CAP_ORF_PREFIX_SM_ADV
)
7815 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7816 PEER_CAP_ORF_PREFIX_RM_RCV
)
7817 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7818 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
7819 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
7820 uint8_t prefix_type
;
7822 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
7823 PEER_CAP_ORF_PREFIX_RM_RCV
))
7824 prefix_type
= ORF_TYPE_PREFIX
;
7826 prefix_type
= ORF_TYPE_PREFIX_OLD
;
7828 if (filter
->plist
[FILTER_IN
].plist
) {
7829 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7830 PEER_STATUS_ORF_PREFIX_SEND
))
7831 bgp_route_refresh_send(
7832 peer
, afi
, safi
, prefix_type
,
7834 BGP_ROUTE_REFRESH_NORMAL
);
7835 bgp_route_refresh_send(
7836 peer
, afi
, safi
, prefix_type
,
7837 REFRESH_IMMEDIATE
, 0,
7838 BGP_ROUTE_REFRESH_NORMAL
);
7840 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
7841 PEER_STATUS_ORF_PREFIX_SEND
))
7842 bgp_route_refresh_send(
7843 peer
, afi
, safi
, prefix_type
,
7844 REFRESH_IMMEDIATE
, 1,
7845 BGP_ROUTE_REFRESH_NORMAL
);
7847 bgp_route_refresh_send(
7848 peer
, afi
, safi
, 0, 0, 0,
7849 BGP_ROUTE_REFRESH_NORMAL
);
7855 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
7856 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
7857 /* If neighbor has soft reconfiguration inbound flag.
7858 Use Adj-RIB-In database. */
7859 if (!bgp_soft_reconfig_in(peer
, afi
, safi
)) {
7860 /* If neighbor has route refresh capability, send route
7862 message to the peer. */
7863 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
7864 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
7865 bgp_route_refresh_send(
7866 peer
, afi
, safi
, 0, 0, 0,
7867 BGP_ROUTE_REFRESH_NORMAL
);
7869 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
7873 if (stype
== BGP_CLEAR_MESSAGE_STATS
)
7874 peer_reset_message_stats(peer
);
7879 /* Display peer uptime.*/
7880 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, bool use_json
,
7883 time_t uptime1
, epoch_tbuf
;
7886 /* If there is no connection has been done before print `never'. */
7889 json_object_string_add(json
, "peerUptime", "never");
7890 json_object_int_add(json
, "peerUptimeMsec", 0);
7892 snprintf(buf
, len
, "never");
7896 /* Get current time. */
7897 uptime1
= monotime(NULL
);
7899 gmtime_r(&uptime1
, &tm
);
7901 if (uptime1
< ONE_DAY_SECOND
)
7902 snprintf(buf
, len
, "%02d:%02d:%02d", tm
.tm_hour
, tm
.tm_min
,
7904 else if (uptime1
< ONE_WEEK_SECOND
)
7905 snprintf(buf
, len
, "%dd%02dh%02dm", tm
.tm_yday
, tm
.tm_hour
,
7907 else if (uptime1
< ONE_YEAR_SECOND
)
7908 snprintf(buf
, len
, "%02dw%dd%02dh", tm
.tm_yday
/ 7,
7909 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7), tm
.tm_hour
);
7911 snprintf(buf
, len
, "%02dy%02dw%dd", tm
.tm_year
- 70,
7913 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7));
7916 epoch_tbuf
= time(NULL
) - uptime1
;
7917 json_object_string_add(json
, "peerUptime", buf
);
7918 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
7919 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
7926 void bgp_master_init(struct thread_master
*master
, const int buffer_size
,
7927 struct list
*addresses
)
7931 memset(&bgp_master
, 0, sizeof(bgp_master
));
7934 bm
->bgp
= list_new();
7935 bm
->listen_sockets
= list_new();
7936 bm
->port
= BGP_PORT_DEFAULT
;
7937 bm
->addresses
= addresses
;
7938 bm
->master
= master
;
7939 bm
->start_time
= monotime(NULL
);
7940 bm
->t_rmap_update
= NULL
;
7941 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7942 bm
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
7943 bm
->v_establish_wait
= BGP_UPDATE_DELAY_DEF
;
7944 bm
->terminating
= false;
7945 bm
->socket_buffer
= buffer_size
;
7946 bm
->wait_for_fib
= false;
7947 bm
->tcp_dscp
= IPTOS_PREC_INTERNETCONTROL
;
7948 bm
->inq_limit
= BM_DEFAULT_Q_LIMIT
;
7949 bm
->outq_limit
= BM_DEFAULT_Q_LIMIT
;
7952 /* init the rd id space.
7953 assign 0th index in the bitfield,
7954 so that we start with id 1
7956 bf_init(bm
->rd_idspace
, UINT16_MAX
);
7957 bf_assign_zero_index(bm
->rd_idspace
);
7959 /* mpls label dynamic allocation pool */
7960 bgp_lp_init(bm
->master
, &bm
->labelpool
);
7964 QOBJ_REG(bm
, bgp_master
);
7968 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7969 * instance delete (non-default only) or BGP exit.
7971 static void bgp_if_finish(struct bgp
*bgp
)
7974 struct interface
*ifp
;
7976 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
7978 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
7981 FOR_ALL_INTERFACES (vrf
, ifp
) {
7982 struct listnode
*c_node
, *c_nnode
;
7983 struct connected
*c
;
7985 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
7986 bgp_connected_delete(bgp
, c
);
7990 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
7992 struct vrf
*vrf
= NULL
;
7993 struct listnode
*next
;
7996 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
7997 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
7999 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8000 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
8003 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
8007 static void bgp_instasn_autocomplete(vector comps
, struct cmd_token
*token
)
8009 struct listnode
*next
, *next2
;
8010 struct bgp
*bgp
, *bgp2
;
8013 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
8015 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next2
, bgp2
)) {
8016 if (bgp2
->as
== bgp
->as
)
8024 snprintf(buf
, sizeof(buf
), "%u", bgp
->as
);
8025 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, buf
));
8029 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
8030 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
8031 {.varname
= "instasn", .completions
= bgp_instasn_autocomplete
},
8032 {.completions
= NULL
},
8035 struct frr_pthread
*bgp_pth_io
;
8036 struct frr_pthread
*bgp_pth_ka
;
8038 static void bgp_pthreads_init(void)
8040 assert(!bgp_pth_io
);
8041 assert(!bgp_pth_ka
);
8043 struct frr_pthread_attr io
= {
8044 .start
= frr_pthread_attr_default
.start
,
8045 .stop
= frr_pthread_attr_default
.stop
,
8047 struct frr_pthread_attr ka
= {
8048 .start
= bgp_keepalives_start
,
8049 .stop
= bgp_keepalives_stop
,
8051 bgp_pth_io
= frr_pthread_new(&io
, "BGP I/O thread", "bgpd_io");
8052 bgp_pth_ka
= frr_pthread_new(&ka
, "BGP Keepalives thread", "bgpd_ka");
8055 void bgp_pthreads_run(void)
8057 frr_pthread_run(bgp_pth_io
, NULL
);
8058 frr_pthread_run(bgp_pth_ka
, NULL
);
8060 /* Wait until threads are ready. */
8061 frr_pthread_wait_running(bgp_pth_io
);
8062 frr_pthread_wait_running(bgp_pth_ka
);
8065 void bgp_pthreads_finish(void)
8067 frr_pthread_stop_all();
8070 static int peer_unshut_after_cfg(struct bgp
*bgp
)
8072 struct listnode
*node
;
8075 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
8076 if (!peer
->shut_during_cfg
)
8079 if (bgp_debug_neighbor_events(peer
))
8080 zlog_debug("%s: released from config-pending hold",
8083 peer
->shut_during_cfg
= false;
8084 if (peer_active(peer
) && peer
->status
!= Established
) {
8085 if (peer
->status
!= Idle
)
8086 BGP_EVENT_ADD(peer
, BGP_Stop
);
8087 BGP_EVENT_ADD(peer
, BGP_Start
);
8094 void bgp_init(unsigned short instance
)
8096 hook_register(bgp_config_end
, peer_unshut_after_cfg
);
8098 /* allocates some vital data structures used by peer commands in
8101 /* pre-init pthreads */
8102 bgp_pthreads_init();
8105 bgp_zebra_init(bm
->master
, instance
);
8107 #ifdef ENABLE_BGP_VNC
8108 vnc_zebra_init(bm
->master
);
8111 /* BGP VTY commands installation. */
8117 bgp_community_alias_init();
8120 bgp_route_map_init();
8121 bgp_scan_vty_init();
8123 #ifdef ENABLE_BGP_VNC
8126 bgp_ethernetvpn_init();
8127 bgp_flowspec_vty_init();
8129 /* Access list initialize. */
8131 access_list_add_hook(peer_distribute_update
);
8132 access_list_delete_hook(peer_distribute_update
);
8134 /* Filter list initialize. */
8136 as_list_add_hook(peer_aslist_add
);
8137 as_list_delete_hook(peer_aslist_del
);
8139 /* Prefix list initialize.*/
8141 prefix_list_add_hook(peer_prefix_list_update
);
8142 prefix_list_delete_hook(peer_prefix_list_update
);
8144 /* Community list initialize. */
8145 bgp_clist
= community_list_init();
8148 bgp_bfd_init(bm
->master
);
8152 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
8155 void bgp_terminate(void)
8159 struct listnode
*node
, *nnode
;
8160 struct listnode
*mnode
, *mnnode
;
8164 /* Close the listener sockets first as this prevents peers from
8166 * to reconnect on receiving the peer unconfig message. In the presence
8167 * of a large number of peers this will ensure that no peer is left with
8168 * a dangling connection
8172 /* reverse bgp_master_init */
8173 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
8174 bgp_close_vrf_socket(bgp
);
8175 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8176 if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer
)) {
8177 if (bgp_debug_neighbor_events(peer
))
8179 "%pBP configured Graceful-Restart, skipping unconfig notification",
8183 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
8184 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
8185 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
8189 if (bm
->listen_sockets
)
8190 list_delete(&bm
->listen_sockets
);
8192 THREAD_OFF(bm
->t_rmap_update
);
8197 struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
8198 const char *ip_str
, bool use_json
)
8204 /* Get peer sockunion. */
8205 ret
= str2sockunion(ip_str
, &su
);
8207 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
8209 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
8213 json_object
*json_no
= NULL
;
8214 json_no
= json_object_new_object();
8215 json_object_string_add(
8217 "malformedAddressOrName",
8219 vty_json(vty
, json_no
);
8222 "%% Malformed address or name: %s\n",
8230 /* Peer structure lookup. */
8231 peer
= peer_lookup(bgp
, &su
);
8234 json_object
*json_no
= NULL
;
8235 json_no
= json_object_new_object();
8236 json_object_string_add(json_no
, "warning",
8237 "No such neighbor in this view/vrf");
8238 vty_json(vty
, json_no
);
8240 vty_out(vty
, "No such neighbor in this view/vrf\n");
8247 void bgp_gr_apply_running_config(void)
8249 struct peer
*peer
= NULL
;
8250 struct bgp
*bgp
= NULL
;
8251 struct listnode
*node
, *nnode
;
8252 bool gr_router_detected
= false;
8254 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
8255 zlog_debug("[BGP_GR] %s called !", __func__
);
8257 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
8258 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
8259 bgp_peer_gr_flags_update(peer
);
8260 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
))
8261 gr_router_detected
= true;
8264 if (gr_router_detected
8265 && bgp
->present_zebra_gr_state
== ZEBRA_GR_DISABLE
) {
8266 bgp_zebra_send_capabilities(bgp
, true);
8267 } else if (!gr_router_detected
8268 && bgp
->present_zebra_gr_state
== ZEBRA_GR_ENABLE
) {
8269 bgp_zebra_send_capabilities(bgp
, false);
8272 gr_router_detected
= false;
8276 printfrr_ext_autoreg_p("BP", printfrr_bp
);
8277 static ssize_t
printfrr_bp(struct fbuf
*buf
, struct printfrr_eargs
*ea
,
8280 const struct peer
*peer
= ptr
;
8283 return bputs(buf
, "(null)");
8285 return bprintfrr(buf
, "%s(%s)", peer
->host
,
8286 peer
->hostname
? peer
->hostname
: "Unknown");