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 "frr_pthread.h"
49 #include "bgpd/bgpd.h"
50 #include "bgpd/bgp_table.h"
51 #include "bgpd/bgp_aspath.h"
52 #include "bgpd/bgp_route.h"
53 #include "bgpd/bgp_dump.h"
54 #include "bgpd/bgp_debug.h"
55 #include "bgpd/bgp_errors.h"
56 #include "bgpd/bgp_community.h"
57 #include "bgpd/bgp_attr.h"
58 #include "bgpd/bgp_regex.h"
59 #include "bgpd/bgp_clist.h"
60 #include "bgpd/bgp_fsm.h"
61 #include "bgpd/bgp_packet.h"
62 #include "bgpd/bgp_zebra.h"
63 #include "bgpd/bgp_open.h"
64 #include "bgpd/bgp_filter.h"
65 #include "bgpd/bgp_nexthop.h"
66 #include "bgpd/bgp_damp.h"
67 #include "bgpd/bgp_mplsvpn.h"
69 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
70 #include "bgpd/rfapi/rfapi_backend.h"
72 #include "bgpd/bgp_evpn.h"
73 #include "bgpd/bgp_advertise.h"
74 #include "bgpd/bgp_network.h"
75 #include "bgpd/bgp_vty.h"
76 #include "bgpd/bgp_mpath.h"
77 #include "bgpd/bgp_nht.h"
78 #include "bgpd/bgp_updgrp.h"
79 #include "bgpd/bgp_bfd.h"
80 #include "bgpd/bgp_memory.h"
81 #include "bgpd/bgp_evpn_vty.h"
82 #include "bgpd/bgp_keepalives.h"
83 #include "bgpd/bgp_io.h"
84 #include "bgpd/bgp_ecommunity.h"
85 #include "bgpd/bgp_flowspec.h"
86 #include "bgpd/bgp_labelpool.h"
87 #include "bgpd/bgp_pbr.h"
88 #include "bgpd/bgp_addpath.h"
89 #include "bgpd/bgp_evpn_private.h"
90 #include "bgpd/bgp_mac.h"
92 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
93 DEFINE_MTYPE_STATIC(BGPD
, BGP_EVPN_INFO
, "BGP EVPN instance information");
94 DEFINE_QOBJ_TYPE(bgp_master
)
96 DEFINE_QOBJ_TYPE(peer
)
97 DEFINE_HOOK(bgp_inst_delete
, (struct bgp
*bgp
), (bgp
))
99 /* BGP process wide configuration. */
100 static struct bgp_master bgp_master
;
102 /* BGP process wide configuration pointer to export. */
103 struct bgp_master
*bm
;
105 /* BGP community-list. */
106 struct community_list_handler
*bgp_clist
;
108 unsigned int multipath_num
= MULTIPATH_NUM
;
110 static void bgp_if_finish(struct bgp
*bgp
);
111 static void peer_drop_dynamic_neighbor(struct peer
*peer
);
113 extern struct zclient
*zclient
;
115 /* handle main socket creation or deletion */
116 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
118 static int bgp_server_main_created
;
121 if (bgp_server_main_created
)
123 if (bgp_socket(bgp
, bm
->port
, bm
->address
) < 0)
124 return BGP_ERR_INVALID_VALUE
;
125 bgp_server_main_created
= 1;
128 if (!bgp_server_main_created
)
131 bgp_server_main_created
= 0;
135 void bgp_session_reset(struct peer
*peer
)
137 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
138 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
139 peer_delete(peer
->doppelganger
);
141 BGP_EVENT_ADD(peer
, BGP_Stop
);
145 * During session reset, we may delete the doppelganger peer, which would
146 * be the next node to the current node. If the session reset was invoked
147 * during walk of peer list, we would end up accessing the freed next
148 * node. This function moves the next node along.
150 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
155 n
= (nnode
) ? *nnode
: NULL
;
156 npeer
= (n
) ? listgetdata(n
) : NULL
;
158 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
159 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
160 PEER_FLAG_CONFIG_NODE
))) {
161 if (peer
->doppelganger
== npeer
)
162 /* nnode and *nnode are confirmed to be non-NULL here */
163 *nnode
= (*nnode
)->next
;
164 peer_delete(peer
->doppelganger
);
167 BGP_EVENT_ADD(peer
, BGP_Stop
);
170 /* BGP global flag manipulation. */
171 int bgp_option_set(int flag
)
175 case BGP_OPT_NO_LISTEN
:
176 case BGP_OPT_NO_ZEBRA
:
177 SET_FLAG(bm
->options
, flag
);
180 return BGP_ERR_INVALID_FLAG
;
185 int bgp_option_unset(int flag
)
189 case BGP_OPT_NO_ZEBRA
:
191 UNSET_FLAG(bm
->options
, flag
);
194 return BGP_ERR_INVALID_FLAG
;
199 int bgp_option_check(int flag
)
201 return CHECK_FLAG(bm
->options
, flag
);
204 /* Internal function to set BGP structure configureation flag. */
205 static void bgp_config_set(struct bgp
*bgp
, int config
)
207 SET_FLAG(bgp
->config
, config
);
210 static void bgp_config_unset(struct bgp
*bgp
, int config
)
212 UNSET_FLAG(bgp
->config
, config
);
215 static int bgp_config_check(struct bgp
*bgp
, int config
)
217 return CHECK_FLAG(bgp
->config
, config
);
220 /* Set BGP router identifier; distinguish between explicit config and other
223 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
,
227 struct listnode
*node
, *nnode
;
229 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
232 /* EVPN uses router id in RD, withdraw them */
233 if (is_evpn_enabled())
234 bgp_evpn_handle_router_id_update(bgp
, true);
236 vpn_handle_router_id_update(bgp
, true, is_config
);
238 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
240 /* Set all peer's local identifier with this value. */
241 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
242 IPV4_ADDR_COPY(&peer
->local_id
, id
);
244 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
245 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
246 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
247 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
251 /* EVPN uses router id in RD, update them */
252 if (is_evpn_enabled())
253 bgp_evpn_handle_router_id_update(bgp
, false);
255 vpn_handle_router_id_update(bgp
, false, is_config
);
260 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
262 struct listnode
*node
, *nnode
;
264 struct in_addr
*addr
= NULL
;
266 if (router_id
!= NULL
)
267 addr
= (struct in_addr
*)&(router_id
->u
.prefix4
);
269 if (vrf_id
== VRF_DEFAULT
) {
270 /* Router-id change for default VRF has to also update all
272 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
273 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
277 bgp
->router_id_zebra
= *addr
;
279 addr
= &bgp
->router_id_zebra
;
281 if (!bgp
->router_id_static
.s_addr
) {
282 /* Router ID is updated if there are no active
285 if (bgp
->established_peers
== 0) {
286 if (BGP_DEBUG(zebra
, ZEBRA
))
287 zlog_debug("RID change : vrf %u, RTR ID %s",
288 bgp
->vrf_id
, inet_ntoa(*addr
));
289 bgp_router_id_set(bgp
, addr
, false);
294 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
297 bgp
->router_id_zebra
= *addr
;
299 addr
= &bgp
->router_id_zebra
;
301 if (!bgp
->router_id_static
.s_addr
) {
302 /* Router ID is updated if there are no active
305 if (bgp
->established_peers
== 0) {
306 if (BGP_DEBUG(zebra
, ZEBRA
))
307 zlog_debug("RID change : vrf %u, RTR ID %s",
308 bgp
->vrf_id
, inet_ntoa(*addr
));
309 bgp_router_id_set(bgp
, addr
, false);
317 int bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
319 bgp
->router_id_static
= id
;
320 bgp_router_id_set(bgp
,
321 id
.s_addr
!= INADDR_ANY
? &id
: &bgp
->router_id_zebra
,
322 true /* is config */);
326 /* BGP's cluster-id control. */
327 int bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
330 struct listnode
*node
, *nnode
;
332 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
333 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
336 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
337 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
339 /* Clear all IBGP peer. */
340 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
341 if (peer
->sort
!= BGP_PEER_IBGP
)
344 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
345 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
346 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
347 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
353 int bgp_cluster_id_unset(struct bgp
*bgp
)
356 struct listnode
*node
, *nnode
;
358 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
361 bgp
->cluster_id
.s_addr
= 0;
362 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
364 /* Clear all IBGP peer. */
365 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
366 if (peer
->sort
!= BGP_PEER_IBGP
)
369 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
370 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
371 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
372 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
378 /* time_t value that is monotonicly increasing
379 * and uneffected by adjustments to system clock
381 time_t bgp_clock(void)
389 /* BGP timer configuration. */
390 int bgp_timers_set(struct bgp
*bgp
, uint32_t keepalive
, uint32_t holdtime
,
391 uint32_t connect_retry
)
393 bgp
->default_keepalive
=
394 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
395 bgp
->default_holdtime
= holdtime
;
396 bgp
->default_connect_retry
= connect_retry
;
401 /* mostly for completeness - CLI uses its own defaults */
402 int bgp_timers_unset(struct bgp
*bgp
)
404 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
405 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
406 bgp
->default_connect_retry
= BGP_DEFAULT_CONNECT_RETRY
;
411 /* BGP confederation configuration. */
412 int bgp_confederation_id_set(struct bgp
*bgp
, as_t as
)
415 struct listnode
*node
, *nnode
;
419 return BGP_ERR_INVALID_AS
;
421 /* Remember - were we doing confederation before? */
422 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
424 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
426 /* If we were doing confederation already, this is just an external
427 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
428 were not doing confederation before, reset all EBGP sessions. */
429 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
430 /* We're looking for peers who's AS is not local or part of our
432 if (already_confed
) {
433 if (peer_sort(peer
) == BGP_PEER_EBGP
) {
435 if (BGP_IS_VALID_STATE_FOR_NOTIF(
438 PEER_DOWN_CONFED_ID_CHANGE
;
440 peer
, BGP_NOTIFY_CEASE
,
441 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
443 bgp_session_reset_safe(peer
, &nnode
);
446 /* Not doign confederation before, so reset every
449 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
450 /* Reset the local_as to be our EBGP one */
451 if (peer_sort(peer
) == BGP_PEER_EBGP
)
453 if (BGP_IS_VALID_STATE_FOR_NOTIF(
456 PEER_DOWN_CONFED_ID_CHANGE
;
458 peer
, BGP_NOTIFY_CEASE
,
459 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
461 bgp_session_reset_safe(peer
, &nnode
);
468 int bgp_confederation_id_unset(struct bgp
*bgp
)
471 struct listnode
*node
, *nnode
;
474 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
476 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
477 /* We're looking for peers who's AS is not local */
478 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
479 peer
->local_as
= bgp
->as
;
480 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
481 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
482 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
483 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
487 bgp_session_reset_safe(peer
, &nnode
);
493 /* Is an AS part of the confed or not? */
494 int bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
501 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
502 if (bgp
->confed_peers
[i
] == as
)
508 /* Add an AS to the confederation set. */
509 int bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
)
512 struct listnode
*node
, *nnode
;
515 return BGP_ERR_INVALID_BGP
;
518 return BGP_ERR_INVALID_AS
;
520 if (bgp_confederation_peers_check(bgp
, as
))
523 if (bgp
->confed_peers
)
525 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
526 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
529 XMALLOC(MTYPE_BGP_CONFED_LIST
,
530 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
532 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
533 bgp
->confed_peers_cnt
++;
535 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
536 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
537 if (peer
->as
== as
) {
538 peer
->local_as
= bgp
->as
;
539 if (BGP_IS_VALID_STATE_FOR_NOTIF(
542 PEER_DOWN_CONFED_PEER_CHANGE
;
544 peer
, BGP_NOTIFY_CEASE
,
545 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
547 bgp_session_reset_safe(peer
, &nnode
);
554 /* Delete an AS from the confederation set. */
555 int bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
560 struct listnode
*node
, *nnode
;
565 if (!bgp_confederation_peers_check(bgp
, as
))
568 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
569 if (bgp
->confed_peers
[i
] == as
)
570 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
571 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
573 bgp
->confed_peers_cnt
--;
575 if (bgp
->confed_peers_cnt
== 0) {
576 if (bgp
->confed_peers
)
577 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
578 bgp
->confed_peers
= NULL
;
581 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
582 bgp
->confed_peers_cnt
* sizeof(as_t
));
584 /* Now reset any peer who's remote AS has just been removed from the
586 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
587 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
588 if (peer
->as
== as
) {
589 peer
->local_as
= bgp
->confed_id
;
590 if (BGP_IS_VALID_STATE_FOR_NOTIF(
593 PEER_DOWN_CONFED_PEER_CHANGE
;
595 peer
, BGP_NOTIFY_CEASE
,
596 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
598 bgp_session_reset_safe(peer
, &nnode
);
606 /* Local preference configuration. */
607 int bgp_default_local_preference_set(struct bgp
*bgp
, uint32_t local_pref
)
612 bgp
->default_local_pref
= local_pref
;
617 int bgp_default_local_preference_unset(struct bgp
*bgp
)
622 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
627 /* Local preference configuration. */
628 int bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
, uint32_t queue_size
)
633 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
638 int bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
642 bgp
->default_subgroup_pkt_queue_max
=
643 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
648 /* Listen limit configuration. */
649 int bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
654 bgp
->dynamic_neighbors_limit
= listen_limit
;
659 int bgp_listen_limit_unset(struct bgp
*bgp
)
664 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
669 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
670 afi_t
*afi
, safi_t
*safi
)
672 /* Map from IANA values to internal values, return error if
673 * values are unrecognized.
675 *afi
= afi_iana2int(pkt_afi
);
676 *safi
= safi_iana2int(pkt_safi
);
677 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
683 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
684 iana_safi_t
*pkt_safi
)
686 /* Map from internal values to IANA values, return error if
687 * internal values are bad (unexpected).
689 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
691 *pkt_afi
= afi_int2iana(afi
);
692 *pkt_safi
= safi_int2iana(safi
);
696 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
705 afid
= afindex(afi
, safi
);
706 if (afid
>= BGP_AF_MAX
)
710 assert(peer
->peer_af_array
[afid
] == NULL
);
712 /* Allocate new peer af */
713 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
715 peer
->peer_af_array
[afid
] = af
;
720 bgp
->af_peer_count
[afi
][safi
]++;
725 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
732 afid
= afindex(afi
, safi
);
733 if (afid
>= BGP_AF_MAX
)
736 return peer
->peer_af_array
[afid
];
739 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
748 afid
= afindex(afi
, safi
);
749 if (afid
>= BGP_AF_MAX
)
752 af
= peer
->peer_af_array
[afid
];
757 bgp_stop_announce_route_timer(af
);
759 if (PAF_SUBGRP(af
)) {
760 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
761 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
762 af
->subgroup
->update_group
->id
,
763 af
->subgroup
->id
, peer
->host
);
767 update_subgroup_remove_peer(af
->subgroup
, af
);
769 if (bgp
->af_peer_count
[afi
][safi
])
770 bgp
->af_peer_count
[afi
][safi
]--;
772 peer
->peer_af_array
[afid
] = NULL
;
773 XFREE(MTYPE_BGP_PEER_AF
, af
);
777 /* Peer comparison function for sorting. */
778 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
780 if (p1
->group
&& !p2
->group
)
783 if (!p1
->group
&& p2
->group
)
786 if (p1
->group
== p2
->group
) {
787 if (p1
->conf_if
&& !p2
->conf_if
)
790 if (!p1
->conf_if
&& p2
->conf_if
)
793 if (p1
->conf_if
&& p2
->conf_if
)
794 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
796 return strcmp(p1
->group
->name
, p2
->group
->name
);
798 return sockunion_cmp(&p1
->su
, &p2
->su
);
801 static unsigned int peer_hash_key_make(const void *p
)
803 const struct peer
*peer
= p
;
804 return sockunion_hash(&peer
->su
);
807 static bool peer_hash_same(const void *p1
, const void *p2
)
809 const struct peer
*peer1
= p1
;
810 const struct peer
*peer2
= p2
;
811 return (sockunion_same(&peer1
->su
, &peer2
->su
)
812 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
813 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
816 void peer_flag_inherit(struct peer
*peer
, uint32_t flag
)
820 /* Skip if peer is not a peer-group member. */
821 if (!peer_group_active(peer
))
824 /* Unset override flag to signal inheritance from peer-group. */
825 UNSET_FLAG(peer
->flags_override
, flag
);
828 * Inherit flag state from peer-group. If the flag of the peer-group is
829 * not being inverted, the peer must inherit the inverse of the current
830 * peer-group flag state.
832 group_val
= CHECK_FLAG(peer
->group
->conf
->flags
, flag
);
833 if (!CHECK_FLAG(peer
->group
->conf
->flags_invert
, flag
)
834 && CHECK_FLAG(peer
->flags_invert
, flag
))
835 COND_FLAG(peer
->flags
, flag
, !group_val
);
837 COND_FLAG(peer
->flags
, flag
, group_val
);
840 int peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
842 return CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
845 void peer_af_flag_inherit(struct peer
*peer
, afi_t afi
, safi_t safi
,
850 /* Skip if peer is not a peer-group member. */
851 if (!peer_group_active(peer
))
854 /* Unset override flag to signal inheritance from peer-group. */
855 UNSET_FLAG(peer
->af_flags_override
[afi
][safi
], flag
);
858 * Inherit flag state from peer-group. If the flag of the peer-group is
859 * not being inverted, the peer must inherit the inverse of the current
860 * peer-group flag state.
862 group_val
= CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
], flag
);
863 if (!CHECK_FLAG(peer
->group
->conf
->af_flags_invert
[afi
][safi
], flag
)
864 && CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
865 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, !group_val
);
867 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, group_val
);
870 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
871 static inline bgp_peer_sort_t
peer_calc_sort(struct peer
*peer
)
878 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
879 if (peer
->as_type
== AS_INTERNAL
)
880 return BGP_PEER_IBGP
;
882 else if (peer
->as_type
== AS_EXTERNAL
)
883 return BGP_PEER_EBGP
;
885 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
) {
887 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
895 peer1
= listnode_head(peer
->group
->peer
);
900 return BGP_PEER_INTERNAL
;
904 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
905 if (peer
->local_as
== 0)
906 return BGP_PEER_INTERNAL
;
908 if (peer
->local_as
== peer
->as
) {
909 if (bgp
->as
== bgp
->confed_id
) {
910 if (peer
->local_as
== bgp
->as
)
911 return BGP_PEER_IBGP
;
913 return BGP_PEER_EBGP
;
915 if (peer
->local_as
== bgp
->confed_id
)
916 return BGP_PEER_EBGP
;
918 return BGP_PEER_IBGP
;
922 if (bgp_confederation_peers_check(bgp
, peer
->as
))
923 return BGP_PEER_CONFED
;
925 return BGP_PEER_EBGP
;
927 if (peer
->as_type
== AS_UNSPECIFIED
) {
928 /* check if in peer-group with AS information */
930 && (peer
->group
->conf
->as_type
!= AS_UNSPECIFIED
)) {
931 if (peer
->group
->conf
->as_type
934 == peer
->group
->conf
->as
)
935 return BGP_PEER_IBGP
;
937 return BGP_PEER_EBGP
;
938 } else if (peer
->group
->conf
->as_type
940 return BGP_PEER_IBGP
;
942 return BGP_PEER_EBGP
;
944 /* no AS information anywhere, let caller know */
945 return BGP_PEER_UNSPECIFIED
;
946 } else if (peer
->as_type
!= AS_SPECIFIED
)
947 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
950 return (peer
->local_as
== 0
952 : peer
->local_as
== peer
->as
? BGP_PEER_IBGP
957 /* Calculate and cache the peer "sort" */
958 bgp_peer_sort_t
peer_sort(struct peer
*peer
)
960 peer
->sort
= peer_calc_sort(peer
);
964 static void peer_free(struct peer
*peer
)
969 assert(peer
->status
== Deleted
);
973 /* this /ought/ to have been done already through bgp_stop earlier,
974 * but just to be sure..
978 bgp_writes_off(peer
);
979 assert(!peer
->t_write
);
980 assert(!peer
->t_read
);
981 BGP_EVENT_FLUSH(peer
);
983 pthread_mutex_destroy(&peer
->io_mtx
);
985 /* Free connected nexthop, if present */
986 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
987 && !peer_dynamic_neighbor(peer
))
988 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
991 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
993 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
994 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
995 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
996 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
998 /* Update source configuration. */
999 if (peer
->update_source
) {
1000 sockunion_free(peer
->update_source
);
1001 peer
->update_source
= NULL
;
1004 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1006 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1007 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1009 if (peer
->clear_node_queue
)
1010 work_queue_free_and_null(&peer
->clear_node_queue
);
1012 bgp_sync_delete(peer
);
1014 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1016 bfd_info_free(&(peer
->bfd_info
));
1018 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
1019 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
1020 bgp_addpath_set_peer_type(peer
, afi
, safi
,
1025 bgp_unlock(peer
->bgp
);
1027 memset(peer
, 0, sizeof(struct peer
));
1029 XFREE(MTYPE_BGP_PEER
, peer
);
1032 /* increase reference count on a struct peer */
1033 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1035 assert(peer
&& (peer
->lock
>= 0));
1038 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1046 /* decrease reference count on a struct peer
1047 * struct peer is freed and NULL returned if last reference
1049 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1051 assert(peer
&& (peer
->lock
> 0));
1054 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1059 if (peer
->lock
== 0) {
1066 /* BGP GR changes */
1068 int bgp_global_gr_init(struct bgp
*bgp
)
1070 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1071 zlog_debug("%s called ..", __func__
);
1073 int local_GLOBAL_GR_FSM
[BGP_GLOBAL_GR_MODE
][BGP_GLOBAL_GR_EVENT_CMD
] = {
1074 /* GLOBAL_HELPER Mode */
1077 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1078 GLOBAL_GR
, GLOBAL_INVALID
,
1079 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1080 GLOBAL_DISABLE
, GLOBAL_INVALID
1082 /* GLOBAL_GR Mode */
1085 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1086 GLOBAL_INVALID
, GLOBAL_HELPER
,
1087 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1088 GLOBAL_DISABLE
, GLOBAL_INVALID
1090 /* GLOBAL_DISABLE Mode */
1093 /*GLOBAL_GR_cmd */ /*no_Global_GR_cmd*/
1094 GLOBAL_GR
, GLOBAL_INVALID
,
1095 /*GLOBAL_DISABLE_cmd*//*no_Global_Disable_cmd*/
1096 GLOBAL_INVALID
, GLOBAL_HELPER
1098 /* GLOBAL_INVALID Mode */
1101 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1102 GLOBAL_INVALID
, GLOBAL_INVALID
,
1103 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1104 GLOBAL_INVALID
, GLOBAL_INVALID
1107 memcpy(bgp
->GLOBAL_GR_FSM
, local_GLOBAL_GR_FSM
,
1108 sizeof(local_GLOBAL_GR_FSM
));
1110 bgp
->global_gr_present_state
= GLOBAL_HELPER
;
1111 bgp
->present_zebra_gr_state
= ZEBRA_GR_DISABLE
;
1113 return BGP_GR_SUCCESS
;
1116 int bgp_peer_gr_init(struct peer
*peer
)
1118 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1119 zlog_debug("%s called ..", __func__
);
1121 struct bgp_peer_gr local_Peer_GR_FSM
[BGP_PEER_GR_MODE
]
1122 [BGP_PEER_GR_EVENT_CMD
] = {
1124 /* PEER_HELPER Mode */
1125 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1126 { PEER_GR
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1127 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1128 {PEER_DISABLE
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1129 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1130 { PEER_INVALID
, NULL
}, {PEER_GLOBAL_INHERIT
,
1131 bgp_peer_gr_action
}
1135 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1136 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1137 bgp_peer_gr_action
},
1138 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1139 {PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1140 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1141 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1144 /* PEER_DISABLE Mode */
1145 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1146 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1147 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1148 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1149 bgp_peer_gr_action
},
1150 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1151 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1154 /* PEER_INVALID Mode */
1155 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1156 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1157 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1158 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1159 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1160 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1163 /* PEER_GLOBAL_INHERIT Mode */
1164 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1165 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1166 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1167 { PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1168 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1169 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1172 memcpy(&peer
->PEER_GR_FSM
, local_Peer_GR_FSM
,
1173 sizeof(local_Peer_GR_FSM
));
1174 peer
->peer_gr_present_state
= PEER_GLOBAL_INHERIT
;
1175 bgp_peer_move_to_gr_mode(peer
, PEER_GLOBAL_INHERIT
);
1177 return BGP_GR_SUCCESS
;
1180 /* Allocate new peer object, implicitely locked. */
1181 struct peer
*peer_new(struct bgp
*bgp
)
1188 /* bgp argument is absolutely required */
1193 /* Allocate new peer. */
1194 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1196 /* Set default value. */
1198 peer
->v_start
= BGP_INIT_START_TIMER
;
1199 peer
->v_connect
= bgp
->default_connect_retry
;
1200 peer
->status
= Idle
;
1201 peer
->ostatus
= Idle
;
1202 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1203 peer
->bgp
= bgp_lock(bgp
);
1204 peer
= peer_lock(peer
); /* initial reference */
1205 peer
->password
= NULL
;
1207 /* Set default flags. */
1208 FOREACH_AFI_SAFI (afi
, safi
) {
1209 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1210 SET_FLAG(peer
->af_flags
[afi
][safi
],
1211 PEER_FLAG_SEND_EXT_COMMUNITY
);
1212 SET_FLAG(peer
->af_flags
[afi
][safi
],
1213 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1215 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1216 PEER_FLAG_SEND_COMMUNITY
);
1217 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1218 PEER_FLAG_SEND_EXT_COMMUNITY
);
1219 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1220 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1221 peer
->addpath_type
[afi
][safi
] = BGP_ADDPATH_NONE
;
1224 /* set nexthop-unchanged for l2vpn evpn by default */
1225 SET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1226 PEER_FLAG_NEXTHOP_UNCHANGED
);
1228 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1230 /* Initialize per peer bgp GR FSM */
1231 bgp_peer_gr_init(peer
);
1233 /* Create buffers. */
1234 peer
->ibuf
= stream_fifo_new();
1235 peer
->obuf
= stream_fifo_new();
1236 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1238 /* We use a larger buffer for peer->obuf_work in the event that:
1239 * - We RX a BGP_UPDATE where the attributes alone are just
1240 * under BGP_MAX_PACKET_SIZE
1241 * - The user configures an outbound route-map that does many as-path
1242 * prepends or adds many communities. At most they can have
1243 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1244 * large they can make the attributes.
1246 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1247 * bounds checking for every single attribute as we construct an
1251 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1253 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1255 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1257 bgp_sync_init(peer
);
1259 /* Get service port number. */
1260 sp
= getservbyname("bgp", "tcp");
1261 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1263 QOBJ_REG(peer
, peer
);
1268 * This function is invoked when a duplicate peer structure associated with
1269 * a neighbor is being deleted. If this about-to-be-deleted structure is
1270 * the one with all the config, then we have to copy over the info.
1272 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1274 struct peer_af
*paf
;
1282 /* The following function is used by both peer group config copy to
1283 * individual peer and when we transfer config
1285 if (peer_src
->change_local_as
)
1286 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1288 /* peer flags apply */
1289 peer_dst
->flags
= peer_src
->flags
;
1290 peer_dst
->cap
= peer_src
->cap
;
1292 peer_dst
->peer_gr_present_state
= peer_src
->peer_gr_present_state
;
1293 peer_dst
->peer_gr_new_status_flag
= peer_src
->peer_gr_new_status_flag
;
1295 peer_dst
->local_as
= peer_src
->local_as
;
1296 peer_dst
->port
= peer_src
->port
;
1297 (void)peer_sort(peer_dst
);
1298 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1301 peer_dst
->holdtime
= peer_src
->holdtime
;
1302 peer_dst
->keepalive
= peer_src
->keepalive
;
1303 peer_dst
->connect
= peer_src
->connect
;
1304 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1305 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1306 peer_dst
->routeadv
= peer_src
->routeadv
;
1307 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1309 /* password apply */
1310 if (peer_src
->password
&& !peer_dst
->password
)
1311 peer_dst
->password
=
1312 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1314 FOREACH_AFI_SAFI (afi
, safi
) {
1315 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1316 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1317 peer_dst
->allowas_in
[afi
][safi
] =
1318 peer_src
->allowas_in
[afi
][safi
];
1319 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1320 peer_dst
->addpath_type
[afi
][safi
] =
1321 peer_src
->addpath_type
[afi
][safi
];
1324 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1325 paf
= peer_src
->peer_af_array
[afidx
];
1327 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1330 /* update-source apply */
1331 if (peer_src
->update_source
) {
1332 if (peer_dst
->update_source
)
1333 sockunion_free(peer_dst
->update_source
);
1334 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1335 peer_dst
->update_source
=
1336 sockunion_dup(peer_src
->update_source
);
1337 } else if (peer_src
->update_if
) {
1338 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1339 if (peer_dst
->update_source
) {
1340 sockunion_free(peer_dst
->update_source
);
1341 peer_dst
->update_source
= NULL
;
1343 peer_dst
->update_if
=
1344 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1347 if (peer_src
->ifname
) {
1348 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1351 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1355 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1356 struct interface
*ifp
)
1358 struct connected
*ifc
;
1361 struct listnode
*node
;
1363 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1364 * IPv4 address of the other end.
1366 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1367 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1368 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1369 if (p
.prefixlen
== 30) {
1370 peer
->su
.sa
.sa_family
= AF_INET
;
1371 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1373 peer
->su
.sin
.sin_addr
.s_addr
=
1375 else if (addr
% 4 == 2)
1376 peer
->su
.sin
.sin_addr
.s_addr
=
1378 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1379 peer
->su
.sin
.sin_len
=
1380 sizeof(struct sockaddr_in
);
1381 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1383 } else if (p
.prefixlen
== 31) {
1384 peer
->su
.sa
.sa_family
= AF_INET
;
1385 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1387 peer
->su
.sin
.sin_addr
.s_addr
=
1390 peer
->su
.sin
.sin_addr
.s_addr
=
1392 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1393 peer
->su
.sin
.sin_len
=
1394 sizeof(struct sockaddr_in
);
1395 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1397 } else if (bgp_debug_neighbor_events(peer
))
1399 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1407 static int bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1408 struct interface
*ifp
)
1410 struct nbr_connected
*ifc_nbr
;
1412 /* Have we learnt the peer's IPv6 link-local address? */
1413 if (ifp
->nbr_connected
1414 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1415 peer
->su
.sa
.sa_family
= AF_INET6
;
1416 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1417 sizeof(struct in6_addr
));
1419 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1421 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1429 * Set or reset the peer address socketunion structure based on the
1430 * learnt/derived peer address. If the address has changed, update the
1431 * password on the listen socket, if needed.
1433 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1435 struct interface
*ifp
;
1437 int peer_addr_updated
= 0;
1443 * Our peer structure is stored in the bgp->peerhash
1444 * release it before we modify anything.
1446 hash_release(peer
->bgp
->peerhash
, peer
);
1448 prev_family
= peer
->su
.sa
.sa_family
;
1449 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1451 /* If BGP unnumbered is not "v6only", we first see if we can
1453 * peer's IPv4 address.
1455 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1457 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1459 /* If "v6only" or we can't derive peer's IPv4 address, see if
1461 * learnt the peer's IPv6 link-local address. This is from the
1463 * IPv6 address in router advertisement.
1465 if (!peer_addr_updated
)
1467 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1469 /* If we could derive the peer address, we may need to install the
1471 * configured for the peer, if any, on the listen socket. Otherwise,
1473 * that peer's address is not available and uninstall the password, if
1476 if (peer_addr_updated
) {
1477 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1478 && prev_family
== AF_UNSPEC
)
1481 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1482 && prev_family
!= AF_UNSPEC
)
1483 bgp_md5_unset(peer
);
1484 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1485 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1489 * Since our su changed we need to del/add peer to the peerhash
1491 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1494 static void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
,
1497 struct bgp_node
*rn
, *nrn
;
1498 struct bgp_table
*table
;
1500 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
1501 rn
= bgp_route_next(rn
)) {
1502 table
= bgp_node_get_bgp_table_info(rn
);
1503 if (table
!= NULL
) {
1504 /* Special handling for 2-level routing
1506 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1507 || safi
== SAFI_EVPN
) {
1508 for (nrn
= bgp_table_top(table
);
1509 nrn
; nrn
= bgp_route_next(nrn
))
1510 bgp_process(bgp
, nrn
, afi
, safi
);
1512 bgp_process(bgp
, rn
, afi
, safi
);
1517 /* Force a bestpath recalculation for all prefixes. This is used
1518 * when 'bgp bestpath' commands are entered.
1520 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1525 FOREACH_AFI_SAFI (afi
, safi
) {
1526 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1531 * Create new BGP peer.
1533 * conf_if and su are mutually exclusive if configuring from the cli.
1534 * If we are handing a doppelganger, then we *must* pass in both
1535 * the original peer's su and conf_if, so that we can appropriately
1536 * track the bgp->peerhash( ie we don't want to remove the current
1537 * one from the config ).
1539 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1540 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1541 int as_type
, afi_t afi
, safi_t safi
,
1542 struct peer_group
*group
)
1546 char buf
[SU_ADDRSTRLEN
];
1548 peer
= peer_new(bgp
);
1550 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1554 bgp_peer_conf_if_to_su_update(peer
);
1555 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1556 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1559 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1560 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1561 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1563 peer
->local_as
= local_as
;
1564 peer
->as
= remote_as
;
1565 peer
->as_type
= as_type
;
1566 peer
->local_id
= bgp
->router_id
;
1567 peer
->v_holdtime
= bgp
->default_holdtime
;
1568 peer
->v_keepalive
= bgp
->default_keepalive
;
1569 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1570 ? BGP_DEFAULT_IBGP_ROUTEADV
1571 : BGP_DEFAULT_EBGP_ROUTEADV
;
1573 peer
= peer_lock(peer
); /* bgp peer list reference */
1574 peer
->group
= group
;
1575 listnode_add_sort(bgp
->peer
, peer
);
1576 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1578 /* Adjust update-group coalesce timer heuristics for # peers. */
1579 if (bgp
->heuristic_coalesce
) {
1580 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1582 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1583 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1586 active
= peer_active(peer
);
1588 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
)
1589 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1591 peer
->last_reset
= PEER_DOWN_NOAFI_ACTIVATED
;
1594 /* Last read and reset time set */
1595 peer
->readtime
= peer
->resettime
= bgp_clock();
1597 /* Default TTL set. */
1598 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: BGP_DEFAULT_TTL
;
1600 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1603 peer
->afc
[afi
][safi
] = 1;
1604 peer_af_create(peer
, afi
, safi
);
1607 /* auto shutdown if configured */
1608 if (bgp
->autoshutdown
)
1609 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1610 /* Set up peer's events and timers. */
1611 else if (!active
&& peer_active(peer
))
1612 bgp_timer_set(peer
);
1614 bgp_peer_gr_flags_update(peer
);
1615 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp
, bgp
->peer
);
1620 /* Make accept BGP peer. This function is only called from the test code */
1621 struct peer
*peer_create_accept(struct bgp
*bgp
)
1625 peer
= peer_new(bgp
);
1627 peer
= peer_lock(peer
); /* bgp peer list reference */
1628 listnode_add_sort(bgp
->peer
, peer
);
1634 * Return true if we have a peer configured to use this afi/safi
1636 int bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1638 struct listnode
*node
;
1641 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1642 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1645 if (peer
->afc
[afi
][safi
])
1652 /* Change peer's AS number. */
1653 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
)
1655 bgp_peer_sort_t type
;
1658 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1659 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1660 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1661 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1662 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1664 bgp_session_reset(peer
);
1666 type
= peer_sort(peer
);
1668 peer
->as_type
= as_specified
;
1670 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1671 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1672 && peer
->bgp
->as
!= as
)
1673 peer
->local_as
= peer
->bgp
->confed_id
;
1675 peer
->local_as
= peer
->bgp
->as
;
1677 /* Advertisement-interval reset */
1678 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1679 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1680 ? BGP_DEFAULT_IBGP_ROUTEADV
1681 : BGP_DEFAULT_EBGP_ROUTEADV
;
1685 if (peer_sort(peer
) == BGP_PEER_IBGP
)
1687 else if (type
== BGP_PEER_IBGP
)
1688 peer
->ttl
= BGP_DEFAULT_TTL
;
1690 /* reflector-client reset */
1691 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
1692 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1693 PEER_FLAG_REFLECTOR_CLIENT
);
1694 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1695 PEER_FLAG_REFLECTOR_CLIENT
);
1696 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1697 PEER_FLAG_REFLECTOR_CLIENT
);
1698 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1699 PEER_FLAG_REFLECTOR_CLIENT
);
1700 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1701 PEER_FLAG_REFLECTOR_CLIENT
);
1702 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1703 PEER_FLAG_REFLECTOR_CLIENT
);
1704 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1705 PEER_FLAG_REFLECTOR_CLIENT
);
1706 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1707 PEER_FLAG_REFLECTOR_CLIENT
);
1708 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1709 PEER_FLAG_REFLECTOR_CLIENT
);
1710 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1711 PEER_FLAG_REFLECTOR_CLIENT
);
1712 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1713 PEER_FLAG_REFLECTOR_CLIENT
);
1714 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1715 PEER_FLAG_REFLECTOR_CLIENT
);
1716 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1717 PEER_FLAG_REFLECTOR_CLIENT
);
1720 /* local-as reset */
1721 if (peer_sort(peer
) != BGP_PEER_EBGP
) {
1722 peer
->change_local_as
= 0;
1723 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
1724 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1725 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1729 /* If peer does not exist, create new one. If peer already exists,
1730 set AS number to the peer. */
1731 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1732 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1738 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1740 peer
= peer_lookup(bgp
, su
);
1743 /* Not allowed for a dynamic peer. */
1744 if (peer_dynamic_neighbor(peer
)) {
1746 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1749 /* When this peer is a member of peer-group. */
1751 /* peer-group already has AS number/internal/external */
1752 if (peer
->group
->conf
->as
1753 || peer
->group
->conf
->as_type
) {
1754 /* Return peer group's AS number. */
1755 *as
= peer
->group
->conf
->as
;
1756 return BGP_ERR_PEER_GROUP_MEMBER
;
1759 bgp_peer_sort_t peer_sort_type
=
1760 peer_sort(peer
->group
->conf
);
1762 /* Explicit AS numbers used, compare AS numbers */
1763 if (as_type
== AS_SPECIFIED
) {
1764 if (((peer_sort_type
== BGP_PEER_IBGP
)
1765 && (bgp
->as
!= *as
))
1766 || ((peer_sort_type
== BGP_PEER_EBGP
)
1767 && (bgp
->as
== *as
))) {
1769 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1772 /* internal/external used, compare as-types */
1773 if (((peer_sort_type
== BGP_PEER_IBGP
)
1774 && (as_type
!= AS_INTERNAL
))
1775 || ((peer_sort_type
== BGP_PEER_EBGP
)
1776 && (as_type
!= AS_EXTERNAL
))) {
1778 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1783 /* Existing peer's AS number change. */
1784 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
1785 || (peer
->as_type
!= as_type
))
1786 peer_as_change(peer
, *as
, as_type
);
1789 return BGP_ERR_NO_INTERFACE_CONFIG
;
1791 /* If the peer is not part of our confederation, and its not an
1792 iBGP peer then spoof the source AS */
1793 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)
1794 && !bgp_confederation_peers_check(bgp
, *as
)
1796 local_as
= bgp
->confed_id
;
1800 /* If this is IPv4 unicast configuration and "no bgp default
1801 ipv4-unicast" is specified. */
1803 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_DEFAULT_IPV4
)
1804 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1805 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0,
1808 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
,
1815 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
1816 struct peer
*peer
, afi_t afi
,
1820 int out
= FILTER_OUT
;
1822 uint32_t pflags_ovrd
;
1823 uint8_t *pfilter_ovrd
;
1827 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
1828 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
1830 /* peer af_flags apply */
1831 flags_tmp
= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
1832 flags_tmp
^= conf
->af_flags_invert
[afi
][safi
]
1833 ^ peer
->af_flags_invert
[afi
][safi
];
1834 flags_tmp
&= ~pflags_ovrd
;
1836 UNSET_FLAG(peer
->af_flags
[afi
][safi
], ~pflags_ovrd
);
1837 SET_FLAG(peer
->af_flags
[afi
][safi
], flags_tmp
);
1838 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1839 conf
->af_flags_invert
[afi
][safi
]);
1841 /* maximum-prefix */
1842 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
1843 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
1844 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
1845 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
1849 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
1850 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
1853 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
1854 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
1856 /* default-originate route-map */
1857 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
1858 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
1859 MTYPE_ROUTE_MAP_NAME
);
1860 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
1863 /* inbound filter apply */
1864 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
1865 PEER_STR_ATTR_INHERIT(peer
, group
,
1866 filter
[afi
][safi
].dlist
[in
].name
,
1867 MTYPE_BGP_FILTER_NAME
);
1868 PEER_ATTR_INHERIT(peer
, group
,
1869 filter
[afi
][safi
].dlist
[in
].alist
);
1872 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
1873 PEER_STR_ATTR_INHERIT(peer
, group
,
1874 filter
[afi
][safi
].plist
[in
].name
,
1875 MTYPE_BGP_FILTER_NAME
);
1876 PEER_ATTR_INHERIT(peer
, group
,
1877 filter
[afi
][safi
].plist
[in
].plist
);
1880 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
1881 PEER_STR_ATTR_INHERIT(peer
, group
,
1882 filter
[afi
][safi
].aslist
[in
].name
,
1883 MTYPE_BGP_FILTER_NAME
);
1884 PEER_ATTR_INHERIT(peer
, group
,
1885 filter
[afi
][safi
].aslist
[in
].aslist
);
1888 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
1889 PEER_STR_ATTR_INHERIT(peer
, group
,
1890 filter
[afi
][safi
].map
[in
].name
,
1891 MTYPE_BGP_FILTER_NAME
);
1892 PEER_ATTR_INHERIT(peer
, group
,
1893 filter
[afi
][safi
].map
[RMAP_IN
].map
);
1896 /* outbound filter apply */
1897 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
1898 PEER_STR_ATTR_INHERIT(peer
, group
,
1899 filter
[afi
][safi
].dlist
[out
].name
,
1900 MTYPE_BGP_FILTER_NAME
);
1901 PEER_ATTR_INHERIT(peer
, group
,
1902 filter
[afi
][safi
].dlist
[out
].alist
);
1905 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
1906 PEER_STR_ATTR_INHERIT(peer
, group
,
1907 filter
[afi
][safi
].plist
[out
].name
,
1908 MTYPE_BGP_FILTER_NAME
);
1909 PEER_ATTR_INHERIT(peer
, group
,
1910 filter
[afi
][safi
].plist
[out
].plist
);
1913 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
1914 PEER_STR_ATTR_INHERIT(peer
, group
,
1915 filter
[afi
][safi
].aslist
[out
].name
,
1916 MTYPE_BGP_FILTER_NAME
);
1917 PEER_ATTR_INHERIT(peer
, group
,
1918 filter
[afi
][safi
].aslist
[out
].aslist
);
1921 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
1922 PEER_STR_ATTR_INHERIT(peer
, group
,
1923 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
1924 MTYPE_BGP_FILTER_NAME
);
1925 PEER_ATTR_INHERIT(peer
, group
,
1926 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
1929 /* nondirectional filter apply */
1930 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
1931 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
1932 MTYPE_BGP_FILTER_NAME
);
1933 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
1936 if (peer
->addpath_type
[afi
][safi
] == BGP_ADDPATH_NONE
) {
1937 peer
->addpath_type
[afi
][safi
] = conf
->addpath_type
[afi
][safi
];
1938 bgp_addpath_type_changed(conf
->bgp
);
1942 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
1947 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1948 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
1949 __func__
, peer
->host
);
1953 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
1955 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1956 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1957 return BGP_ERR_PEER_SAFI_CONFLICT
;
1959 /* Nothing to do if we've already activated this peer */
1960 if (peer
->afc
[afi
][safi
])
1963 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1966 active
= peer_active(peer
);
1967 peer
->afc
[afi
][safi
] = 1;
1970 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
1972 if (!active
&& peer_active(peer
)) {
1973 bgp_timer_set(peer
);
1975 if (peer
->status
== Established
) {
1976 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
1977 peer
->afc_adv
[afi
][safi
] = 1;
1978 bgp_capability_send(peer
, afi
, safi
,
1980 CAPABILITY_ACTION_SET
);
1981 if (peer
->afc_recv
[afi
][safi
]) {
1982 peer
->afc_nego
[afi
][safi
] = 1;
1983 bgp_announce_route(peer
, afi
, safi
);
1986 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1987 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1988 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1991 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
1992 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1993 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1994 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1997 * If we are turning on a AFI/SAFI locally and we've
1998 * started bringing a peer up, we need to tell
1999 * the other peer to restart because we might loose
2000 * configuration here because when the doppelganger
2001 * gets to a established state due to how
2002 * we resolve we could just overwrite the afi/safi
2005 other
= peer
->doppelganger
;
2007 && (other
->status
== OpenSent
2008 || other
->status
== OpenConfirm
)) {
2009 other
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2010 bgp_notify_send(other
, BGP_NOTIFY_CEASE
,
2011 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2018 /* Activate the peer or peer group for specified AFI and SAFI. */
2019 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2022 struct peer_group
*group
;
2023 struct listnode
*node
, *nnode
;
2024 struct peer
*tmp_peer
;
2027 /* Nothing to do if we've already activated this peer */
2028 if (peer
->afc
[afi
][safi
])
2033 /* This is a peer-group so activate all of the members of the
2034 * peer-group as well */
2035 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2037 /* Do not activate a peer for both SAFI_UNICAST and
2038 * SAFI_LABELED_UNICAST */
2039 if ((safi
== SAFI_UNICAST
2040 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2041 || (safi
== SAFI_LABELED_UNICAST
2042 && peer
->afc
[afi
][SAFI_UNICAST
]))
2043 return BGP_ERR_PEER_SAFI_CONFLICT
;
2045 peer
->afc
[afi
][safi
] = 1;
2046 group
= peer
->group
;
2048 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2049 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2052 ret
|= peer_activate_af(peer
, afi
, safi
);
2055 /* If this is the first peer to be activated for this
2056 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2057 if (safi
== SAFI_LABELED_UNICAST
2058 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2060 if (BGP_DEBUG(zebra
, ZEBRA
))
2062 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2064 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2065 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2068 if (safi
== SAFI_FLOWSPEC
) {
2069 /* connect to table manager */
2070 bgp_zebra_init_tm_connect(bgp
);
2075 static int non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2078 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2079 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2080 __func__
, peer
->host
);
2084 /* Nothing to do if we've already deactivated this peer */
2085 if (!peer
->afc
[afi
][safi
])
2088 /* De-activate the address family configuration. */
2089 peer
->afc
[afi
][safi
] = 0;
2091 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2092 flog_err(EC_BGP_PEER_DELETE
,
2093 "couldn't delete af structure for peer %s",
2098 if (peer
->status
== Established
) {
2099 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2100 peer
->afc_adv
[afi
][safi
] = 0;
2101 peer
->afc_nego
[afi
][safi
] = 0;
2103 if (peer_active_nego(peer
)) {
2104 bgp_capability_send(peer
, afi
, safi
,
2106 CAPABILITY_ACTION_UNSET
);
2107 bgp_clear_route(peer
, afi
, safi
);
2108 peer
->pcount
[afi
][safi
] = 0;
2110 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2111 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2112 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2115 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2116 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2117 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2124 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2127 struct peer_group
*group
;
2128 struct peer
*tmp_peer
;
2129 struct listnode
*node
, *nnode
;
2132 /* Nothing to do if we've already de-activated this peer */
2133 if (!peer
->afc
[afi
][safi
])
2136 /* This is a peer-group so de-activate all of the members of the
2137 * peer-group as well */
2138 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2139 peer
->afc
[afi
][safi
] = 0;
2140 group
= peer
->group
;
2142 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2143 flog_err(EC_BGP_PEER_DELETE
,
2144 "couldn't delete af structure for peer %s",
2148 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2149 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2152 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2157 /* If this is the last peer to be deactivated for this
2158 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2159 if (safi
== SAFI_LABELED_UNICAST
2160 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2161 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2163 if (BGP_DEBUG(zebra
, ZEBRA
))
2165 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2167 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2168 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2173 int peer_afc_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
2176 return peer_activate(peer
, afi
, safi
);
2178 return peer_deactivate(peer
, afi
, safi
);
2181 void peer_nsf_stop(struct peer
*peer
)
2186 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2187 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2189 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2190 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
2191 peer
->nsf
[afi
][safi
] = 0;
2193 if (peer
->t_gr_restart
) {
2194 BGP_TIMER_OFF(peer
->t_gr_restart
);
2195 if (bgp_debug_neighbor_events(peer
))
2196 zlog_debug("%s graceful restart timer stopped",
2199 if (peer
->t_gr_stale
) {
2200 BGP_TIMER_OFF(peer
->t_gr_stale
);
2201 if (bgp_debug_neighbor_events(peer
))
2203 "%s graceful restart stalepath timer stopped",
2206 bgp_clear_route_all(peer
);
2209 /* Delete peer from confguration.
2211 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2212 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2214 * This function /should/ take care to be idempotent, to guard against
2215 * it being called multiple times through stray events that come in
2216 * that happen to result in this function being called again. That
2217 * said, getting here for a "Deleted" peer is a bug in the neighbour
2220 int peer_delete(struct peer
*peer
)
2226 struct bgp_filter
*filter
;
2227 struct listnode
*pn
;
2230 assert(peer
->status
!= Deleted
);
2233 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2235 bgp_keepalives_off(peer
);
2236 bgp_reads_off(peer
);
2237 bgp_writes_off(peer
);
2238 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2239 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2240 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_KEEPALIVES_ON
));
2242 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2243 peer_nsf_stop(peer
);
2245 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2247 bgp_bfd_deregister_peer(peer
);
2249 /* If this peer belongs to peer group, clear up the
2252 if (peer_dynamic_neighbor(peer
))
2253 peer_drop_dynamic_neighbor(peer
);
2255 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2257 peer
); /* group->peer list reference */
2258 list_delete_node(peer
->group
->peer
, pn
);
2263 /* Withdraw all information from routing table. We can not use
2264 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2265 * executed after peer structure is deleted.
2267 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2269 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2271 if (peer
->doppelganger
) {
2272 peer
->doppelganger
->doppelganger
= NULL
;
2273 peer
->doppelganger
= NULL
;
2276 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2277 bgp_fsm_change_status(peer
, Deleted
);
2279 /* Remove from NHT */
2280 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2281 bgp_unlink_nexthop_by_peer(peer
);
2283 /* Password configuration */
2284 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)) {
2285 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2287 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2288 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
2289 bgp_md5_unset(peer
);
2292 bgp_timer_set(peer
); /* stops all timers for Deleted */
2294 /* Delete from all peer list. */
2295 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2296 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2297 peer_unlock(peer
); /* bgp peer list reference */
2298 list_delete_node(bgp
->peer
, pn
);
2299 hash_release(bgp
->peerhash
, peer
);
2304 stream_fifo_free(peer
->ibuf
);
2309 stream_fifo_free(peer
->obuf
);
2313 if (peer
->ibuf_work
) {
2314 ringbuf_del(peer
->ibuf_work
);
2315 peer
->ibuf_work
= NULL
;
2318 if (peer
->obuf_work
) {
2319 stream_free(peer
->obuf_work
);
2320 peer
->obuf_work
= NULL
;
2323 if (peer
->scratch
) {
2324 stream_free(peer
->scratch
);
2325 peer
->scratch
= NULL
;
2328 /* Local and remote addresses. */
2329 if (peer
->su_local
) {
2330 sockunion_free(peer
->su_local
);
2331 peer
->su_local
= NULL
;
2334 if (peer
->su_remote
) {
2335 sockunion_free(peer
->su_remote
);
2336 peer
->su_remote
= NULL
;
2339 /* Free filter related memory. */
2340 FOREACH_AFI_SAFI (afi
, safi
) {
2341 filter
= &peer
->filter
[afi
][safi
];
2343 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2344 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2345 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2346 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2349 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2350 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2353 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2354 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2357 FOREACH_AFI_SAFI (afi
, safi
)
2358 peer_af_delete(peer
, afi
, safi
);
2360 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2361 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2363 peer_unlock(peer
); /* initial reference */
2368 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2370 return strcmp(g1
->name
, g2
->name
);
2373 /* Peer group cofiguration. */
2374 static struct peer_group
*peer_group_new(void)
2376 return XCALLOC(MTYPE_PEER_GROUP
, sizeof(struct peer_group
));
2379 static void peer_group_free(struct peer_group
*group
)
2381 XFREE(MTYPE_PEER_GROUP
, group
);
2384 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2386 struct peer_group
*group
;
2387 struct listnode
*node
, *nnode
;
2389 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2390 if (strcmp(group
->name
, name
) == 0)
2396 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2398 struct peer_group
*group
;
2401 group
= peer_group_lookup(bgp
, name
);
2405 group
= peer_group_new();
2407 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2408 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2409 group
->peer
= list_new();
2410 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2411 group
->listen_range
[afi
] = list_new();
2412 group
->conf
= peer_new(bgp
);
2413 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_DEFAULT_IPV4
))
2414 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2415 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2416 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2417 group
->conf
->group
= group
;
2418 group
->conf
->as
= 0;
2419 group
->conf
->ttl
= BGP_DEFAULT_TTL
;
2420 group
->conf
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
2421 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2422 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2423 listnode_add_sort(bgp
->group
, group
);
2428 static void peer_group2peer_config_copy(struct peer_group
*group
,
2438 peer
->as
= conf
->as
;
2441 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_LOCAL_AS
))
2442 peer
->change_local_as
= conf
->change_local_as
;
2444 /* If peer-group has configured TTL then override it */
2445 if (conf
->ttl
!= BGP_DEFAULT_TTL
)
2446 peer
->ttl
= conf
->ttl
;
2449 peer
->gtsm_hops
= conf
->gtsm_hops
;
2451 /* peer flags apply */
2452 flags_tmp
= conf
->flags
& ~peer
->flags_override
;
2453 flags_tmp
^= conf
->flags_invert
^ peer
->flags_invert
;
2454 flags_tmp
&= ~peer
->flags_override
;
2456 UNSET_FLAG(peer
->flags
, ~peer
->flags_override
);
2457 SET_FLAG(peer
->flags
, flags_tmp
);
2458 SET_FLAG(peer
->flags_invert
, conf
->flags_invert
);
2460 /* peer timers apply */
2461 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2462 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2463 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2466 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2467 PEER_ATTR_INHERIT(peer
, group
, connect
);
2468 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2469 peer
->v_connect
= conf
->connect
;
2471 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
2474 /* advertisement-interval apply */
2475 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2476 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2477 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2478 peer
->v_routeadv
= conf
->routeadv
;
2480 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2481 ? BGP_DEFAULT_IBGP_ROUTEADV
2482 : BGP_DEFAULT_EBGP_ROUTEADV
;
2485 /* password apply */
2486 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_PASSWORD
))
2487 PEER_STR_ATTR_INHERIT(peer
, group
, password
,
2488 MTYPE_PEER_PASSWORD
);
2490 if (!BGP_PEER_SU_UNSPEC(peer
))
2493 /* update-source apply */
2494 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_UPDATE_SOURCE
)) {
2495 if (conf
->update_source
) {
2496 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2497 PEER_SU_ATTR_INHERIT(peer
, group
, update_source
);
2498 } else if (conf
->update_if
) {
2499 sockunion_free(peer
->update_source
);
2500 PEER_STR_ATTR_INHERIT(peer
, group
, update_if
,
2501 MTYPE_PEER_UPDATE_SOURCE
);
2505 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2508 /* Peer group's remote AS configuration. */
2509 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2512 struct peer_group
*group
;
2514 struct listnode
*node
, *nnode
;
2516 group
= peer_group_lookup(bgp
, group_name
);
2520 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2524 /* When we setup peer-group AS number all peer group member's AS
2525 number must be updated to same number. */
2526 peer_as_change(group
->conf
, *as
, as_type
);
2528 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2529 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2530 || (peer
->as_type
!= as_type
))
2531 peer_as_change(peer
, *as
, as_type
);
2537 int peer_notify_unconfig(struct peer
*peer
)
2539 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2540 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2541 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
2545 int peer_group_notify_unconfig(struct peer_group
*group
)
2547 struct peer
*peer
, *other
;
2548 struct listnode
*node
, *nnode
;
2550 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2551 other
= peer
->doppelganger
;
2552 if (other
&& other
->status
!= Deleted
) {
2553 other
->group
= NULL
;
2554 peer_notify_unconfig(other
);
2556 peer_notify_unconfig(peer
);
2561 int peer_group_delete(struct peer_group
*group
)
2565 struct prefix
*prefix
;
2567 struct listnode
*node
, *nnode
;
2572 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2573 other
= peer
->doppelganger
;
2575 if (other
&& other
->status
!= Deleted
) {
2576 other
->group
= NULL
;
2580 list_delete(&group
->peer
);
2582 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2583 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2585 prefix_free(&prefix
);
2587 list_delete(&group
->listen_range
[afi
]);
2590 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2593 bfd_info_free(&(group
->conf
->bfd_info
));
2595 group
->conf
->group
= NULL
;
2596 peer_delete(group
->conf
);
2598 /* Delete from all peer_group list. */
2599 listnode_delete(bgp
->group
, group
);
2601 peer_group_free(group
);
2606 int peer_group_remote_as_delete(struct peer_group
*group
)
2608 struct peer
*peer
, *other
;
2609 struct listnode
*node
, *nnode
;
2611 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2612 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2615 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2616 other
= peer
->doppelganger
;
2620 if (other
&& other
->status
!= Deleted
) {
2621 other
->group
= NULL
;
2625 list_delete_all_node(group
->peer
);
2627 group
->conf
->as
= 0;
2628 group
->conf
->as_type
= AS_UNSPECIFIED
;
2633 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2635 struct prefix
*prefix
;
2636 struct listnode
*node
, *nnode
;
2639 afi
= family2afi(range
->family
);
2641 /* Group needs remote AS configured. */
2642 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2643 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2645 /* Ensure no duplicates. Currently we don't care about overlaps. */
2646 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2647 if (prefix_same(range
, prefix
))
2651 prefix
= prefix_new();
2652 prefix_copy(prefix
, range
);
2653 listnode_add(group
->listen_range
[afi
], prefix
);
2655 /* Update passwords for new ranges */
2656 if (group
->conf
->password
)
2657 bgp_md5_set_prefix(prefix
, group
->conf
->password
);
2662 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
2664 struct prefix
*prefix
, prefix2
;
2665 struct listnode
*node
, *nnode
;
2668 char buf
[PREFIX2STR_BUFFER
];
2670 afi
= family2afi(range
->family
);
2672 /* Identify the listen range. */
2673 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2674 if (prefix_same(range
, prefix
))
2679 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2681 prefix2str(prefix
, buf
, sizeof(buf
));
2683 /* Dispose off any dynamic neighbors that exist due to this listen range
2685 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2686 if (!peer_dynamic_neighbor(peer
))
2689 sockunion2hostprefix(&peer
->su
, &prefix2
);
2690 if (prefix_match(prefix
, &prefix2
)) {
2691 if (bgp_debug_neighbor_events(peer
))
2693 "Deleting dynamic neighbor %s group %s upon "
2694 "delete of listen range %s",
2695 peer
->host
, group
->name
, buf
);
2700 /* Get rid of the listen range */
2701 listnode_delete(group
->listen_range
[afi
], prefix
);
2703 /* Remove passwords for deleted ranges */
2704 if (group
->conf
->password
)
2705 bgp_md5_unset_prefix(prefix
);
2710 /* Bind specified peer to peer group. */
2711 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2712 struct peer_group
*group
, as_t
*as
)
2714 int first_member
= 0;
2718 /* Lookup the peer. */
2720 peer
= peer_lookup(bgp
, su
);
2722 /* The peer exist, bind it to the peer-group */
2724 /* When the peer already belongs to a peer-group, check the
2726 if (peer_group_active(peer
)) {
2728 /* The peer is already bound to the peer-group,
2731 if (strcmp(peer
->group
->name
, group
->name
) == 0)
2734 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2737 /* The peer has not specified a remote-as, inherit it from the
2739 if (peer
->as_type
== AS_UNSPECIFIED
) {
2740 peer
->as_type
= group
->conf
->as_type
;
2741 peer
->as
= group
->conf
->as
;
2742 peer
->sort
= group
->conf
->sort
;
2745 if (!group
->conf
->as
&& peer_sort(peer
)) {
2746 if (peer_sort(group
->conf
) != BGP_PEER_INTERNAL
2747 && peer_sort(group
->conf
) != peer_sort(peer
)) {
2750 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2753 if (peer_sort(group
->conf
) == BGP_PEER_INTERNAL
)
2757 peer_group2peer_config_copy(group
, peer
);
2759 FOREACH_AFI_SAFI (afi
, safi
) {
2760 if (group
->conf
->afc
[afi
][safi
]) {
2761 peer
->afc
[afi
][safi
] = 1;
2763 if (peer_af_find(peer
, afi
, safi
)
2764 || peer_af_create(peer
, afi
, safi
)) {
2765 peer_group2peer_config_copy_af(
2766 group
, peer
, afi
, safi
);
2768 } else if (peer
->afc
[afi
][safi
])
2769 peer_deactivate(peer
, afi
, safi
);
2773 assert(group
&& peer
->group
== group
);
2775 listnode_delete(bgp
->peer
, peer
);
2777 peer
->group
= group
;
2778 listnode_add_sort(bgp
->peer
, peer
);
2780 peer
= peer_lock(peer
); /* group->peer list reference */
2781 listnode_add(group
->peer
, peer
);
2785 /* Advertisement-interval reset */
2786 if (!CHECK_FLAG(group
->conf
->flags
,
2787 PEER_FLAG_ROUTEADV
)) {
2788 group
->conf
->v_routeadv
=
2789 (peer_sort(group
->conf
)
2791 ? BGP_DEFAULT_IBGP_ROUTEADV
2792 : BGP_DEFAULT_EBGP_ROUTEADV
;
2795 /* ebgp-multihop reset */
2796 if (peer_sort(group
->conf
) == BGP_PEER_IBGP
)
2797 group
->conf
->ttl
= MAXTTL
;
2799 /* local-as reset */
2800 if (peer_sort(group
->conf
) != BGP_PEER_EBGP
) {
2801 group
->conf
->change_local_as
= 0;
2802 peer_flag_unset(group
->conf
,
2803 PEER_FLAG_LOCAL_AS
);
2804 peer_flag_unset(group
->conf
,
2805 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2806 peer_flag_unset(group
->conf
,
2807 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2811 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2813 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2814 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2815 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2816 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2818 bgp_session_reset(peer
);
2822 /* Create a new peer. */
2824 if ((group
->conf
->as_type
== AS_SPECIFIED
)
2825 && (!group
->conf
->as
)) {
2826 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2829 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
2830 group
->conf
->as_type
, 0, 0, group
);
2832 peer
= peer_lock(peer
); /* group->peer list reference */
2833 listnode_add(group
->peer
, peer
);
2835 peer_group2peer_config_copy(group
, peer
);
2837 /* If the peer-group is active for this afi/safi then activate
2839 FOREACH_AFI_SAFI (afi
, safi
) {
2840 if (group
->conf
->afc
[afi
][safi
]) {
2841 peer
->afc
[afi
][safi
] = 1;
2842 peer_af_create(peer
, afi
, safi
);
2843 peer_group2peer_config_copy_af(group
, peer
, afi
,
2845 } else if (peer
->afc
[afi
][safi
])
2846 peer_deactivate(peer
, afi
, safi
);
2849 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2851 /* Set up peer's events and timers. */
2852 if (peer_active(peer
))
2853 bgp_timer_set(peer
);
2859 static int bgp_startup_timer_expire(struct thread
*thread
)
2863 bgp
= THREAD_ARG(thread
);
2864 bgp
->t_startup
= NULL
;
2870 * On shutdown we call the cleanup function which
2871 * does a free of the link list nodes, free up
2872 * the data we are pointing at too.
2874 static void bgp_vrf_string_name_delete(void *data
)
2878 XFREE(MTYPE_TMP
, vname
);
2881 /* BGP instance creation by `router bgp' commands. */
2882 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
2883 enum bgp_instance_type inst_type
)
2889 if ((bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
))) == NULL
)
2892 if (BGP_DEBUG(zebra
, ZEBRA
)) {
2893 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2894 zlog_debug("Creating Default VRF, AS %u", *as
);
2896 zlog_debug("Creating %s %s, AS %u",
2897 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
2903 /* Default the EVPN VRF to the default one */
2904 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
&& !bgp_master
.bgp_evpn
) {
2910 bgp
->heuristic_coalesce
= true;
2911 bgp
->inst_type
= inst_type
;
2912 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
2914 bgp
->peer_self
= peer_new(bgp
);
2915 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2916 bgp
->peer_self
->host
=
2917 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2918 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
2919 if (cmd_hostname_get())
2920 bgp
->peer_self
->hostname
=
2921 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
2923 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
2924 if (cmd_domainname_get())
2925 bgp
->peer_self
->domainname
=
2926 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
2927 bgp
->peer
= list_new();
2928 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
2929 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
2931 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
2933 bgp
->group
= list_new();
2934 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
2936 FOREACH_AFI_SAFI (afi
, safi
) {
2937 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2938 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2939 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2941 /* Enable maximum-paths */
2942 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
2944 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
2946 /* Initialize graceful restart info */
2947 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
2948 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
2949 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
2950 bgp
->gr_info
[afi
][safi
].t_route_select
= NULL
;
2951 bgp
->gr_info
[afi
][safi
].route_list
= list_new();
2954 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2955 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2956 bgp
->default_subgroup_pkt_queue_max
=
2957 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2958 bgp_timers_unset(bgp
);
2959 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2960 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2961 bgp
->select_defer_time
= BGP_DEFAULT_SELECT_DEFERRAL_TIME
;
2962 bgp
->rib_stale_time
= BGP_DEFAULT_RIB_STALE_TIME
;
2963 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2964 bgp
->dynamic_neighbors_count
= 0;
2965 bgp
->ebgp_requires_policy
= DEFAULT_EBGP_POLICY_DISABLED
;
2966 bgp
->reject_as_sets
= BGP_REJECT_AS_SETS_DISABLED
;
2967 bgp_addpath_init_bgp_data(&bgp
->tx_addpath
);
2972 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
2973 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2975 assert(bgp
->rfapi_cfg
);
2977 #endif /* ENABLE_BGP_VNC */
2979 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2980 bgp
->vpn_policy
[afi
].bgp
= bgp
;
2981 bgp
->vpn_policy
[afi
].afi
= afi
;
2982 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
2983 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
2986 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
2987 bgp
->vpn_policy
[afi
].import_vrf
->del
=
2988 bgp_vrf_string_name_delete
;
2989 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
2990 bgp
->vpn_policy
[afi
].export_vrf
->del
=
2991 bgp_vrf_string_name_delete
;
2994 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2996 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
2997 bgp
->restart_time
, &bgp
->t_startup
);
2999 /* printable name we can use in debug messages */
3000 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3001 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3011 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3013 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3014 snprintf(bgp
->name_pretty
, len
, "%s %s",
3015 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3021 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3022 memory_order_relaxed
);
3023 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3024 memory_order_relaxed
);
3025 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3029 update_bgp_group_init(bgp
);
3031 /* assign a unique rd id for auto derivation of vrf's RD */
3032 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3034 bgp
->evpn_info
= XCALLOC(MTYPE_BGP_EVPN_INFO
,
3035 sizeof(struct bgp_evpn_info
));
3040 /*initilize global GR FSM */
3041 bgp_global_gr_init(bgp
);
3045 /* Return the "default VRF" instance of BGP. */
3046 struct bgp
*bgp_get_default(void)
3049 struct listnode
*node
, *nnode
;
3051 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3052 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3057 /* Lookup BGP entry. */
3058 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3061 struct listnode
*node
, *nnode
;
3063 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3065 && ((bgp
->name
== NULL
&& name
== NULL
)
3066 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3071 /* Lookup BGP structure by view name. */
3072 struct bgp
*bgp_lookup_by_name(const char *name
)
3075 struct listnode
*node
, *nnode
;
3077 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3078 if ((bgp
->name
== NULL
&& name
== NULL
)
3079 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3084 /* Lookup BGP instance based on VRF id. */
3085 /* Note: Only to be used for incoming messages from Zebra. */
3086 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3090 /* Lookup VRF (in tree) and follow link. */
3091 vrf
= vrf_lookup_by_id(vrf_id
);
3094 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3097 /* Sets the BGP instance where EVPN is enabled */
3098 void bgp_set_evpn(struct bgp
*bgp
)
3100 if (bm
->bgp_evpn
== bgp
)
3103 /* First, release the reference count we hold on the instance */
3105 bgp_unlock(bm
->bgp_evpn
);
3109 /* Increase the reference count on this new VRF */
3111 bgp_lock(bm
->bgp_evpn
);
3114 /* Returns the BGP instance where EVPN is enabled, if any */
3115 struct bgp
*bgp_get_evpn(void)
3117 return bm
->bgp_evpn
;
3120 /* handle socket creation or deletion, if necessary
3121 * this is called for all new BGP instances
3123 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3128 /* Create BGP server socket, if listen mode not disabled */
3129 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3131 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3133 * suppress vrf socket
3135 if (create
== false) {
3136 bgp_close_vrf_socket(bgp
);
3140 return BGP_ERR_INVALID_VALUE
;
3142 * if vrf_id did not change
3144 if (vrf
->vrf_id
== old_vrf_id
)
3146 if (old_vrf_id
!= VRF_UNKNOWN
) {
3147 /* look for old socket. close it. */
3148 bgp_close_vrf_socket(bgp
);
3150 /* if backend is not yet identified ( VRF_UNKNOWN) then
3151 * creation will be done later
3153 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3155 ret
= bgp_socket(bgp
, bm
->port
, bm
->address
);
3157 return BGP_ERR_INVALID_VALUE
;
3160 return bgp_check_main_socket(create
, bgp
);
3163 /* Called from VTY commands. */
3164 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3165 enum bgp_instance_type inst_type
)
3168 struct vrf
*vrf
= NULL
;
3170 /* Multiple instance check. */
3172 bgp
= bgp_lookup_by_name(name
);
3174 bgp
= bgp_get_default();
3176 /* Already exists. */
3178 if (bgp
->as
!= *as
) {
3180 return BGP_ERR_INSTANCE_MISMATCH
;
3182 if (bgp
->inst_type
!= inst_type
)
3183 return BGP_ERR_INSTANCE_MISMATCH
;
3188 bgp
= bgp_create(as
, name
, inst_type
);
3189 if (bgp_option_check(BGP_OPT_NO_ZEBRA
) && name
)
3190 bgp
->vrf_id
= vrf_generate_id();
3191 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
, true);
3192 bgp_address_init(bgp
);
3193 bgp_tip_hash_init(bgp
);
3197 bgp
->t_rmap_def_originate_eval
= NULL
;
3199 /* If Default instance or VRF, link to the VRF structure, if present. */
3200 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3201 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3202 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3204 bgp_vrf_link(bgp
, vrf
);
3206 /* BGP server socket already processed if BGP instance
3207 * already part of the list
3209 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3210 listnode_add(bm
->bgp
, bgp
);
3212 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3213 if (BGP_DEBUG(zebra
, ZEBRA
))
3214 zlog_debug("%s: Registering BGP instance %s to zebra",
3215 __PRETTY_FUNCTION__
, name
);
3216 bgp_zebra_instance_register(bgp
);
3223 * Make BGP instance "up". Applies only to VRFs (non-default) and
3224 * implies the VRF has been learnt from Zebra.
3226 void bgp_instance_up(struct bgp
*bgp
)
3229 struct listnode
*node
, *next
;
3231 /* Register with zebra. */
3232 bgp_zebra_instance_register(bgp
);
3234 /* Kick off any peers that may have been configured. */
3235 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3236 if (!BGP_PEER_START_SUPPRESSED(peer
))
3237 BGP_EVENT_ADD(peer
, BGP_Start
);
3240 /* Process any networks that have been configured. */
3241 bgp_static_add(bgp
);
3245 * Make BGP instance "down". Applies only to VRFs (non-default) and
3246 * implies the VRF has been deleted by Zebra.
3248 void bgp_instance_down(struct bgp
*bgp
)
3251 struct listnode
*node
;
3252 struct listnode
*next
;
3255 if (bgp
->t_rmap_def_originate_eval
) {
3256 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3257 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3261 /* Bring down peers, so corresponding routes are purged. */
3262 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3263 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3264 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3265 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3267 bgp_session_reset(peer
);
3270 /* Purge network and redistributed routes. */
3271 bgp_purge_static_redist_routes(bgp
);
3273 /* Cleanup registered nexthops (flags) */
3274 bgp_cleanup_nexthops(bgp
);
3277 /* Delete BGP instance. */
3278 int bgp_delete(struct bgp
*bgp
)
3281 struct peer_group
*group
;
3282 struct listnode
*node
, *next
;
3287 struct graceful_restart_info
*gr_info
;
3291 hook_call(bgp_inst_delete
, bgp
);
3293 THREAD_OFF(bgp
->t_startup
);
3294 THREAD_OFF(bgp
->t_maxmed_onstartup
);
3295 THREAD_OFF(bgp
->t_update_delay
);
3296 THREAD_OFF(bgp
->t_establish_wait
);
3298 /* Set flag indicating bgp instance delete in progress */
3299 SET_FLAG(bgp
->flags
, BGP_FLAG_DELETE_IN_PROGRESS
);
3301 /* Delete the graceful restart info */
3302 FOREACH_AFI_SAFI (afi
, safi
) {
3303 gr_info
= &bgp
->gr_info
[afi
][safi
];
3307 BGP_TIMER_OFF(gr_info
->t_select_deferral
);
3308 BGP_TIMER_OFF(gr_info
->t_route_select
);
3309 if (gr_info
->route_list
)
3310 list_delete(&gr_info
->route_list
);
3313 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3314 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3315 zlog_debug("Deleting Default VRF");
3317 zlog_debug("Deleting %s %s",
3318 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3324 /* unmap from RT list */
3325 bgp_evpn_vrf_delete(bgp
);
3327 /* unmap bgp vrf label */
3328 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP
);
3329 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP6
);
3332 if (bgp
->t_rmap_def_originate_eval
) {
3333 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3334 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3338 /* Inform peers we're going down. */
3339 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3340 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3341 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3342 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3345 /* Delete static routes (networks). */
3346 bgp_static_delete(bgp
);
3348 /* Unset redistribution. */
3349 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3350 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3351 if (i
!= ZEBRA_ROUTE_BGP
)
3352 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3354 /* Free peers and peer-groups. */
3355 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3356 peer_group_delete(group
);
3358 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3361 if (bgp
->peer_self
) {
3362 peer_delete(bgp
->peer_self
);
3363 bgp
->peer_self
= NULL
;
3366 update_bgp_group_free(bgp
);
3368 /* TODO - Other memory may need to be freed - e.g., NHT */
3373 bgp_cleanup_routes(bgp
);
3375 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3376 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3379 &bgp
->vpn_policy
[afi
]
3380 .import_redirect_rtlist
);
3381 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3384 /* Deregister from Zebra, if needed */
3385 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3386 if (BGP_DEBUG(zebra
, ZEBRA
))
3387 zlog_debug("%s: deregistering this bgp %s instance from zebra",
3388 __PRETTY_FUNCTION__
, bgp
->name
);
3389 bgp_zebra_instance_deregister(bgp
);
3392 /* Remove visibility via the master list - there may however still be
3393 * routes to be processed still referencing the struct bgp.
3395 listnode_delete(bm
->bgp
, bgp
);
3397 /* Free interfaces in this instance. */
3400 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3401 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3403 bgp_vrf_unlink(bgp
, vrf
);
3405 /* Update EVPN VRF pointer */
3406 if (bm
->bgp_evpn
== bgp
) {
3407 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3410 bgp_set_evpn(bgp_get_default());
3413 thread_master_free_unused(bm
->master
);
3414 bgp_unlock(bgp
); /* initial reference */
3419 void bgp_free(struct bgp
*bgp
)
3423 struct bgp_table
*table
;
3424 struct bgp_node
*rn
;
3425 struct bgp_rmap
*rmap
;
3429 list_delete(&bgp
->group
);
3430 list_delete(&bgp
->peer
);
3432 if (bgp
->peerhash
) {
3433 hash_free(bgp
->peerhash
);
3434 bgp
->peerhash
= NULL
;
3437 FOREACH_AFI_SAFI (afi
, safi
) {
3438 /* Special handling for 2-level routing tables. */
3439 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3440 || safi
== SAFI_EVPN
) {
3441 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
3442 rn
= bgp_route_next(rn
)) {
3443 table
= bgp_node_get_bgp_table_info(rn
);
3444 bgp_table_finish(&table
);
3447 if (bgp
->route
[afi
][safi
])
3448 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3449 if (bgp
->aggregate
[afi
][safi
])
3450 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3451 if (bgp
->rib
[afi
][safi
])
3452 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3453 rmap
= &bgp
->table_map
[afi
][safi
];
3454 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3457 bgp_scan_finish(bgp
);
3458 bgp_address_destroy(bgp
);
3459 bgp_tip_hash_destroy(bgp
);
3461 /* release the auto RD id */
3462 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3464 bgp_evpn_cleanup(bgp
);
3465 bgp_pbr_cleanup(bgp
);
3466 XFREE(MTYPE_BGP_EVPN_INFO
, bgp
->evpn_info
);
3468 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3469 vpn_policy_direction_t dir
;
3471 if (bgp
->vpn_policy
[afi
].import_vrf
)
3472 list_delete(&bgp
->vpn_policy
[afi
].import_vrf
);
3473 if (bgp
->vpn_policy
[afi
].export_vrf
)
3474 list_delete(&bgp
->vpn_policy
[afi
].export_vrf
);
3476 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3477 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3478 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3479 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3480 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3481 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3484 XFREE(MTYPE_BGP
, bgp
->name
);
3485 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3487 XFREE(MTYPE_BGP
, bgp
);
3490 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3493 struct listnode
*node
, *nnode
;
3499 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3500 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3501 && !CHECK_FLAG(peer
->sflags
,
3502 PEER_STATUS_ACCEPT_PEER
))
3504 } else if (bm
->bgp
!= NULL
) {
3505 struct listnode
*bgpnode
, *nbgpnode
;
3507 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3508 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3510 && !strcmp(peer
->conf_if
, conf_if
)
3511 && !CHECK_FLAG(peer
->sflags
,
3512 PEER_STATUS_ACCEPT_PEER
))
3518 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
3521 struct listnode
*node
, *nnode
;
3527 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3528 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3529 && !CHECK_FLAG(peer
->sflags
,
3530 PEER_STATUS_ACCEPT_PEER
))
3532 } else if (bm
->bgp
!= NULL
) {
3533 struct listnode
*bgpnode
, *nbgpnode
;
3535 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3536 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3538 && !strcmp(peer
->hostname
, hostname
)
3539 && !CHECK_FLAG(peer
->sflags
,
3540 PEER_STATUS_ACCEPT_PEER
))
3546 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
3548 struct peer
*peer
= NULL
;
3549 struct peer tmp_peer
;
3551 memset(&tmp_peer
, 0, sizeof(struct peer
));
3554 * We do not want to find the doppelganger peer so search for the peer
3556 * the hash that has PEER_FLAG_CONFIG_NODE
3558 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3563 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3564 } else if (bm
->bgp
!= NULL
) {
3565 struct listnode
*bgpnode
, *nbgpnode
;
3567 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
3568 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3577 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
3578 union sockunion
*su
,
3579 struct peer_group
*group
)
3585 /* Create peer first; we've already checked group config is valid. */
3586 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3587 group
->conf
->as_type
, 0, 0, group
);
3592 peer
= peer_lock(peer
);
3593 listnode_add(group
->peer
, peer
);
3595 peer_group2peer_config_copy(group
, peer
);
3598 * Bind peer for all AFs configured for the group. We don't call
3599 * peer_group_bind as that is sub-optimal and does some stuff we don't
3602 FOREACH_AFI_SAFI (afi
, safi
) {
3603 if (!group
->conf
->afc
[afi
][safi
])
3605 peer
->afc
[afi
][safi
] = 1;
3607 if (!peer_af_find(peer
, afi
, safi
))
3608 peer_af_create(peer
, afi
, safi
);
3610 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
3613 /* Mark as dynamic, but also as a "config node" for other things to
3615 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3616 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3622 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
3623 struct prefix
*prefix
)
3625 struct listnode
*node
, *nnode
;
3626 struct prefix
*range
;
3629 afi
= family2afi(prefix
->family
);
3631 if (group
->listen_range
[afi
])
3632 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
3634 if (prefix_match(range
, prefix
))
3641 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
3642 struct prefix
**listen_range
)
3644 struct prefix
*range
= NULL
;
3645 struct peer_group
*group
= NULL
;
3646 struct listnode
*node
, *nnode
;
3648 *listen_range
= NULL
;
3650 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3651 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3654 } else if (bm
->bgp
!= NULL
) {
3655 struct listnode
*bgpnode
, *nbgpnode
;
3657 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3658 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3659 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3665 *listen_range
= range
;
3666 return (group
&& range
) ? group
: NULL
;
3669 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
3671 struct peer_group
*group
;
3674 struct prefix prefix
;
3675 struct prefix
*listen_range
;
3677 char buf
[PREFIX2STR_BUFFER
];
3678 char buf1
[PREFIX2STR_BUFFER
];
3680 sockunion2hostprefix(su
, &prefix
);
3682 /* See if incoming connection matches a configured listen range. */
3683 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
3694 prefix2str(&prefix
, buf
, sizeof(buf
));
3695 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3697 if (bgp_debug_neighbor_events(NULL
))
3699 "Dynamic Neighbor %s matches group %s listen range %s",
3700 buf
, group
->name
, buf1
);
3702 /* Are we within the listen limit? */
3703 dncount
= gbgp
->dynamic_neighbors_count
;
3705 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
3706 if (bgp_debug_neighbor_events(NULL
))
3707 zlog_debug("Dynamic Neighbor %s rejected - at limit %d",
3708 inet_sutop(su
, buf
),
3709 gbgp
->dynamic_neighbors_limit
);
3713 /* Ensure group is not disabled. */
3714 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
3715 if (bgp_debug_neighbor_events(NULL
))
3717 "Dynamic Neighbor %s rejected - group %s disabled",
3722 /* Check that at least one AF is activated for the group. */
3723 if (!peer_group_af_configured(group
)) {
3724 if (bgp_debug_neighbor_events(NULL
))
3726 "Dynamic Neighbor %s rejected - no AF activated for group %s",
3731 /* Create dynamic peer and bind to associated group. */
3732 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
3735 gbgp
->dynamic_neighbors_count
= ++dncount
;
3737 if (bgp_debug_neighbor_events(peer
))
3738 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
3739 peer
->host
, group
->name
, dncount
);
3744 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
3747 if (peer
->group
->bgp
) {
3748 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3750 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3752 if (bgp_debug_neighbor_events(peer
))
3753 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
3754 peer
->group
->name
, dncount
);
3757 /* If peer is configured at least one address family return 1. */
3758 int peer_active(struct peer
*peer
)
3760 if (BGP_PEER_SU_UNSPEC(peer
))
3762 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3763 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3764 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3765 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
3766 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3767 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3768 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3769 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3770 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
3771 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
3772 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
3777 /* If peer is negotiated at least one address family return 1. */
3778 int peer_active_nego(struct peer
*peer
)
3780 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3781 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3782 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3783 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3784 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3785 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
3786 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3787 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3788 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3789 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3790 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
3791 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
3792 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
3797 void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
3798 enum peer_change_type type
)
3800 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
3803 if (peer
->status
!= Established
)
3806 if (type
== peer_change_reset
) {
3807 /* If we're resetting session, we've to delete both peer struct
3809 if ((peer
->doppelganger
)
3810 && (peer
->doppelganger
->status
!= Deleted
)
3811 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3812 PEER_FLAG_CONFIG_NODE
)))
3813 peer_delete(peer
->doppelganger
);
3815 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3816 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3817 } else if (type
== peer_change_reset_in
) {
3818 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3819 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3820 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
3822 if ((peer
->doppelganger
)
3823 && (peer
->doppelganger
->status
!= Deleted
)
3824 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3825 PEER_FLAG_CONFIG_NODE
)))
3826 peer_delete(peer
->doppelganger
);
3828 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3829 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3831 } else if (type
== peer_change_reset_out
) {
3832 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3833 bgp_announce_route(peer
, afi
, safi
);
3837 struct peer_flag_action
{
3841 /* This flag can be set for peer-group member. */
3842 uint8_t not_for_member
;
3844 /* Action when the flag is changed. */
3845 enum peer_change_type type
;
3848 static const struct peer_flag_action peer_flag_action_list
[] = {
3849 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3850 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3851 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3852 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3853 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3854 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3855 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3856 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3857 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
3858 {PEER_FLAG_IFPEER_V6ONLY
, 0, peer_change_reset
},
3859 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
3860 {PEER_FLAG_TIMER
, 0, peer_change_none
},
3861 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
3862 {PEER_FLAG_PASSWORD
, 0, peer_change_none
},
3863 {PEER_FLAG_LOCAL_AS
, 0, peer_change_none
},
3864 {PEER_FLAG_LOCAL_AS_NO_PREPEND
, 0, peer_change_none
},
3865 {PEER_FLAG_LOCAL_AS_REPLACE_AS
, 0, peer_change_none
},
3866 {PEER_FLAG_UPDATE_SOURCE
, 0, peer_change_none
},
3869 static const struct peer_flag_action peer_af_flag_action_list
[] = {
3870 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3871 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3872 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3873 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3874 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3875 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3876 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3877 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3878 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3879 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3880 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
3881 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3882 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3883 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3884 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3885 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3886 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
3887 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
3888 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3889 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3890 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3891 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
3892 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3893 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
3894 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3897 /* Proper action set. */
3898 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
3899 int size
, struct peer_flag_action
*action
,
3906 const struct peer_flag_action
*match
= NULL
;
3908 /* Check peer's frag action. */
3909 for (i
= 0; i
< size
; i
++) {
3910 match
= &action_list
[i
];
3912 if (match
->flag
== 0)
3915 if (match
->flag
& flag
) {
3918 if (match
->type
== peer_change_reset_in
)
3920 if (match
->type
== peer_change_reset_out
)
3922 if (match
->type
== peer_change_reset
) {
3926 if (match
->not_for_member
)
3927 action
->not_for_member
= 1;
3931 /* Set peer clear type. */
3932 if (reset_in
&& reset_out
)
3933 action
->type
= peer_change_reset
;
3935 action
->type
= peer_change_reset_in
;
3937 action
->type
= peer_change_reset_out
;
3939 action
->type
= peer_change_none
;
3944 static void peer_flag_modify_action(struct peer
*peer
, uint32_t flag
)
3946 if (flag
== PEER_FLAG_SHUTDOWN
) {
3947 if (CHECK_FLAG(peer
->flags
, flag
)) {
3948 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3949 peer_nsf_stop(peer
);
3951 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3952 if (peer
->t_pmax_restart
) {
3953 BGP_TIMER_OFF(peer
->t_pmax_restart
);
3954 if (bgp_debug_neighbor_events(peer
))
3956 "%s Maximum-prefix restart timer canceled",
3960 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3961 peer_nsf_stop(peer
);
3963 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3964 char *msg
= peer
->tx_shutdown_message
;
3967 if (!msg
&& peer_group_active(peer
))
3968 msg
= peer
->group
->conf
3969 ->tx_shutdown_message
;
3970 msglen
= msg
? strlen(msg
) : 0;
3975 uint8_t msgbuf
[129];
3978 memcpy(msgbuf
+ 1, msg
, msglen
);
3980 bgp_notify_send_with_data(
3981 peer
, BGP_NOTIFY_CEASE
,
3982 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3983 msgbuf
, msglen
+ 1);
3986 peer
, BGP_NOTIFY_CEASE
,
3987 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3989 bgp_session_reset(peer
);
3991 peer
->v_start
= BGP_INIT_START_TIMER
;
3992 BGP_EVENT_ADD(peer
, BGP_Stop
);
3994 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3995 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3996 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3997 else if (flag
== PEER_FLAG_PASSIVE
)
3998 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3999 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
4000 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
4002 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4003 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4005 bgp_session_reset(peer
);
4008 /* Change specified peer flag. */
4009 static int peer_flag_modify(struct peer
*peer
, uint32_t flag
, int set
)
4013 bool invert
, member_invert
;
4014 struct peer
*member
;
4015 struct listnode
*node
, *nnode
;
4016 struct peer_flag_action action
;
4018 memset(&action
, 0, sizeof(struct peer_flag_action
));
4019 size
= sizeof peer_flag_action_list
/ sizeof(struct peer_flag_action
);
4021 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4022 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4025 /* Abort if no flag action exists. */
4027 return BGP_ERR_INVALID_FLAG
;
4029 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4030 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4031 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4032 return BGP_ERR_PEER_FLAG_CONFLICT
;
4034 /* Handle flag updates where desired state matches current state. */
4035 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4036 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4037 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4041 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4042 COND_FLAG(peer
->flags_override
, flag
, invert
);
4047 /* Inherit from peer-group or set/unset flags accordingly. */
4048 if (peer_group_active(peer
) && set
== invert
)
4049 peer_flag_inherit(peer
, flag
);
4051 COND_FLAG(peer
->flags
, flag
, set
);
4053 /* Check if handling a regular peer. */
4054 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4055 /* Update flag override state accordingly. */
4056 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4058 /* Execute flag action on peer. */
4059 if (action
.type
== peer_change_reset
)
4060 peer_flag_modify_action(peer
, flag
);
4062 /* Skip peer-group mechanics for regular peers. */
4066 if (set
&& flag
== PEER_FLAG_CAPABILITY_ENHE
)
4067 bgp_nht_register_enhe_capability_interfaces(peer
);
4070 * Update peer-group members, unless they are explicitely overriding
4071 * peer-group configuration.
4073 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4074 /* Skip peers with overridden configuration. */
4075 if (CHECK_FLAG(member
->flags_override
, flag
))
4078 /* Check if only member without group is inverted. */
4080 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4082 /* Skip peers with equivalent configuration. */
4083 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4086 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4089 /* Update flag on peer-group member. */
4090 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4092 if (set
&& flag
== PEER_FLAG_CAPABILITY_ENHE
)
4093 bgp_nht_register_enhe_capability_interfaces(member
);
4095 /* Execute flag action on peer-group member. */
4096 if (action
.type
== peer_change_reset
)
4097 peer_flag_modify_action(member
, flag
);
4103 int peer_flag_set(struct peer
*peer
, uint32_t flag
)
4105 return peer_flag_modify(peer
, flag
, 1);
4108 int peer_flag_unset(struct peer
*peer
, uint32_t flag
)
4110 return peer_flag_modify(peer
, flag
, 0);
4113 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4114 uint32_t flag
, bool set
)
4118 bool invert
, member_invert
;
4119 struct peer
*member
;
4120 struct listnode
*node
, *nnode
;
4121 struct peer_flag_action action
;
4123 memset(&action
, 0, sizeof(struct peer_flag_action
));
4124 size
= sizeof peer_af_flag_action_list
4125 / sizeof(struct peer_flag_action
);
4127 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4128 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4131 /* Abort if flag action exists. */
4133 return BGP_ERR_INVALID_FLAG
;
4135 /* Special check for reflector client. */
4136 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
4137 && peer_sort(peer
) != BGP_PEER_IBGP
)
4138 return BGP_ERR_NOT_INTERNAL_PEER
;
4140 /* Special check for remove-private-AS. */
4141 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
4142 && peer_sort(peer
) == BGP_PEER_IBGP
)
4143 return BGP_ERR_REMOVE_PRIVATE_AS
;
4145 /* as-override is not allowed for IBGP peers */
4146 if (flag
& PEER_FLAG_AS_OVERRIDE
&& peer_sort(peer
) == BGP_PEER_IBGP
)
4147 return BGP_ERR_AS_OVERRIDE
;
4149 /* Handle flag updates where desired state matches current state. */
4150 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4151 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4152 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4157 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4158 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4165 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4166 * if we are setting/unsetting flags which conflict with this flag
4167 * handle accordingly
4169 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4173 * if we are setting NEXTHOP_SELF, we need to unset the
4174 * NEXTHOP_UNCHANGED flag
4176 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4177 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4178 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4179 PEER_FLAG_NEXTHOP_UNCHANGED
);
4183 * if we are unsetting NEXTHOP_SELF, we need to set the
4184 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4186 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4187 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4188 SET_FLAG(peer
->af_flags
[afi
][safi
],
4189 PEER_FLAG_NEXTHOP_UNCHANGED
);
4193 /* Inherit from peer-group or set/unset flags accordingly. */
4194 if (peer_group_active(peer
) && set
== invert
)
4195 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4197 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4199 /* Execute action when peer is established. */
4200 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4201 && peer
->status
== Established
) {
4202 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4203 bgp_clear_adj_in(peer
, afi
, safi
);
4205 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4206 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4207 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4208 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4209 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4210 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4211 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4212 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4214 peer_change_action(peer
, afi
, safi
, action
.type
);
4218 /* Check if handling a regular peer. */
4219 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4220 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4224 * Update peer-group members, unless they are explicitely
4225 * overriding peer-group configuration.
4227 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4229 /* Skip peers with overridden configuration. */
4230 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4234 /* Check if only member without group is inverted. */
4236 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4240 /* Skip peers with equivalent configuration. */
4241 if (set
!= member_invert
4242 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4245 if (set
== member_invert
4246 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4249 /* Update flag on peer-group member. */
4250 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4251 set
!= member_invert
);
4253 /* Execute flag action on peer-group member. */
4254 if (member
->status
== Established
) {
4255 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4256 bgp_clear_adj_in(member
, afi
, safi
);
4258 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4259 member
->last_reset
=
4260 PEER_DOWN_RR_CLIENT_CHANGE
;
4262 == PEER_FLAG_RSERVER_CLIENT
)
4263 member
->last_reset
=
4264 PEER_DOWN_RS_CLIENT_CHANGE
;
4266 == PEER_FLAG_ORF_PREFIX_SM
)
4267 member
->last_reset
=
4268 PEER_DOWN_CAPABILITY_CHANGE
;
4270 == PEER_FLAG_ORF_PREFIX_RM
)
4271 member
->last_reset
=
4272 PEER_DOWN_CAPABILITY_CHANGE
;
4274 peer_change_action(member
, afi
, safi
,
4284 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4286 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4289 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4291 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4295 int peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4297 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4298 peer
->tx_shutdown_message
=
4299 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4303 int peer_tx_shutdown_message_unset(struct peer
*peer
)
4305 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4310 /* EBGP multihop configuration. */
4311 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4313 struct peer_group
*group
;
4314 struct listnode
*node
, *nnode
;
4317 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4320 /* see comment in peer_ttl_security_hops_set() */
4321 if (ttl
!= MAXTTL
) {
4322 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4323 group
= peer
->group
;
4324 if (group
->conf
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4325 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4327 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4329 if (peer1
->sort
== BGP_PEER_IBGP
)
4332 if (peer1
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4333 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4336 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4337 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4343 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4344 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
) {
4345 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4346 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4347 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4349 bgp_session_reset(peer
);
4352 group
= peer
->group
;
4353 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4354 if (peer
->sort
== BGP_PEER_IBGP
)
4357 peer
->ttl
= group
->conf
->ttl
;
4359 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4360 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4361 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4363 bgp_session_reset(peer
);
4369 int peer_ebgp_multihop_unset(struct peer
*peer
)
4371 struct peer_group
*group
;
4372 struct listnode
*node
, *nnode
;
4374 if (peer
->sort
== BGP_PEER_IBGP
)
4377 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
&& peer
->ttl
!= MAXTTL
)
4378 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4380 if (peer_group_active(peer
))
4381 peer
->ttl
= peer
->group
->conf
->ttl
;
4383 peer
->ttl
= BGP_DEFAULT_TTL
;
4385 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4386 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4387 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4388 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4390 bgp_session_reset(peer
);
4392 group
= peer
->group
;
4393 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4394 if (peer
->sort
== BGP_PEER_IBGP
)
4397 peer
->ttl
= BGP_DEFAULT_TTL
;
4399 if (peer
->fd
>= 0) {
4400 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4402 peer
, BGP_NOTIFY_CEASE
,
4403 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4405 bgp_session_reset(peer
);
4412 /* Neighbor description. */
4413 int peer_description_set(struct peer
*peer
, const char *desc
)
4415 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4417 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
4422 int peer_description_unset(struct peer
*peer
)
4424 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4429 /* Neighbor update-source. */
4430 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
4432 struct peer
*member
;
4433 struct listnode
*node
, *nnode
;
4435 /* Set flag and configuration on peer. */
4436 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
4437 if (peer
->update_if
) {
4438 if (strcmp(peer
->update_if
, ifname
) == 0)
4440 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4442 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4443 sockunion_free(peer
->update_source
);
4444 peer
->update_source
= NULL
;
4446 /* Check if handling a regular peer. */
4447 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4448 /* Send notification or reset peer depending on state. */
4449 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4450 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4451 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4452 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4454 bgp_session_reset(peer
);
4456 /* Skip peer-group mechanics for regular peers. */
4461 * Set flag and configuration on all peer-group members, unless they are
4462 * explicitely overriding peer-group configuration.
4464 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4465 /* Skip peers with overridden configuration. */
4466 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4469 /* Skip peers with the same configuration. */
4470 if (member
->update_if
) {
4471 if (strcmp(member
->update_if
, ifname
) == 0)
4473 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4476 /* Set flag and configuration on peer-group member. */
4477 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4478 member
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4479 sockunion_free(member
->update_source
);
4480 member
->update_source
= NULL
;
4482 /* Send notification or reset peer depending on state. */
4483 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4484 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4485 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4486 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4488 bgp_session_reset(member
);
4494 int peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
4496 struct peer
*member
;
4497 struct listnode
*node
, *nnode
;
4499 /* Set flag and configuration on peer. */
4500 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
4501 if (peer
->update_source
) {
4502 if (sockunion_cmp(peer
->update_source
, su
) == 0)
4504 sockunion_free(peer
->update_source
);
4506 peer
->update_source
= sockunion_dup(su
);
4507 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4509 /* Check if handling a regular peer. */
4510 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4511 /* Send notification or reset peer depending on state. */
4512 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4513 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4514 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4515 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4517 bgp_session_reset(peer
);
4519 /* Skip peer-group mechanics for regular peers. */
4524 * Set flag and configuration on all peer-group members, unless they are
4525 * explicitely overriding peer-group configuration.
4527 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4528 /* Skip peers with overridden configuration. */
4529 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4532 /* Skip peers with the same configuration. */
4533 if (member
->update_source
) {
4534 if (sockunion_cmp(member
->update_source
, su
) == 0)
4536 sockunion_free(member
->update_source
);
4539 /* Set flag and configuration on peer-group member. */
4540 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4541 member
->update_source
= sockunion_dup(su
);
4542 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4544 /* Send notification or reset peer depending on state. */
4545 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4546 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4547 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4548 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4550 bgp_session_reset(member
);
4556 int peer_update_source_unset(struct peer
*peer
)
4558 struct peer
*member
;
4559 struct listnode
*node
, *nnode
;
4561 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_UPDATE_SOURCE
))
4564 /* Inherit configuration from peer-group if peer is member. */
4565 if (peer_group_active(peer
)) {
4566 peer_flag_inherit(peer
, PEER_FLAG_UPDATE_SOURCE
);
4567 PEER_SU_ATTR_INHERIT(peer
, peer
->group
, update_source
);
4568 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, update_if
,
4569 MTYPE_PEER_UPDATE_SOURCE
);
4571 /* Otherwise remove flag and configuration from peer. */
4572 peer_flag_unset(peer
, PEER_FLAG_UPDATE_SOURCE
);
4573 sockunion_free(peer
->update_source
);
4574 peer
->update_source
= NULL
;
4575 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4578 /* Check if handling a regular peer. */
4579 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4580 /* Send notification or reset peer depending on state. */
4581 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4582 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4583 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4584 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4586 bgp_session_reset(peer
);
4588 /* Skip peer-group mechanics for regular peers. */
4593 * Set flag and configuration on all peer-group members, unless they are
4594 * explicitely overriding peer-group configuration.
4596 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4597 /* Skip peers with overridden configuration. */
4598 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4601 /* Skip peers with the same configuration. */
4602 if (!CHECK_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
)
4603 && !member
->update_source
&& !member
->update_if
)
4606 /* Remove flag and configuration on peer-group member. */
4607 UNSET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4608 sockunion_free(member
->update_source
);
4609 member
->update_source
= NULL
;
4610 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4612 /* Send notification or reset peer depending on state. */
4613 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4614 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4615 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4616 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4618 bgp_session_reset(member
);
4624 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
4625 const char *rmap
, struct route_map
*route_map
)
4627 struct peer
*member
;
4628 struct listnode
*node
, *nnode
;
4630 /* Set flag and configuration on peer. */
4631 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
4633 if (!peer
->default_rmap
[afi
][safi
].name
4634 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
4635 if (peer
->default_rmap
[afi
][safi
].name
)
4636 XFREE(MTYPE_ROUTE_MAP_NAME
,
4637 peer
->default_rmap
[afi
][safi
].name
);
4639 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4640 peer
->default_rmap
[afi
][safi
].name
=
4641 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4642 peer
->default_rmap
[afi
][safi
].map
= route_map
;
4643 route_map_counter_increment(route_map
);
4646 if (peer
->default_rmap
[afi
][safi
].name
)
4647 XFREE(MTYPE_ROUTE_MAP_NAME
,
4648 peer
->default_rmap
[afi
][safi
].name
);
4650 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4651 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4652 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4655 /* Check if handling a regular peer. */
4656 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4657 /* Update peer route announcements. */
4658 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4659 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4660 bgp_default_originate(peer
, afi
, safi
, 0);
4661 bgp_announce_route(peer
, afi
, safi
);
4664 /* Skip peer-group mechanics for regular peers. */
4669 * Set flag and configuration on all peer-group members, unless they are
4670 * explicitely overriding peer-group configuration.
4672 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4673 /* Skip peers with overridden configuration. */
4674 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4675 PEER_FLAG_DEFAULT_ORIGINATE
))
4678 /* Set flag and configuration on peer-group member. */
4679 SET_FLAG(member
->af_flags
[afi
][safi
],
4680 PEER_FLAG_DEFAULT_ORIGINATE
);
4682 if (member
->default_rmap
[afi
][safi
].name
)
4683 XFREE(MTYPE_ROUTE_MAP_NAME
,
4684 member
->default_rmap
[afi
][safi
].name
);
4685 route_map_counter_decrement(
4686 member
->default_rmap
[afi
][safi
].map
);
4687 member
->default_rmap
[afi
][safi
].name
=
4688 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4689 member
->default_rmap
[afi
][safi
].map
= route_map
;
4690 route_map_counter_increment(route_map
);
4693 /* Update peer route announcements. */
4694 if (member
->status
== Established
4695 && member
->afc_nego
[afi
][safi
]) {
4696 update_group_adjust_peer(
4697 peer_af_find(member
, afi
, safi
));
4698 bgp_default_originate(member
, afi
, safi
, 0);
4699 bgp_announce_route(member
, afi
, safi
);
4706 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4708 struct peer
*member
;
4709 struct listnode
*node
, *nnode
;
4711 /* Inherit configuration from peer-group if peer is member. */
4712 if (peer_group_active(peer
)) {
4713 peer_af_flag_inherit(peer
, afi
, safi
,
4714 PEER_FLAG_DEFAULT_ORIGINATE
);
4715 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
4716 default_rmap
[afi
][safi
].name
,
4717 MTYPE_ROUTE_MAP_NAME
);
4718 PEER_ATTR_INHERIT(peer
, peer
->group
,
4719 default_rmap
[afi
][safi
].map
);
4721 /* Otherwise remove flag and configuration from peer. */
4722 peer_af_flag_unset(peer
, afi
, safi
,
4723 PEER_FLAG_DEFAULT_ORIGINATE
);
4724 if (peer
->default_rmap
[afi
][safi
].name
)
4725 XFREE(MTYPE_ROUTE_MAP_NAME
,
4726 peer
->default_rmap
[afi
][safi
].name
);
4727 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4728 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4729 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4732 /* Check if handling a regular peer. */
4733 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4734 /* Update peer route announcements. */
4735 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4736 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4737 bgp_default_originate(peer
, afi
, safi
, 1);
4738 bgp_announce_route(peer
, afi
, safi
);
4741 /* Skip peer-group mechanics for regular peers. */
4746 * Remove flag and configuration from all peer-group members, unless
4747 * they are explicitely overriding peer-group configuration.
4749 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4750 /* Skip peers with overridden configuration. */
4751 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4752 PEER_FLAG_DEFAULT_ORIGINATE
))
4755 /* Remove flag and configuration on peer-group member. */
4756 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4757 PEER_FLAG_DEFAULT_ORIGINATE
);
4758 if (peer
->default_rmap
[afi
][safi
].name
)
4759 XFREE(MTYPE_ROUTE_MAP_NAME
,
4760 peer
->default_rmap
[afi
][safi
].name
);
4761 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4762 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4763 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4765 /* Update peer route announcements. */
4766 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4767 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4768 bgp_default_originate(peer
, afi
, safi
, 1);
4769 bgp_announce_route(peer
, afi
, safi
);
4776 int peer_port_set(struct peer
*peer
, uint16_t port
)
4782 int peer_port_unset(struct peer
*peer
)
4784 peer
->port
= BGP_PORT_DEFAULT
;
4789 * Helper function that is called after the name of the policy
4790 * being used by a peer has changed (AF specific). Automatically
4791 * initiates inbound or outbound processing as needed.
4793 static void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
4797 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4798 if (peer
->status
== Established
)
4799 bgp_announce_route(peer
, afi
, safi
);
4801 if (peer
->status
!= Established
)
4804 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4805 PEER_FLAG_SOFT_RECONFIG
))
4806 bgp_soft_reconfig_in(peer
, afi
, safi
);
4807 else if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4808 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4809 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
4814 /* neighbor weight. */
4815 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
4817 struct peer
*member
;
4818 struct listnode
*node
, *nnode
;
4820 /* Set flag and configuration on peer. */
4821 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4822 if (peer
->weight
[afi
][safi
] != weight
) {
4823 peer
->weight
[afi
][safi
] = weight
;
4824 peer_on_policy_change(peer
, afi
, safi
, 0);
4827 /* Skip peer-group mechanics for regular peers. */
4828 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4832 * Set flag and configuration on all peer-group members, unless they are
4833 * explicitely overriding peer-group configuration.
4835 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4836 /* Skip peers with overridden configuration. */
4837 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4841 /* Set flag and configuration on peer-group member. */
4842 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4843 if (member
->weight
[afi
][safi
] != weight
) {
4844 member
->weight
[afi
][safi
] = weight
;
4845 peer_on_policy_change(member
, afi
, safi
, 0);
4852 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4854 struct peer
*member
;
4855 struct listnode
*node
, *nnode
;
4857 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4860 /* Inherit configuration from peer-group if peer is member. */
4861 if (peer_group_active(peer
)) {
4862 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4863 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
4865 peer_on_policy_change(peer
, afi
, safi
, 0);
4869 /* Remove flag and configuration from peer. */
4870 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4871 peer
->weight
[afi
][safi
] = 0;
4872 peer_on_policy_change(peer
, afi
, safi
, 0);
4874 /* Skip peer-group mechanics for regular peers. */
4875 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4879 * Remove flag and configuration from all peer-group members, unless
4880 * they are explicitely overriding peer-group configuration.
4882 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4883 /* Skip peers with overridden configuration. */
4884 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4888 /* Skip peers where flag is already disabled. */
4889 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4892 /* Remove flag and configuration on peer-group member. */
4893 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4894 member
->weight
[afi
][safi
] = 0;
4895 peer_on_policy_change(member
, afi
, safi
, 0);
4901 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
4903 struct peer
*member
;
4904 struct listnode
*node
, *nnode
;
4906 if (keepalive
> 65535)
4907 return BGP_ERR_INVALID_VALUE
;
4909 if (holdtime
> 65535)
4910 return BGP_ERR_INVALID_VALUE
;
4912 if (holdtime
< 3 && holdtime
!= 0)
4913 return BGP_ERR_INVALID_VALUE
;
4915 /* Set flag and configuration on peer. */
4916 peer_flag_set(peer
, PEER_FLAG_TIMER
);
4917 peer
->holdtime
= holdtime
;
4918 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4920 /* Skip peer-group mechanics for regular peers. */
4921 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4925 * Set flag and configuration on all peer-group members, unless they are
4926 * explicitely overriding peer-group configuration.
4928 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4929 /* Skip peers with overridden configuration. */
4930 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
4933 /* Set flag and configuration on peer-group member. */
4934 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
4935 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
4936 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
4942 int peer_timers_unset(struct peer
*peer
)
4944 struct peer
*member
;
4945 struct listnode
*node
, *nnode
;
4947 /* Inherit configuration from peer-group if peer is member. */
4948 if (peer_group_active(peer
)) {
4949 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
4950 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
4951 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
4953 /* Otherwise remove flag and configuration from peer. */
4954 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
4956 peer
->keepalive
= 0;
4959 /* Skip peer-group mechanics for regular peers. */
4960 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4964 * Remove flag and configuration from all peer-group members, unless
4965 * they are explicitely overriding peer-group configuration.
4967 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4968 /* Skip peers with overridden configuration. */
4969 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
4972 /* Remove flag and configuration on peer-group member. */
4973 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
4974 member
->holdtime
= 0;
4975 member
->keepalive
= 0;
4981 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
4983 struct peer
*member
;
4984 struct listnode
*node
, *nnode
;
4986 if (connect
> 65535)
4987 return BGP_ERR_INVALID_VALUE
;
4989 /* Set flag and configuration on peer. */
4990 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
4991 peer
->connect
= connect
;
4992 peer
->v_connect
= connect
;
4994 /* Skip peer-group mechanics for regular peers. */
4995 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4999 * Set flag and configuration on all peer-group members, unless they are
5000 * explicitely overriding peer-group configuration.
5002 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5003 /* Skip peers with overridden configuration. */
5004 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5007 /* Set flag and configuration on peer-group member. */
5008 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5009 member
->connect
= connect
;
5010 member
->v_connect
= connect
;
5016 int peer_timers_connect_unset(struct peer
*peer
)
5018 struct peer
*member
;
5019 struct listnode
*node
, *nnode
;
5021 /* Inherit configuration from peer-group if peer is member. */
5022 if (peer_group_active(peer
)) {
5023 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5024 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5026 /* Otherwise remove flag and configuration from peer. */
5027 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5031 /* Set timer with fallback to default value. */
5033 peer
->v_connect
= peer
->connect
;
5035 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
5037 /* Skip peer-group mechanics for regular peers. */
5038 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5042 * Remove flag and configuration from all peer-group members, unless
5043 * they are explicitely overriding peer-group configuration.
5045 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5046 /* Skip peers with overridden configuration. */
5047 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5050 /* Remove flag and configuration on peer-group member. */
5051 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5052 member
->connect
= 0;
5053 member
->v_connect
= peer
->bgp
->default_connect_retry
;
5059 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5061 struct peer
*member
;
5062 struct listnode
*node
, *nnode
;
5065 return BGP_ERR_INVALID_VALUE
;
5067 /* Set flag and configuration on peer. */
5068 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5069 peer
->routeadv
= routeadv
;
5070 peer
->v_routeadv
= routeadv
;
5072 /* Check if handling a regular peer. */
5073 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5074 /* Update peer route announcements. */
5075 update_group_adjust_peer_afs(peer
);
5076 if (peer
->status
== Established
)
5077 bgp_announce_route_all(peer
);
5079 /* Skip peer-group mechanics for regular peers. */
5084 * Set flag and configuration on all peer-group members, unless they are
5085 * explicitely overriding peer-group configuration.
5087 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5088 /* Skip peers with overridden configuration. */
5089 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5092 /* Set flag and configuration on peer-group member. */
5093 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5094 member
->routeadv
= routeadv
;
5095 member
->v_routeadv
= routeadv
;
5097 /* Update peer route announcements. */
5098 update_group_adjust_peer_afs(member
);
5099 if (member
->status
== Established
)
5100 bgp_announce_route_all(member
);
5106 int peer_advertise_interval_unset(struct peer
*peer
)
5108 struct peer
*member
;
5109 struct listnode
*node
, *nnode
;
5111 /* Inherit configuration from peer-group if peer is member. */
5112 if (peer_group_active(peer
)) {
5113 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
5114 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
5116 /* Otherwise remove flag and configuration from peer. */
5117 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
5121 /* Set timer with fallback to default value. */
5123 peer
->v_routeadv
= peer
->routeadv
;
5125 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
5126 ? BGP_DEFAULT_IBGP_ROUTEADV
5127 : BGP_DEFAULT_EBGP_ROUTEADV
;
5129 /* Check if handling a regular peer. */
5130 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5131 /* Update peer route announcements. */
5132 update_group_adjust_peer_afs(peer
);
5133 if (peer
->status
== Established
)
5134 bgp_announce_route_all(peer
);
5136 /* Skip peer-group mechanics for regular peers. */
5141 * Remove flag and configuration from all peer-group members, unless
5142 * they are explicitely overriding peer-group configuration.
5144 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5145 /* Skip peers with overridden configuration. */
5146 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5149 /* Remove flag and configuration on peer-group member. */
5150 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5151 member
->routeadv
= 0;
5152 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
5153 ? BGP_DEFAULT_IBGP_ROUTEADV
5154 : BGP_DEFAULT_EBGP_ROUTEADV
;
5156 /* Update peer route announcements. */
5157 update_group_adjust_peer_afs(member
);
5158 if (member
->status
== Established
)
5159 bgp_announce_route_all(member
);
5165 /* neighbor interface */
5166 void peer_interface_set(struct peer
*peer
, const char *str
)
5168 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5169 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
5172 void peer_interface_unset(struct peer
*peer
)
5174 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5178 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5179 int allow_num
, int origin
)
5181 struct peer
*member
;
5182 struct listnode
*node
, *nnode
;
5184 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
5185 return BGP_ERR_INVALID_VALUE
;
5187 /* Set flag and configuration on peer. */
5188 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5190 if (peer
->allowas_in
[afi
][safi
] != 0
5191 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5192 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5193 peer_af_flag_set(peer
, afi
, safi
,
5194 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5195 peer
->allowas_in
[afi
][safi
] = 0;
5196 peer_on_policy_change(peer
, afi
, safi
, 0);
5199 if (peer
->allowas_in
[afi
][safi
] != allow_num
5200 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5201 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5203 peer_af_flag_unset(peer
, afi
, safi
,
5204 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5205 peer
->allowas_in
[afi
][safi
] = allow_num
;
5206 peer_on_policy_change(peer
, afi
, safi
, 0);
5210 /* Skip peer-group mechanics for regular peers. */
5211 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5215 * Set flag and configuration on all peer-group members, unless
5216 * they are explicitely overriding peer-group configuration.
5218 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5219 /* Skip peers with overridden configuration. */
5220 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5221 PEER_FLAG_ALLOWAS_IN
))
5224 /* Set flag and configuration on peer-group member. */
5225 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5227 if (member
->allowas_in
[afi
][safi
] != 0
5228 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
5229 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5230 SET_FLAG(member
->af_flags
[afi
][safi
],
5231 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5232 member
->allowas_in
[afi
][safi
] = 0;
5233 peer_on_policy_change(peer
, afi
, safi
, 0);
5236 if (member
->allowas_in
[afi
][safi
] != allow_num
5237 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
5238 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5239 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5240 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5241 member
->allowas_in
[afi
][safi
] = allow_num
;
5242 peer_on_policy_change(peer
, afi
, safi
, 0);
5250 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5252 struct peer
*member
;
5253 struct listnode
*node
, *nnode
;
5255 /* Skip peer if flag is already disabled. */
5256 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
5259 /* Inherit configuration from peer-group if peer is member. */
5260 if (peer_group_active(peer
)) {
5261 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5262 peer_af_flag_inherit(peer
, afi
, safi
,
5263 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5264 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
5265 peer_on_policy_change(peer
, afi
, safi
, 0);
5270 /* Remove flag and configuration from peer. */
5271 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5272 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5273 peer
->allowas_in
[afi
][safi
] = 0;
5274 peer_on_policy_change(peer
, afi
, safi
, 0);
5276 /* Skip peer-group mechanics if handling a regular peer. */
5277 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5281 * Remove flags and configuration from all peer-group members, unless
5282 * they are explicitely overriding peer-group configuration.
5284 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5285 /* Skip peers with overridden configuration. */
5286 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5287 PEER_FLAG_ALLOWAS_IN
))
5290 /* Skip peers where flag is already disabled. */
5291 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
],
5292 PEER_FLAG_ALLOWAS_IN
))
5295 /* Remove flags and configuration on peer-group member. */
5296 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5297 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5298 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5299 member
->allowas_in
[afi
][safi
] = 0;
5300 peer_on_policy_change(member
, afi
, safi
, 0);
5306 int peer_local_as_set(struct peer
*peer
, as_t as
, int no_prepend
,
5309 bool old_no_prepend
, old_replace_as
;
5310 struct bgp
*bgp
= peer
->bgp
;
5311 struct peer
*member
;
5312 struct listnode
*node
, *nnode
;
5314 if (peer_sort(peer
) != BGP_PEER_EBGP
5315 && peer_sort(peer
) != BGP_PEER_INTERNAL
)
5316 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5319 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5322 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5324 /* Save previous flag states. */
5326 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5328 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5330 /* Set flag and configuration on peer. */
5331 peer_flag_set(peer
, PEER_FLAG_LOCAL_AS
);
5332 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
, no_prepend
);
5333 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
, replace_as
);
5335 if (peer
->change_local_as
== as
&& old_no_prepend
== no_prepend
5336 && old_replace_as
== replace_as
)
5338 peer
->change_local_as
= as
;
5340 /* Check if handling a regular peer. */
5341 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5342 /* Send notification or reset peer depending on state. */
5343 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5344 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5345 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5346 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5348 bgp_session_reset(peer
);
5350 /* Skip peer-group mechanics for regular peers. */
5355 * Set flag and configuration on all peer-group members, unless they are
5356 * explicitely overriding peer-group configuration.
5358 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5359 /* Skip peers with overridden configuration. */
5360 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
5363 /* Skip peers with the same configuration. */
5364 old_no_prepend
= CHECK_FLAG(member
->flags
,
5365 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5366 old_replace_as
= CHECK_FLAG(member
->flags
,
5367 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5368 if (member
->change_local_as
== as
5369 && CHECK_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
)
5370 && old_no_prepend
== no_prepend
5371 && old_replace_as
== replace_as
)
5374 /* Set flag and configuration on peer-group member. */
5375 SET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
5376 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
,
5378 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
,
5380 member
->change_local_as
= as
;
5382 /* Send notification or stop peer depending on state. */
5383 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5384 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5385 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5386 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5388 BGP_EVENT_ADD(member
, BGP_Stop
);
5394 int peer_local_as_unset(struct peer
*peer
)
5396 struct peer
*member
;
5397 struct listnode
*node
, *nnode
;
5399 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS
))
5402 /* Inherit configuration from peer-group if peer is member. */
5403 if (peer_group_active(peer
)) {
5404 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS
);
5405 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5406 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5407 PEER_ATTR_INHERIT(peer
, peer
->group
, change_local_as
);
5409 /* Otherwise remove flag and configuration from peer. */
5410 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
5411 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5412 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5413 peer
->change_local_as
= 0;
5416 /* Check if handling a regular peer. */
5417 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5418 /* Send notification or stop peer depending on state. */
5419 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5420 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5421 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5422 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5424 BGP_EVENT_ADD(peer
, BGP_Stop
);
5426 /* Skip peer-group mechanics for regular peers. */
5431 * Remove flag and configuration from all peer-group members, unless
5432 * they are explicitely overriding peer-group configuration.
5434 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5435 /* Skip peers with overridden configuration. */
5436 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
5439 /* Remove flag and configuration on peer-group member. */
5440 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
5441 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5442 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5443 member
->change_local_as
= 0;
5445 /* Send notification or stop peer depending on state. */
5446 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5447 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5448 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5449 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5451 bgp_session_reset(member
);
5457 /* Set password for authenticating with the peer. */
5458 int peer_password_set(struct peer
*peer
, const char *password
)
5460 struct peer
*member
;
5461 struct listnode
*node
, *nnode
;
5462 int len
= password
? strlen(password
) : 0;
5463 int ret
= BGP_SUCCESS
;
5465 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5466 return BGP_ERR_INVALID_VALUE
;
5468 /* Set flag and configuration on peer. */
5469 peer_flag_set(peer
, PEER_FLAG_PASSWORD
);
5470 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
5472 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5473 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5475 /* Check if handling a regular peer. */
5476 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5477 /* Send notification or reset peer depending on state. */
5478 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5479 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5480 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5482 bgp_session_reset(peer
);
5485 * Attempt to install password on socket and skip peer-group
5488 if (BGP_PEER_SU_UNSPEC(peer
))
5490 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
5491 : BGP_ERR_TCPSIG_FAILED
;
5495 * Set flag and configuration on all peer-group members, unless they are
5496 * explicitely overriding peer-group configuration.
5498 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5499 /* Skip peers with overridden configuration. */
5500 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
5503 /* Skip peers with the same password. */
5504 if (member
->password
&& strcmp(member
->password
, password
) == 0)
5507 /* Set flag and configuration on peer-group member. */
5508 SET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
5509 if (member
->password
)
5510 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
5511 member
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5513 /* Send notification or reset peer depending on state. */
5514 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
5515 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5516 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5518 bgp_session_reset(member
);
5520 /* Attempt to install password on socket. */
5521 if (!BGP_PEER_SU_UNSPEC(member
) && bgp_md5_set(member
) < 0)
5522 ret
= BGP_ERR_TCPSIG_FAILED
;
5525 /* Set flag and configuration on all peer-group listen ranges */
5526 struct listnode
*ln
;
5529 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
5530 bgp_md5_set_prefix(lr
, password
);
5531 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
5532 bgp_md5_set_prefix(lr
, password
);
5537 int peer_password_unset(struct peer
*peer
)
5539 struct peer
*member
;
5540 struct listnode
*node
, *nnode
;
5542 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
))
5545 /* Inherit configuration from peer-group if peer is member. */
5546 if (peer_group_active(peer
)) {
5547 peer_flag_inherit(peer
, PEER_FLAG_PASSWORD
);
5548 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, password
,
5549 MTYPE_PEER_PASSWORD
);
5551 /* Otherwise remove flag and configuration from peer. */
5552 peer_flag_unset(peer
, PEER_FLAG_PASSWORD
);
5553 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5556 /* Check if handling a regular peer. */
5557 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5558 /* Send notification or reset peer depending on state. */
5559 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5560 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5561 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5563 bgp_session_reset(peer
);
5565 /* Attempt to uninstall password on socket. */
5566 if (!BGP_PEER_SU_UNSPEC(peer
))
5567 bgp_md5_unset(peer
);
5569 /* Skip peer-group mechanics for regular peers. */
5574 * Remove flag and configuration from all peer-group members, unless
5575 * they are explicitely overriding peer-group configuration.
5577 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5578 /* Skip peers with overridden configuration. */
5579 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
5582 /* Remove flag and configuration on peer-group member. */
5583 UNSET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
5584 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
5586 /* Send notification or reset peer depending on state. */
5587 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
5588 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5589 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5591 bgp_session_reset(member
);
5593 /* Attempt to uninstall password on socket. */
5594 if (!BGP_PEER_SU_UNSPEC(member
))
5595 bgp_md5_unset(member
);
5598 /* Set flag and configuration on all peer-group listen ranges */
5599 struct listnode
*ln
;
5602 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
5603 bgp_md5_unset_prefix(lr
);
5604 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
5605 bgp_md5_unset_prefix(lr
);
5611 /* Set distribute list to the peer. */
5612 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5615 struct peer
*member
;
5616 struct bgp_filter
*filter
;
5617 struct listnode
*node
, *nnode
;
5619 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5620 return BGP_ERR_INVALID_VALUE
;
5622 /* Set configuration on peer. */
5623 filter
= &peer
->filter
[afi
][safi
];
5624 if (filter
->plist
[direct
].name
)
5625 return BGP_ERR_PEER_FILTER_CONFLICT
;
5626 if (filter
->dlist
[direct
].name
)
5627 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5628 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5629 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5631 /* Check if handling a regular peer. */
5632 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5633 /* Set override-flag and process peer route updates. */
5634 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5635 PEER_FT_DISTRIBUTE_LIST
);
5636 peer_on_policy_change(peer
, afi
, safi
,
5637 (direct
== FILTER_OUT
) ? 1 : 0);
5639 /* Skip peer-group mechanics for regular peers. */
5644 * Set configuration on all peer-group members, un less they are
5645 * explicitely overriding peer-group configuration.
5647 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5648 /* Skip peers with overridden configuration. */
5649 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5650 PEER_FT_DISTRIBUTE_LIST
))
5653 /* Set configuration on peer-group member. */
5654 filter
= &member
->filter
[afi
][safi
];
5655 if (filter
->dlist
[direct
].name
)
5656 XFREE(MTYPE_BGP_FILTER_NAME
,
5657 filter
->dlist
[direct
].name
);
5658 filter
->dlist
[direct
].name
=
5659 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5660 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5662 /* Process peer route updates. */
5663 peer_on_policy_change(member
, afi
, safi
,
5664 (direct
== FILTER_OUT
) ? 1 : 0);
5670 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5672 struct peer
*member
;
5673 struct bgp_filter
*filter
;
5674 struct listnode
*node
, *nnode
;
5676 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5677 return BGP_ERR_INVALID_VALUE
;
5679 /* Unset override-flag unconditionally. */
5680 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5681 PEER_FT_DISTRIBUTE_LIST
);
5683 /* Inherit configuration from peer-group if peer is member. */
5684 if (peer_group_active(peer
)) {
5685 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5686 filter
[afi
][safi
].dlist
[direct
].name
,
5687 MTYPE_BGP_FILTER_NAME
);
5688 PEER_ATTR_INHERIT(peer
, peer
->group
,
5689 filter
[afi
][safi
].dlist
[direct
].alist
);
5691 /* Otherwise remove configuration from peer. */
5692 filter
= &peer
->filter
[afi
][safi
];
5693 if (filter
->dlist
[direct
].name
)
5694 XFREE(MTYPE_BGP_FILTER_NAME
,
5695 filter
->dlist
[direct
].name
);
5696 filter
->dlist
[direct
].name
= NULL
;
5697 filter
->dlist
[direct
].alist
= NULL
;
5700 /* Check if handling a regular peer. */
5701 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5702 /* Process peer route updates. */
5703 peer_on_policy_change(peer
, afi
, safi
,
5704 (direct
== FILTER_OUT
) ? 1 : 0);
5706 /* Skip peer-group mechanics for regular peers. */
5711 * Remove configuration on all peer-group members, unless they are
5712 * explicitely overriding peer-group configuration.
5714 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5715 /* Skip peers with overridden configuration. */
5716 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5717 PEER_FT_DISTRIBUTE_LIST
))
5720 /* Remove configuration on peer-group member. */
5721 filter
= &member
->filter
[afi
][safi
];
5722 if (filter
->dlist
[direct
].name
)
5723 XFREE(MTYPE_BGP_FILTER_NAME
,
5724 filter
->dlist
[direct
].name
);
5725 filter
->dlist
[direct
].name
= NULL
;
5726 filter
->dlist
[direct
].alist
= NULL
;
5728 /* Process peer route updates. */
5729 peer_on_policy_change(member
, afi
, safi
,
5730 (direct
== FILTER_OUT
) ? 1 : 0);
5736 /* Update distribute list. */
5737 static void peer_distribute_update(struct access_list
*access
)
5742 struct listnode
*mnode
, *mnnode
;
5743 struct listnode
*node
, *nnode
;
5746 struct peer_group
*group
;
5747 struct bgp_filter
*filter
;
5749 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5751 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
5752 access
->name
, 0, 0);
5753 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5754 FOREACH_AFI_SAFI (afi
, safi
) {
5755 filter
= &peer
->filter
[afi
][safi
];
5757 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5759 if (filter
->dlist
[direct
].name
)
5760 filter
->dlist
[direct
]
5761 .alist
= access_list_lookup(
5763 filter
->dlist
[direct
]
5766 filter
->dlist
[direct
].alist
=
5771 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5772 FOREACH_AFI_SAFI (afi
, safi
) {
5773 filter
= &group
->conf
->filter
[afi
][safi
];
5775 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5777 if (filter
->dlist
[direct
].name
)
5778 filter
->dlist
[direct
]
5779 .alist
= access_list_lookup(
5781 filter
->dlist
[direct
]
5784 filter
->dlist
[direct
].alist
=
5790 vnc_prefix_list_update(bgp
);
5795 /* Set prefix list to the peer. */
5796 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5799 struct peer
*member
;
5800 struct bgp_filter
*filter
;
5801 struct listnode
*node
, *nnode
;
5803 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5804 return BGP_ERR_INVALID_VALUE
;
5806 /* Set configuration on peer. */
5807 filter
= &peer
->filter
[afi
][safi
];
5808 if (filter
->dlist
[direct
].name
)
5809 return BGP_ERR_PEER_FILTER_CONFLICT
;
5810 if (filter
->plist
[direct
].name
)
5811 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5812 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5813 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5815 /* Check if handling a regular peer. */
5816 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5817 /* Set override-flag and process peer route updates. */
5818 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5819 PEER_FT_PREFIX_LIST
);
5820 peer_on_policy_change(peer
, afi
, safi
,
5821 (direct
== FILTER_OUT
) ? 1 : 0);
5823 /* Skip peer-group mechanics for regular peers. */
5828 * Set configuration on all peer-group members, unless they are
5829 * explicitely overriding peer-group configuration.
5831 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5832 /* Skip peers with overridden configuration. */
5833 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5834 PEER_FT_PREFIX_LIST
))
5837 /* Set configuration on peer-group member. */
5838 filter
= &member
->filter
[afi
][safi
];
5839 if (filter
->plist
[direct
].name
)
5840 XFREE(MTYPE_BGP_FILTER_NAME
,
5841 filter
->plist
[direct
].name
);
5842 filter
->plist
[direct
].name
=
5843 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5844 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5846 /* Process peer route updates. */
5847 peer_on_policy_change(member
, afi
, safi
,
5848 (direct
== FILTER_OUT
) ? 1 : 0);
5854 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
5857 struct peer
*member
;
5858 struct bgp_filter
*filter
;
5859 struct listnode
*node
, *nnode
;
5861 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5862 return BGP_ERR_INVALID_VALUE
;
5864 /* Unset override-flag unconditionally. */
5865 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5866 PEER_FT_PREFIX_LIST
);
5868 /* Inherit configuration from peer-group if peer is member. */
5869 if (peer_group_active(peer
)) {
5870 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5871 filter
[afi
][safi
].plist
[direct
].name
,
5872 MTYPE_BGP_FILTER_NAME
);
5873 PEER_ATTR_INHERIT(peer
, peer
->group
,
5874 filter
[afi
][safi
].plist
[direct
].plist
);
5876 /* Otherwise remove configuration from peer. */
5877 filter
= &peer
->filter
[afi
][safi
];
5878 if (filter
->plist
[direct
].name
)
5879 XFREE(MTYPE_BGP_FILTER_NAME
,
5880 filter
->plist
[direct
].name
);
5881 filter
->plist
[direct
].name
= NULL
;
5882 filter
->plist
[direct
].plist
= NULL
;
5885 /* Check if handling a regular peer. */
5886 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5887 /* Process peer route updates. */
5888 peer_on_policy_change(peer
, afi
, safi
,
5889 (direct
== FILTER_OUT
) ? 1 : 0);
5891 /* Skip peer-group mechanics for regular peers. */
5896 * Remove configuration on all peer-group members, unless they are
5897 * explicitely overriding peer-group configuration.
5899 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5900 /* Skip peers with overridden configuration. */
5901 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5902 PEER_FT_PREFIX_LIST
))
5905 /* Remove configuration on peer-group member. */
5906 filter
= &member
->filter
[afi
][safi
];
5907 if (filter
->plist
[direct
].name
)
5908 XFREE(MTYPE_BGP_FILTER_NAME
,
5909 filter
->plist
[direct
].name
);
5910 filter
->plist
[direct
].name
= NULL
;
5911 filter
->plist
[direct
].plist
= NULL
;
5913 /* Process peer route updates. */
5914 peer_on_policy_change(member
, afi
, safi
,
5915 (direct
== FILTER_OUT
) ? 1 : 0);
5921 /* Update prefix-list list. */
5922 static void peer_prefix_list_update(struct prefix_list
*plist
)
5924 struct listnode
*mnode
, *mnnode
;
5925 struct listnode
*node
, *nnode
;
5928 struct peer_group
*group
;
5929 struct bgp_filter
*filter
;
5934 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5937 * Update the prefix-list on update groups.
5939 update_group_policy_update(
5940 bgp
, BGP_POLICY_PREFIX_LIST
,
5941 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5943 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5944 FOREACH_AFI_SAFI (afi
, safi
) {
5945 filter
= &peer
->filter
[afi
][safi
];
5947 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5949 if (filter
->plist
[direct
].name
)
5950 filter
->plist
[direct
]
5951 .plist
= prefix_list_lookup(
5953 filter
->plist
[direct
]
5956 filter
->plist
[direct
].plist
=
5961 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5962 FOREACH_AFI_SAFI (afi
, safi
) {
5963 filter
= &group
->conf
->filter
[afi
][safi
];
5965 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5967 if (filter
->plist
[direct
].name
)
5968 filter
->plist
[direct
]
5969 .plist
= prefix_list_lookup(
5971 filter
->plist
[direct
]
5974 filter
->plist
[direct
].plist
=
5982 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5985 struct peer
*member
;
5986 struct bgp_filter
*filter
;
5987 struct listnode
*node
, *nnode
;
5989 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5990 return BGP_ERR_INVALID_VALUE
;
5992 /* Set configuration on peer. */
5993 filter
= &peer
->filter
[afi
][safi
];
5994 if (filter
->aslist
[direct
].name
)
5995 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5996 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5997 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
5999 /* Check if handling a regular peer. */
6000 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6001 /* Set override-flag and process peer route updates. */
6002 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6003 PEER_FT_FILTER_LIST
);
6004 peer_on_policy_change(peer
, afi
, safi
,
6005 (direct
== FILTER_OUT
) ? 1 : 0);
6007 /* Skip peer-group mechanics for regular peers. */
6012 * Set configuration on all peer-group members, unless they are
6013 * explicitely overriding peer-group configuration.
6015 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6016 /* Skip peers with overridden configuration. */
6017 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6018 PEER_FT_FILTER_LIST
))
6021 /* Set configuration on peer-group member. */
6022 filter
= &member
->filter
[afi
][safi
];
6023 if (filter
->aslist
[direct
].name
)
6024 XFREE(MTYPE_BGP_FILTER_NAME
,
6025 filter
->aslist
[direct
].name
);
6026 filter
->aslist
[direct
].name
=
6027 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6028 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6030 /* Process peer route updates. */
6031 peer_on_policy_change(member
, afi
, safi
,
6032 (direct
== FILTER_OUT
) ? 1 : 0);
6038 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6040 struct peer
*member
;
6041 struct bgp_filter
*filter
;
6042 struct listnode
*node
, *nnode
;
6044 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6045 return BGP_ERR_INVALID_VALUE
;
6047 /* Unset override-flag unconditionally. */
6048 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6049 PEER_FT_FILTER_LIST
);
6051 /* Inherit configuration from peer-group if peer is member. */
6052 if (peer_group_active(peer
)) {
6053 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6054 filter
[afi
][safi
].aslist
[direct
].name
,
6055 MTYPE_BGP_FILTER_NAME
);
6056 PEER_ATTR_INHERIT(peer
, peer
->group
,
6057 filter
[afi
][safi
].aslist
[direct
].aslist
);
6059 /* Otherwise remove configuration from peer. */
6060 filter
= &peer
->filter
[afi
][safi
];
6061 if (filter
->aslist
[direct
].name
)
6062 XFREE(MTYPE_BGP_FILTER_NAME
,
6063 filter
->aslist
[direct
].name
);
6064 filter
->aslist
[direct
].name
= NULL
;
6065 filter
->aslist
[direct
].aslist
= NULL
;
6068 /* Check if handling a regular peer. */
6069 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6070 /* Process peer route updates. */
6071 peer_on_policy_change(peer
, afi
, safi
,
6072 (direct
== FILTER_OUT
) ? 1 : 0);
6074 /* Skip peer-group mechanics for regular peers. */
6079 * Remove configuration on all peer-group members, unless they are
6080 * explicitely overriding peer-group configuration.
6082 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6083 /* Skip peers with overridden configuration. */
6084 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6085 PEER_FT_FILTER_LIST
))
6088 /* Remove configuration on peer-group member. */
6089 filter
= &member
->filter
[afi
][safi
];
6090 if (filter
->aslist
[direct
].name
)
6091 XFREE(MTYPE_BGP_FILTER_NAME
,
6092 filter
->aslist
[direct
].name
);
6093 filter
->aslist
[direct
].name
= NULL
;
6094 filter
->aslist
[direct
].aslist
= NULL
;
6096 /* Process peer route updates. */
6097 peer_on_policy_change(member
, afi
, safi
,
6098 (direct
== FILTER_OUT
) ? 1 : 0);
6104 static void peer_aslist_update(const char *aslist_name
)
6109 struct listnode
*mnode
, *mnnode
;
6110 struct listnode
*node
, *nnode
;
6113 struct peer_group
*group
;
6114 struct bgp_filter
*filter
;
6116 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6117 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
6120 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6121 FOREACH_AFI_SAFI (afi
, safi
) {
6122 filter
= &peer
->filter
[afi
][safi
];
6124 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6126 if (filter
->aslist
[direct
].name
)
6127 filter
->aslist
[direct
]
6128 .aslist
= as_list_lookup(
6129 filter
->aslist
[direct
]
6132 filter
->aslist
[direct
].aslist
=
6137 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6138 FOREACH_AFI_SAFI (afi
, safi
) {
6139 filter
= &group
->conf
->filter
[afi
][safi
];
6141 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6143 if (filter
->aslist
[direct
].name
)
6144 filter
->aslist
[direct
]
6145 .aslist
= as_list_lookup(
6146 filter
->aslist
[direct
]
6149 filter
->aslist
[direct
].aslist
=
6157 static void peer_aslist_add(char *aslist_name
)
6159 peer_aslist_update(aslist_name
);
6160 route_map_notify_dependencies((char *)aslist_name
,
6161 RMAP_EVENT_ASLIST_ADDED
);
6164 static void peer_aslist_del(const char *aslist_name
)
6166 peer_aslist_update(aslist_name
);
6167 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
6171 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6172 const char *name
, struct route_map
*route_map
)
6174 struct peer
*member
;
6175 struct bgp_filter
*filter
;
6176 struct listnode
*node
, *nnode
;
6178 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6179 return BGP_ERR_INVALID_VALUE
;
6181 /* Set configuration on peer. */
6182 filter
= &peer
->filter
[afi
][safi
];
6183 if (filter
->map
[direct
].name
) {
6184 /* If the neighbor is configured with the same route-map
6185 * again then, ignore the duplicate configuration.
6187 if (strcmp(filter
->map
[direct
].name
, name
) == 0)
6190 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6192 route_map_counter_decrement(filter
->map
[direct
].map
);
6193 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6194 filter
->map
[direct
].map
= route_map
;
6195 route_map_counter_increment(route_map
);
6197 /* Check if handling a regular peer. */
6198 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6199 /* Set override-flag and process peer route updates. */
6200 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6202 peer_on_policy_change(peer
, afi
, safi
,
6203 (direct
== RMAP_OUT
) ? 1 : 0);
6205 /* Skip peer-group mechanics for regular peers. */
6210 * Set configuration on all peer-group members, unless they are
6211 * explicitely overriding peer-group configuration.
6213 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6214 /* Skip peers with overridden configuration. */
6215 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6219 /* Set configuration on peer-group member. */
6220 filter
= &member
->filter
[afi
][safi
];
6221 if (filter
->map
[direct
].name
)
6222 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6223 route_map_counter_decrement(filter
->map
[direct
].map
);
6224 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6225 filter
->map
[direct
].map
= route_map
;
6226 route_map_counter_increment(route_map
);
6228 /* Process peer route updates. */
6229 peer_on_policy_change(member
, afi
, safi
,
6230 (direct
== RMAP_OUT
) ? 1 : 0);
6235 /* Unset route-map from the peer. */
6236 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6238 struct peer
*member
;
6239 struct bgp_filter
*filter
;
6240 struct listnode
*node
, *nnode
;
6242 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6243 return BGP_ERR_INVALID_VALUE
;
6245 /* Unset override-flag unconditionally. */
6246 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
6248 /* Inherit configuration from peer-group if peer is member. */
6249 if (peer_group_active(peer
)) {
6250 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6251 filter
[afi
][safi
].map
[direct
].name
,
6252 MTYPE_BGP_FILTER_NAME
);
6253 PEER_ATTR_INHERIT(peer
, peer
->group
,
6254 filter
[afi
][safi
].map
[direct
].map
);
6256 /* Otherwise remove configuration from peer. */
6257 filter
= &peer
->filter
[afi
][safi
];
6258 if (filter
->map
[direct
].name
)
6259 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6260 route_map_counter_decrement(filter
->map
[direct
].map
);
6261 filter
->map
[direct
].name
= NULL
;
6262 filter
->map
[direct
].map
= NULL
;
6265 /* Check if handling a regular peer. */
6266 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6267 /* Process peer route updates. */
6268 peer_on_policy_change(peer
, afi
, safi
,
6269 (direct
== RMAP_OUT
) ? 1 : 0);
6271 /* Skip peer-group mechanics for regular peers. */
6276 * Remove configuration on all peer-group members, unless they are
6277 * explicitely overriding peer-group configuration.
6279 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6280 /* Skip peers with overridden configuration. */
6281 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6285 /* Remove configuration on peer-group member. */
6286 filter
= &member
->filter
[afi
][safi
];
6287 if (filter
->map
[direct
].name
)
6288 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6289 route_map_counter_decrement(filter
->map
[direct
].map
);
6290 filter
->map
[direct
].name
= NULL
;
6291 filter
->map
[direct
].map
= NULL
;
6293 /* Process peer route updates. */
6294 peer_on_policy_change(member
, afi
, safi
,
6295 (direct
== RMAP_OUT
) ? 1 : 0);
6301 /* Set unsuppress-map to the peer. */
6302 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6303 const char *name
, struct route_map
*route_map
)
6305 struct peer
*member
;
6306 struct bgp_filter
*filter
;
6307 struct listnode
*node
, *nnode
;
6309 /* Set configuration on peer. */
6310 filter
= &peer
->filter
[afi
][safi
];
6311 if (filter
->usmap
.name
)
6312 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6313 route_map_counter_decrement(filter
->usmap
.map
);
6314 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6315 filter
->usmap
.map
= route_map
;
6316 route_map_counter_increment(route_map
);
6318 /* Check if handling a regular peer. */
6319 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6320 /* Set override-flag and process peer route updates. */
6321 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
6322 PEER_FT_UNSUPPRESS_MAP
);
6323 peer_on_policy_change(peer
, afi
, safi
, 1);
6325 /* Skip peer-group mechanics for regular peers. */
6330 * Set configuration on all peer-group members, unless they are
6331 * explicitely overriding peer-group configuration.
6333 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6334 /* Skip peers with overridden configuration. */
6335 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6336 PEER_FT_UNSUPPRESS_MAP
))
6339 /* Set configuration on peer-group member. */
6340 filter
= &member
->filter
[afi
][safi
];
6341 if (filter
->usmap
.name
)
6342 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6343 route_map_counter_decrement(filter
->usmap
.map
);
6344 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6345 filter
->usmap
.map
= route_map
;
6346 route_map_counter_increment(route_map
);
6348 /* Process peer route updates. */
6349 peer_on_policy_change(member
, afi
, safi
, 1);
6355 /* Unset route-map from the peer. */
6356 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6358 struct peer
*member
;
6359 struct bgp_filter
*filter
;
6360 struct listnode
*node
, *nnode
;
6362 /* Unset override-flag unconditionally. */
6363 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
6365 /* Inherit configuration from peer-group if peer is member. */
6366 if (peer_group_active(peer
)) {
6367 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6368 filter
[afi
][safi
].usmap
.name
,
6369 MTYPE_BGP_FILTER_NAME
);
6370 PEER_ATTR_INHERIT(peer
, peer
->group
,
6371 filter
[afi
][safi
].usmap
.map
);
6373 /* Otherwise remove configuration from peer. */
6374 filter
= &peer
->filter
[afi
][safi
];
6375 if (filter
->usmap
.name
)
6376 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6377 route_map_counter_decrement(filter
->usmap
.map
);
6378 filter
->usmap
.name
= NULL
;
6379 filter
->usmap
.map
= NULL
;
6382 /* Check if handling a regular peer. */
6383 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6384 /* Process peer route updates. */
6385 peer_on_policy_change(peer
, afi
, safi
, 1);
6387 /* Skip peer-group mechanics for regular peers. */
6392 * Remove configuration on all peer-group members, unless they are
6393 * explicitely overriding peer-group configuration.
6395 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6396 /* Skip peers with overridden configuration. */
6397 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6398 PEER_FT_UNSUPPRESS_MAP
))
6401 /* Remove configuration on peer-group member. */
6402 filter
= &member
->filter
[afi
][safi
];
6403 if (filter
->usmap
.name
)
6404 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6405 route_map_counter_decrement(filter
->usmap
.map
);
6406 filter
->usmap
.name
= NULL
;
6407 filter
->usmap
.map
= NULL
;
6409 /* Process peer route updates. */
6410 peer_on_policy_change(member
, afi
, safi
, 1);
6416 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6417 uint32_t max
, uint8_t threshold
, int warning
,
6420 struct peer
*member
;
6421 struct listnode
*node
, *nnode
;
6423 /* Set flags and configuration on peer. */
6424 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6426 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6428 peer_af_flag_unset(peer
, afi
, safi
,
6429 PEER_FLAG_MAX_PREFIX_WARNING
);
6431 peer
->pmax
[afi
][safi
] = max
;
6432 peer
->pmax_threshold
[afi
][safi
] = threshold
;
6433 peer
->pmax_restart
[afi
][safi
] = restart
;
6435 /* Check if handling a regular peer. */
6436 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6437 /* Re-check if peer violates maximum-prefix. */
6438 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6439 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
6441 /* Skip peer-group mechanics for regular peers. */
6446 * Set flags and configuration on all peer-group members, unless they
6447 * are explicitely overriding peer-group configuration.
6449 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6450 /* Skip peers with overridden configuration. */
6451 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6452 PEER_FLAG_MAX_PREFIX
))
6455 /* Set flag and configuration on peer-group member. */
6456 member
->pmax
[afi
][safi
] = max
;
6457 member
->pmax_threshold
[afi
][safi
] = threshold
;
6458 member
->pmax_restart
[afi
][safi
] = restart
;
6460 SET_FLAG(member
->af_flags
[afi
][safi
],
6461 PEER_FLAG_MAX_PREFIX_WARNING
);
6463 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6464 PEER_FLAG_MAX_PREFIX_WARNING
);
6466 /* Re-check if peer violates maximum-prefix. */
6467 if ((member
->status
== Established
) && (member
->afc
[afi
][safi
]))
6468 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
6474 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6476 /* Inherit configuration from peer-group if peer is member. */
6477 if (peer_group_active(peer
)) {
6478 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6479 peer_af_flag_inherit(peer
, afi
, safi
,
6480 PEER_FLAG_MAX_PREFIX_WARNING
);
6481 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
6482 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
6483 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
6488 /* Remove flags and configuration from peer. */
6489 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6490 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6491 peer
->pmax
[afi
][safi
] = 0;
6492 peer
->pmax_threshold
[afi
][safi
] = 0;
6493 peer
->pmax_restart
[afi
][safi
] = 0;
6496 * Remove flags and configuration from all peer-group members, unless
6497 * they are explicitely overriding peer-group configuration.
6499 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6500 struct peer
*member
;
6501 struct listnode
*node
;
6503 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6504 /* Skip peers with overridden configuration. */
6505 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6506 PEER_FLAG_MAX_PREFIX
))
6509 /* Remove flag and configuration on peer-group member.
6511 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6512 PEER_FLAG_MAX_PREFIX
);
6513 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6514 PEER_FLAG_MAX_PREFIX_WARNING
);
6515 member
->pmax
[afi
][safi
] = 0;
6516 member
->pmax_threshold
[afi
][safi
] = 0;
6517 member
->pmax_restart
[afi
][safi
] = 0;
6524 int is_ebgp_multihop_configured(struct peer
*peer
)
6526 struct peer_group
*group
;
6527 struct listnode
*node
, *nnode
;
6530 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6531 group
= peer
->group
;
6532 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
6533 && (group
->conf
->ttl
!= BGP_DEFAULT_TTL
))
6536 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
6537 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
6538 && (peer1
->ttl
!= BGP_DEFAULT_TTL
))
6542 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
6543 && (peer
->ttl
!= BGP_DEFAULT_TTL
))
6549 /* Set # of hops between us and BGP peer. */
6550 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
6552 struct peer_group
*group
;
6553 struct listnode
*node
, *nnode
;
6556 zlog_debug("peer_ttl_security_hops_set: set gtsm_hops to %d for %s",
6557 gtsm_hops
, peer
->host
);
6559 /* We cannot configure ttl-security hops when ebgp-multihop is already
6560 set. For non peer-groups, the check is simple. For peer-groups,
6562 slightly messy, because we need to check both the peer-group
6564 and all peer-group members for any trace of ebgp-multihop
6566 before actually applying the ttl-security rules. Cisco really made a
6567 mess of this configuration parameter, and OpenBGPD got it right.
6570 if ((peer
->gtsm_hops
== BGP_GTSM_HOPS_DISABLED
)
6571 && (peer
->sort
!= BGP_PEER_IBGP
)) {
6572 if (is_ebgp_multihop_configured(peer
))
6573 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6575 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6576 peer
->gtsm_hops
= gtsm_hops
;
6578 /* Calling ebgp multihop also resets the session.
6579 * On restart, NHT will get setup correctly as will the
6580 * min & max ttls on the socket. The return value is
6583 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
6588 group
= peer
->group
;
6589 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6591 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6593 /* Calling ebgp multihop also resets the
6595 * On restart, NHT will get setup correctly as
6597 * min & max ttls on the socket. The return
6601 peer_ebgp_multihop_set(peer
, MAXTTL
);
6605 /* Post the first gtsm setup or if its ibgp, maxttl setting
6607 * necessary, just set the minttl.
6609 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6610 peer
->gtsm_hops
= gtsm_hops
;
6613 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6614 MAXTTL
+ 1 - gtsm_hops
);
6615 if ((peer
->status
< Established
) && peer
->doppelganger
6616 && (peer
->doppelganger
->fd
>= 0))
6617 sockopt_minttl(peer
->su
.sa
.sa_family
,
6618 peer
->doppelganger
->fd
,
6619 MAXTTL
+ 1 - gtsm_hops
);
6621 group
= peer
->group
;
6622 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6624 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6626 /* Change setting of existing peer
6627 * established then change value (may break
6629 * not established yet (teardown session and
6631 * no session then do nothing (will get
6632 * handled by next connection)
6636 != BGP_GTSM_HOPS_DISABLED
)
6638 peer
->su
.sa
.sa_family
, peer
->fd
,
6639 MAXTTL
+ 1 - peer
->gtsm_hops
);
6640 if ((peer
->status
< Established
)
6641 && peer
->doppelganger
6642 && (peer
->doppelganger
->fd
>= 0))
6643 sockopt_minttl(peer
->su
.sa
.sa_family
,
6644 peer
->doppelganger
->fd
,
6645 MAXTTL
+ 1 - gtsm_hops
);
6653 int peer_ttl_security_hops_unset(struct peer
*peer
)
6655 struct peer_group
*group
;
6656 struct listnode
*node
, *nnode
;
6659 zlog_debug("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s",
6662 /* if a peer-group member, then reset to peer-group default rather than
6664 if (peer_group_active(peer
))
6665 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6667 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
6669 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6670 /* Invoking ebgp_multihop_set will set the TTL back to the
6672 * value as well as restting the NHT and such. The session is
6675 if (peer
->sort
== BGP_PEER_EBGP
)
6676 ret
= peer_ebgp_multihop_unset(peer
);
6679 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6682 if ((peer
->status
< Established
) && peer
->doppelganger
6683 && (peer
->doppelganger
->fd
>= 0))
6684 sockopt_minttl(peer
->su
.sa
.sa_family
,
6685 peer
->doppelganger
->fd
, 0);
6688 group
= peer
->group
;
6689 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
6690 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
6691 if (peer
->sort
== BGP_PEER_EBGP
)
6692 ret
= peer_ebgp_multihop_unset(peer
);
6695 sockopt_minttl(peer
->su
.sa
.sa_family
,
6698 if ((peer
->status
< Established
)
6699 && peer
->doppelganger
6700 && (peer
->doppelganger
->fd
>= 0))
6701 sockopt_minttl(peer
->su
.sa
.sa_family
,
6702 peer
->doppelganger
->fd
,
6712 * If peer clear is invoked in a loop for all peers on the BGP instance,
6713 * it may end up freeing the doppelganger, and if this was the next node
6714 * to the current node, we would end up accessing the freed next node.
6715 * Pass along additional parameter which can be updated if next node
6716 * is freed; only required when walking the peer list on BGP instance.
6718 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
6720 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)) {
6721 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
)) {
6722 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6723 if (peer
->t_pmax_restart
) {
6724 BGP_TIMER_OFF(peer
->t_pmax_restart
);
6725 if (bgp_debug_neighbor_events(peer
))
6727 "%s Maximum-prefix restart timer canceled",
6730 BGP_EVENT_ADD(peer
, BGP_Start
);
6734 peer
->v_start
= BGP_INIT_START_TIMER
;
6735 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6736 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6737 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6739 bgp_session_reset_safe(peer
, nnode
);
6744 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
6745 enum bgp_clear_type stype
)
6747 struct peer_af
*paf
;
6749 if (peer
->status
!= Established
)
6752 if (!peer
->afc
[afi
][safi
])
6753 return BGP_ERR_AF_UNCONFIGURED
;
6755 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
6757 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
6758 /* Clear the "neighbor x.x.x.x default-originate" flag */
6759 paf
= peer_af_find(peer
, afi
, safi
);
6760 if (paf
&& paf
->subgroup
6761 && CHECK_FLAG(paf
->subgroup
->sflags
,
6762 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6763 UNSET_FLAG(paf
->subgroup
->sflags
,
6764 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6766 bgp_announce_route(peer
, afi
, safi
);
6769 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6770 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6771 PEER_CAP_ORF_PREFIX_SM_ADV
)
6772 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6773 PEER_CAP_ORF_PREFIX_RM_RCV
)
6774 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6775 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
6776 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6777 uint8_t prefix_type
;
6779 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6780 PEER_CAP_ORF_PREFIX_RM_RCV
))
6781 prefix_type
= ORF_TYPE_PREFIX
;
6783 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6785 if (filter
->plist
[FILTER_IN
].plist
) {
6786 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6787 PEER_STATUS_ORF_PREFIX_SEND
))
6788 bgp_route_refresh_send(
6789 peer
, afi
, safi
, prefix_type
,
6791 bgp_route_refresh_send(peer
, afi
, safi
,
6793 REFRESH_IMMEDIATE
, 0);
6795 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6796 PEER_STATUS_ORF_PREFIX_SEND
))
6797 bgp_route_refresh_send(
6798 peer
, afi
, safi
, prefix_type
,
6799 REFRESH_IMMEDIATE
, 1);
6801 bgp_route_refresh_send(peer
, afi
, safi
,
6808 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6809 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6810 /* If neighbor has soft reconfiguration inbound flag.
6811 Use Adj-RIB-In database. */
6812 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6813 PEER_FLAG_SOFT_RECONFIG
))
6814 bgp_soft_reconfig_in(peer
, afi
, safi
);
6816 /* If neighbor has route refresh capability, send route
6818 message to the peer. */
6819 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6820 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6821 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0,
6824 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6830 /* Display peer uptime.*/
6831 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, bool use_json
,
6834 time_t uptime1
, epoch_tbuf
;
6837 /* If there is no connection has been done before print `never'. */
6840 json_object_string_add(json
, "peerUptime", "never");
6841 json_object_int_add(json
, "peerUptimeMsec", 0);
6843 snprintf(buf
, len
, "never");
6847 /* Get current time. */
6848 uptime1
= bgp_clock();
6850 tm
= gmtime(&uptime1
);
6852 if (uptime1
< ONE_DAY_SECOND
)
6853 snprintf(buf
, len
, "%02d:%02d:%02d", tm
->tm_hour
, tm
->tm_min
,
6855 else if (uptime1
< ONE_WEEK_SECOND
)
6856 snprintf(buf
, len
, "%dd%02dh%02dm", tm
->tm_yday
, tm
->tm_hour
,
6858 else if (uptime1
< ONE_YEAR_SECOND
)
6859 snprintf(buf
, len
, "%02dw%dd%02dh", tm
->tm_yday
/ 7,
6860 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7), tm
->tm_hour
);
6862 snprintf(buf
, len
, "%02dy%02dw%dd", tm
->tm_year
- 70,
6864 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7));
6867 epoch_tbuf
= time(NULL
) - uptime1
;
6868 json_object_string_add(json
, "peerUptime", buf
);
6869 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
6870 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
6877 void bgp_master_init(struct thread_master
*master
, const int buffer_size
)
6881 memset(&bgp_master
, 0, sizeof(struct bgp_master
));
6884 bm
->bgp
= list_new();
6885 bm
->listen_sockets
= list_new();
6886 bm
->port
= BGP_PORT_DEFAULT
;
6887 bm
->master
= master
;
6888 bm
->start_time
= bgp_clock();
6889 bm
->t_rmap_update
= NULL
;
6890 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
6891 bm
->terminating
= false;
6892 bm
->socket_buffer
= buffer_size
;
6894 bgp_process_queue_init();
6897 /* init the rd id space.
6898 assign 0th index in the bitfield,
6899 so that we start with id 1
6901 bf_init(bm
->rd_idspace
, UINT16_MAX
);
6902 bf_assign_zero_index(bm
->rd_idspace
);
6904 /* mpls label dynamic allocation pool */
6905 bgp_lp_init(bm
->master
, &bm
->labelpool
);
6907 QOBJ_REG(bm
, bgp_master
);
6911 * Free up connected routes and interfaces for a BGP instance. Invoked upon
6912 * instance delete (non-default only) or BGP exit.
6914 static void bgp_if_finish(struct bgp
*bgp
)
6917 struct interface
*ifp
;
6919 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
6921 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
6924 FOR_ALL_INTERFACES (vrf
, ifp
) {
6925 struct listnode
*c_node
, *c_nnode
;
6926 struct connected
*c
;
6928 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
6929 bgp_connected_delete(bgp
, c
);
6933 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
6935 struct vrf
*vrf
= NULL
;
6936 struct listnode
*next
;
6939 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
6940 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
6942 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
6943 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
6946 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
6950 static void bgp_instasn_autocomplete(vector comps
, struct cmd_token
*token
)
6952 struct listnode
*next
, *next2
;
6953 struct bgp
*bgp
, *bgp2
;
6956 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
6958 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next2
, bgp2
)) {
6959 if (bgp2
->as
== bgp
->as
)
6967 snprintf(buf
, sizeof(buf
), "%u", bgp
->as
);
6968 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, buf
));
6972 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
6973 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
6974 {.varname
= "instasn", .completions
= bgp_instasn_autocomplete
},
6975 {.completions
= NULL
},
6978 struct frr_pthread
*bgp_pth_io
;
6979 struct frr_pthread
*bgp_pth_ka
;
6981 static void bgp_pthreads_init(void)
6983 assert(!bgp_pth_io
);
6984 assert(!bgp_pth_ka
);
6986 struct frr_pthread_attr io
= {
6987 .start
= frr_pthread_attr_default
.start
,
6988 .stop
= frr_pthread_attr_default
.stop
,
6990 struct frr_pthread_attr ka
= {
6991 .start
= bgp_keepalives_start
,
6992 .stop
= bgp_keepalives_stop
,
6994 bgp_pth_io
= frr_pthread_new(&io
, "BGP I/O thread", "bgpd_io");
6995 bgp_pth_ka
= frr_pthread_new(&ka
, "BGP Keepalives thread", "bgpd_ka");
6998 void bgp_pthreads_run(void)
7000 frr_pthread_run(bgp_pth_io
, NULL
);
7001 frr_pthread_run(bgp_pth_ka
, NULL
);
7003 /* Wait until threads are ready. */
7004 frr_pthread_wait_running(bgp_pth_io
);
7005 frr_pthread_wait_running(bgp_pth_ka
);
7008 void bgp_pthreads_finish(void)
7010 frr_pthread_stop_all();
7013 void bgp_init(unsigned short instance
)
7016 /* allocates some vital data structures used by peer commands in
7019 /* pre-init pthreads */
7020 bgp_pthreads_init();
7023 bgp_zebra_init(bm
->master
, instance
);
7026 vnc_zebra_init(bm
->master
);
7029 /* BGP VTY commands installation. */
7037 bgp_route_map_init();
7038 bgp_scan_vty_init();
7043 bgp_ethernetvpn_init();
7044 bgp_flowspec_vty_init();
7046 /* Access list initialize. */
7048 access_list_add_hook(peer_distribute_update
);
7049 access_list_delete_hook(peer_distribute_update
);
7051 /* Filter list initialize. */
7053 as_list_add_hook(peer_aslist_add
);
7054 as_list_delete_hook(peer_aslist_del
);
7056 /* Prefix list initialize.*/
7058 prefix_list_add_hook(peer_prefix_list_update
);
7059 prefix_list_delete_hook(peer_prefix_list_update
);
7061 /* Community list initialize. */
7062 bgp_clist
= community_list_init();
7067 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
7070 void bgp_terminate(void)
7074 struct listnode
*node
, *nnode
;
7075 struct listnode
*mnode
, *mnnode
;
7079 /* Close the listener sockets first as this prevents peers from
7081 * to reconnect on receiving the peer unconfig message. In the presence
7082 * of a large number of peers this will ensure that no peer is left with
7083 * a dangling connection
7085 /* reverse bgp_master_init */
7088 if (bm
->listen_sockets
)
7089 list_delete(&bm
->listen_sockets
);
7091 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
))
7092 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
7093 if (peer
->status
== Established
7094 || peer
->status
== OpenSent
7095 || peer
->status
== OpenConfirm
)
7096 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7097 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7099 if (bm
->process_main_queue
)
7100 work_queue_free_and_null(&bm
->process_main_queue
);
7102 if (bm
->t_rmap_update
)
7103 BGP_TIMER_OFF(bm
->t_rmap_update
);
7108 struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
7109 const char *ip_str
, bool use_json
)
7115 /* Get peer sockunion. */
7116 ret
= str2sockunion(ip_str
, &su
);
7118 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
7120 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
7124 json_object
*json_no
= NULL
;
7125 json_no
= json_object_new_object();
7126 json_object_string_add(
7128 "malformedAddressOrName",
7130 vty_out(vty
, "%s\n",
7131 json_object_to_json_string_ext(
7133 JSON_C_TO_STRING_PRETTY
));
7134 json_object_free(json_no
);
7137 "%% Malformed address or name: %s\n",
7145 /* Peer structure lookup. */
7146 peer
= peer_lookup(bgp
, &su
);
7149 json_object
*json_no
= NULL
;
7150 json_no
= json_object_new_object();
7151 json_object_string_add(json_no
, "warning",
7152 "No such neighbor in this view/vrf");
7153 vty_out(vty
, "%s\n",
7154 json_object_to_json_string_ext(
7155 json_no
, JSON_C_TO_STRING_PRETTY
));
7156 json_object_free(json_no
);
7158 vty_out(vty
, "No such neighbor in this view/vrf\n");
7165 void bgp_gr_apply_running_config(void)
7167 struct peer
*peer
= NULL
;
7168 struct bgp
*bgp
= NULL
;
7169 struct listnode
*node
, *nnode
;
7170 bool gr_router_detected
= false;
7172 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
7173 zlog_debug("[BGP_GR] %s called !", __func__
);
7175 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
7176 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7177 bgp_peer_gr_flags_update(peer
);
7178 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
))
7179 gr_router_detected
= true;
7182 if (gr_router_detected
7183 && bgp
->present_zebra_gr_state
== ZEBRA_GR_DISABLE
) {
7184 bgp_zebra_send_capabilities(bgp
, true);
7185 } else if (!gr_router_detected
7186 && bgp
->present_zebra_gr_state
== ZEBRA_GR_ENABLE
) {
7187 bgp_zebra_send_capabilities(bgp
, false);
7190 gr_router_detected
= false;