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_community.h"
56 #include "bgpd/bgp_attr.h"
57 #include "bgpd/bgp_regex.h"
58 #include "bgpd/bgp_clist.h"
59 #include "bgpd/bgp_fsm.h"
60 #include "bgpd/bgp_packet.h"
61 #include "bgpd/bgp_zebra.h"
62 #include "bgpd/bgp_open.h"
63 #include "bgpd/bgp_filter.h"
64 #include "bgpd/bgp_nexthop.h"
65 #include "bgpd/bgp_damp.h"
66 #include "bgpd/bgp_mplsvpn.h"
68 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
69 #include "bgpd/rfapi/rfapi_backend.h"
71 #include "bgpd/bgp_evpn.h"
72 #include "bgpd/bgp_advertise.h"
73 #include "bgpd/bgp_network.h"
74 #include "bgpd/bgp_vty.h"
75 #include "bgpd/bgp_mpath.h"
76 #include "bgpd/bgp_nht.h"
77 #include "bgpd/bgp_updgrp.h"
78 #include "bgpd/bgp_bfd.h"
79 #include "bgpd/bgp_memory.h"
80 #include "bgpd/bgp_evpn_vty.h"
81 #include "bgpd/bgp_keepalives.h"
82 #include "bgpd/bgp_io.h"
83 #include "bgpd/bgp_ecommunity.h"
84 #include "bgpd/bgp_flowspec.h"
85 #include "bgpd/bgp_labelpool.h"
86 #include "bgpd/bgp_pbr.h"
88 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
89 DEFINE_QOBJ_TYPE(bgp_master
)
91 DEFINE_QOBJ_TYPE(peer
)
93 /* BGP process wide configuration. */
94 static struct bgp_master bgp_master
;
96 /* BGP process wide configuration pointer to export. */
97 struct bgp_master
*bm
;
99 /* BGP community-list. */
100 struct community_list_handler
*bgp_clist
;
102 unsigned int multipath_num
= MULTIPATH_NUM
;
104 static void bgp_if_finish(struct bgp
*bgp
);
105 static void peer_drop_dynamic_neighbor(struct peer
*peer
);
107 extern struct zclient
*zclient
;
109 /* handle main socket creation or deletion */
110 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
112 static int bgp_server_main_created
;
114 if (create
== true) {
115 if (bgp_server_main_created
)
117 if (bgp_socket(bgp
, bm
->port
, bm
->address
) < 0)
118 return BGP_ERR_INVALID_VALUE
;
119 bgp_server_main_created
= 1;
122 if (!bgp_server_main_created
)
125 bgp_server_main_created
= 0;
129 void bgp_session_reset(struct peer
*peer
)
131 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
132 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
133 peer_delete(peer
->doppelganger
);
135 BGP_EVENT_ADD(peer
, BGP_Stop
);
139 * During session reset, we may delete the doppelganger peer, which would
140 * be the next node to the current node. If the session reset was invoked
141 * during walk of peer list, we would end up accessing the freed next
142 * node. This function moves the next node along.
144 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
149 n
= (nnode
) ? *nnode
: NULL
;
150 npeer
= (n
) ? listgetdata(n
) : NULL
;
152 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
153 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
154 PEER_FLAG_CONFIG_NODE
))) {
155 if (peer
->doppelganger
== npeer
)
156 /* nnode and *nnode are confirmed to be non-NULL here */
157 *nnode
= (*nnode
)->next
;
158 peer_delete(peer
->doppelganger
);
161 BGP_EVENT_ADD(peer
, BGP_Stop
);
164 /* BGP global flag manipulation. */
165 int bgp_option_set(int flag
)
169 case BGP_OPT_MULTIPLE_INSTANCE
:
170 case BGP_OPT_CONFIG_CISCO
:
171 case BGP_OPT_NO_LISTEN
:
172 SET_FLAG(bm
->options
, flag
);
175 return BGP_ERR_INVALID_FLAG
;
180 int bgp_option_unset(int flag
)
183 case BGP_OPT_MULTIPLE_INSTANCE
:
184 if (listcount(bm
->bgp
) > 1)
185 return BGP_ERR_MULTIPLE_INSTANCE_USED
;
188 case BGP_OPT_CONFIG_CISCO
:
189 UNSET_FLAG(bm
->options
, flag
);
192 return BGP_ERR_INVALID_FLAG
;
197 int bgp_option_check(int flag
)
199 return CHECK_FLAG(bm
->options
, flag
);
202 /* BGP flag manipulation. */
203 int bgp_flag_set(struct bgp
*bgp
, int flag
)
205 SET_FLAG(bgp
->flags
, flag
);
209 int bgp_flag_unset(struct bgp
*bgp
, int flag
)
211 UNSET_FLAG(bgp
->flags
, flag
);
215 int bgp_flag_check(struct bgp
*bgp
, int flag
)
217 return CHECK_FLAG(bgp
->flags
, flag
);
220 /* Internal function to set BGP structure configureation flag. */
221 static void bgp_config_set(struct bgp
*bgp
, int config
)
223 SET_FLAG(bgp
->config
, config
);
226 static void bgp_config_unset(struct bgp
*bgp
, int config
)
228 UNSET_FLAG(bgp
->config
, config
);
231 static int bgp_config_check(struct bgp
*bgp
, int config
)
233 return CHECK_FLAG(bgp
->config
, config
);
236 /* Set BGP router identifier. */
237 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
)
240 struct listnode
*node
, *nnode
;
242 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
245 /* EVPN uses router id in RD, withdraw them */
246 if (is_evpn_enabled())
247 bgp_evpn_handle_router_id_update(bgp
, TRUE
);
249 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
251 /* Set all peer's local identifier with this value. */
252 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
253 IPV4_ADDR_COPY(&peer
->local_id
, id
);
255 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
256 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
257 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
258 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
262 /* EVPN uses router id in RD, update them */
263 if (is_evpn_enabled())
264 bgp_evpn_handle_router_id_update(bgp
, FALSE
);
269 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
271 struct listnode
*node
, *nnode
;
274 if (vrf_id
== VRF_DEFAULT
) {
275 /* Router-id change for default VRF has to also update all
277 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
278 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
281 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
282 if (!bgp
->router_id_static
.s_addr
)
283 bgp_router_id_set(bgp
, &router_id
->u
.prefix4
);
286 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
288 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
290 if (!bgp
->router_id_static
.s_addr
)
291 bgp_router_id_set(bgp
, &router_id
->u
.prefix4
);
296 int bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
298 bgp
->router_id_static
= id
;
299 bgp_router_id_set(bgp
, id
.s_addr
? &id
: &bgp
->router_id_zebra
);
303 /* BGP's cluster-id control. */
304 int bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
307 struct listnode
*node
, *nnode
;
309 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
310 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
313 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
314 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
316 /* Clear all IBGP peer. */
317 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
318 if (peer
->sort
!= BGP_PEER_IBGP
)
321 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
322 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
323 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
324 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
330 int bgp_cluster_id_unset(struct bgp
*bgp
)
333 struct listnode
*node
, *nnode
;
335 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
338 bgp
->cluster_id
.s_addr
= 0;
339 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
341 /* Clear all IBGP peer. */
342 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
343 if (peer
->sort
!= BGP_PEER_IBGP
)
346 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
347 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
348 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
349 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
355 /* time_t value that is monotonicly increasing
356 * and uneffected by adjustments to system clock
358 time_t bgp_clock(void)
366 /* BGP timer configuration. */
367 int bgp_timers_set(struct bgp
*bgp
, uint32_t keepalive
, uint32_t holdtime
)
369 bgp
->default_keepalive
=
370 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
371 bgp
->default_holdtime
= holdtime
;
376 int bgp_timers_unset(struct bgp
*bgp
)
378 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
379 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
384 /* BGP confederation configuration. */
385 int bgp_confederation_id_set(struct bgp
*bgp
, as_t as
)
388 struct listnode
*node
, *nnode
;
392 return BGP_ERR_INVALID_AS
;
394 /* Remember - were we doing confederation before? */
395 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
397 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
399 /* If we were doing confederation already, this is just an external
400 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
401 were not doing confederation before, reset all EBGP sessions. */
402 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
403 /* We're looking for peers who's AS is not local or part of our
405 if (already_confed
) {
406 if (peer_sort(peer
) == BGP_PEER_EBGP
) {
408 if (BGP_IS_VALID_STATE_FOR_NOTIF(
411 PEER_DOWN_CONFED_ID_CHANGE
;
413 peer
, BGP_NOTIFY_CEASE
,
414 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
416 bgp_session_reset_safe(peer
, &nnode
);
419 /* Not doign confederation before, so reset every
422 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
423 /* Reset the local_as to be our EBGP one */
424 if (peer_sort(peer
) == BGP_PEER_EBGP
)
426 if (BGP_IS_VALID_STATE_FOR_NOTIF(
429 PEER_DOWN_CONFED_ID_CHANGE
;
431 peer
, BGP_NOTIFY_CEASE
,
432 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
434 bgp_session_reset_safe(peer
, &nnode
);
441 int bgp_confederation_id_unset(struct bgp
*bgp
)
444 struct listnode
*node
, *nnode
;
447 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
449 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
450 /* We're looking for peers who's AS is not local */
451 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
452 peer
->local_as
= bgp
->as
;
453 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
454 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
455 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
456 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
460 bgp_session_reset_safe(peer
, &nnode
);
466 /* Is an AS part of the confed or not? */
467 int bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
474 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
475 if (bgp
->confed_peers
[i
] == as
)
481 /* Add an AS to the confederation set. */
482 int bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
)
485 struct listnode
*node
, *nnode
;
488 return BGP_ERR_INVALID_BGP
;
491 return BGP_ERR_INVALID_AS
;
493 if (bgp_confederation_peers_check(bgp
, as
))
496 if (bgp
->confed_peers
)
498 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
499 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
502 XMALLOC(MTYPE_BGP_CONFED_LIST
,
503 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
505 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
506 bgp
->confed_peers_cnt
++;
508 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
509 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
510 if (peer
->as
== as
) {
511 peer
->local_as
= bgp
->as
;
512 if (BGP_IS_VALID_STATE_FOR_NOTIF(
515 PEER_DOWN_CONFED_PEER_CHANGE
;
517 peer
, BGP_NOTIFY_CEASE
,
518 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
520 bgp_session_reset_safe(peer
, &nnode
);
527 /* Delete an AS from the confederation set. */
528 int bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
533 struct listnode
*node
, *nnode
;
538 if (!bgp_confederation_peers_check(bgp
, as
))
541 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
542 if (bgp
->confed_peers
[i
] == as
)
543 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
544 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
546 bgp
->confed_peers_cnt
--;
548 if (bgp
->confed_peers_cnt
== 0) {
549 if (bgp
->confed_peers
)
550 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
551 bgp
->confed_peers
= NULL
;
554 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
555 bgp
->confed_peers_cnt
* sizeof(as_t
));
557 /* Now reset any peer who's remote AS has just been removed from the
559 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
560 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
561 if (peer
->as
== as
) {
562 peer
->local_as
= bgp
->confed_id
;
563 if (BGP_IS_VALID_STATE_FOR_NOTIF(
566 PEER_DOWN_CONFED_PEER_CHANGE
;
568 peer
, BGP_NOTIFY_CEASE
,
569 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
571 bgp_session_reset_safe(peer
, &nnode
);
579 /* Local preference configuration. */
580 int bgp_default_local_preference_set(struct bgp
*bgp
, uint32_t local_pref
)
585 bgp
->default_local_pref
= local_pref
;
590 int bgp_default_local_preference_unset(struct bgp
*bgp
)
595 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
600 /* Local preference configuration. */
601 int bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
, uint32_t queue_size
)
606 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
611 int bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
615 bgp
->default_subgroup_pkt_queue_max
=
616 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
621 /* Listen limit configuration. */
622 int bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
627 bgp
->dynamic_neighbors_limit
= listen_limit
;
632 int bgp_listen_limit_unset(struct bgp
*bgp
)
637 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
642 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
643 afi_t
*afi
, safi_t
*safi
)
645 /* Map from IANA values to internal values, return error if
646 * values are unrecognized.
648 *afi
= afi_iana2int(pkt_afi
);
649 *safi
= safi_iana2int(pkt_safi
);
650 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
656 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
657 iana_safi_t
*pkt_safi
)
659 /* Map from internal values to IANA values, return error if
660 * internal values are bad (unexpected).
662 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
664 *pkt_afi
= afi_int2iana(afi
);
665 *pkt_safi
= safi_int2iana(safi
);
669 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
677 afid
= afindex(afi
, safi
);
678 if (afid
>= BGP_AF_MAX
)
681 assert(peer
->peer_af_array
[afid
] == NULL
);
683 /* Allocate new peer af */
684 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
687 zlog_err("Could not create af structure for peer %s",
692 peer
->peer_af_array
[afid
] = af
;
701 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
708 afid
= afindex(afi
, safi
);
709 if (afid
>= BGP_AF_MAX
)
712 return peer
->peer_af_array
[afid
];
715 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
723 afid
= afindex(afi
, safi
);
724 if (afid
>= BGP_AF_MAX
)
727 af
= peer
->peer_af_array
[afid
];
731 bgp_stop_announce_route_timer(af
);
733 if (PAF_SUBGRP(af
)) {
734 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
735 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
736 af
->subgroup
->update_group
->id
,
737 af
->subgroup
->id
, peer
->host
);
740 update_subgroup_remove_peer(af
->subgroup
, af
);
742 peer
->peer_af_array
[afid
] = NULL
;
743 XFREE(MTYPE_BGP_PEER_AF
, af
);
747 /* Peer comparison function for sorting. */
748 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
750 if (p1
->group
&& !p2
->group
)
753 if (!p1
->group
&& p2
->group
)
756 if (p1
->group
== p2
->group
) {
757 if (p1
->conf_if
&& !p2
->conf_if
)
760 if (!p1
->conf_if
&& p2
->conf_if
)
763 if (p1
->conf_if
&& p2
->conf_if
)
764 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
766 return strcmp(p1
->group
->name
, p2
->group
->name
);
768 return sockunion_cmp(&p1
->su
, &p2
->su
);
771 static unsigned int peer_hash_key_make(void *p
)
773 struct peer
*peer
= p
;
774 return sockunion_hash(&peer
->su
);
777 static int peer_hash_same(const void *p1
, const void *p2
)
779 const struct peer
*peer1
= p1
;
780 const struct peer
*peer2
= p2
;
781 return (sockunion_same(&peer1
->su
, &peer2
->su
)
782 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
783 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
786 void peer_flag_inherit(struct peer
*peer
, uint32_t flag
)
790 /* Skip if peer is not a peer-group member. */
791 if (!peer_group_active(peer
))
794 /* Unset override flag to signal inheritance from peer-group. */
795 UNSET_FLAG(peer
->flags_override
, flag
);
798 * Inherit flag state from peer-group. If the flag of the peer-group is
799 * not being inverted, the peer must inherit the inverse of the current
800 * peer-group flag state.
802 group_val
= CHECK_FLAG(peer
->group
->conf
->flags
, flag
);
803 if (!CHECK_FLAG(peer
->group
->conf
->flags_invert
, flag
)
804 && CHECK_FLAG(peer
->flags_invert
, flag
))
805 COND_FLAG(peer
->flags
, flag
, !group_val
);
807 COND_FLAG(peer
->flags
, flag
, group_val
);
810 int peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
812 return CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
815 void peer_af_flag_inherit(struct peer
*peer
, afi_t afi
, safi_t safi
,
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
->af_flags_override
[afi
][safi
], 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
->af_flags
[afi
][safi
], flag
);
833 if (!CHECK_FLAG(peer
->group
->conf
->af_flags_invert
[afi
][safi
], flag
)
834 && CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
835 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, !group_val
);
837 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, group_val
);
840 static bool peergroup_flag_check(struct peer
*peer
, uint32_t flag
)
842 if (!peer_group_active(peer
)) {
843 if (CHECK_FLAG(peer
->flags_invert
, flag
))
844 return !CHECK_FLAG(peer
->flags
, flag
);
846 return !!CHECK_FLAG(peer
->flags
, flag
);
849 return !!CHECK_FLAG(peer
->flags_override
, flag
);
852 static bool peergroup_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
,
855 if (!peer_group_active(peer
)) {
856 if (CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
857 return !peer_af_flag_check(peer
, afi
, safi
, flag
);
859 return !!peer_af_flag_check(peer
, afi
, safi
, flag
);
862 return !!CHECK_FLAG(peer
->af_flags_override
[afi
][safi
], flag
);
865 static bool peergroup_filter_check(struct peer
*peer
, afi_t afi
, safi_t safi
,
866 uint8_t type
, int direct
)
868 struct bgp_filter
*filter
;
870 if (peer_group_active(peer
))
871 return !!CHECK_FLAG(peer
->filter_override
[afi
][safi
][direct
],
874 filter
= &peer
->filter
[afi
][safi
];
876 case PEER_FT_DISTRIBUTE_LIST
:
877 return !!(filter
->dlist
[direct
].name
);
878 case PEER_FT_FILTER_LIST
:
879 return !!(filter
->aslist
[direct
].name
);
880 case PEER_FT_PREFIX_LIST
:
881 return !!(filter
->plist
[direct
].name
);
882 case PEER_FT_ROUTE_MAP
:
883 return !!(filter
->map
[direct
].name
);
884 case PEER_FT_UNSUPPRESS_MAP
:
885 return !!(filter
->usmap
.name
);
891 /* Reset all address family specific configuration. */
892 static void peer_af_flag_reset(struct peer
*peer
, afi_t afi
, safi_t safi
)
895 struct bgp_filter
*filter
;
896 char orf_name
[BUFSIZ
];
898 filter
= &peer
->filter
[afi
][safi
];
900 /* Clear neighbor filter and route-map */
901 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
902 if (filter
->dlist
[i
].name
) {
903 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
904 filter
->dlist
[i
].name
= NULL
;
906 if (filter
->plist
[i
].name
) {
907 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
908 filter
->plist
[i
].name
= NULL
;
910 if (filter
->aslist
[i
].name
) {
911 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
912 filter
->aslist
[i
].name
= NULL
;
915 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
916 if (filter
->map
[i
].name
) {
917 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
918 filter
->map
[i
].name
= NULL
;
922 /* Clear unsuppress map. */
923 if (filter
->usmap
.name
)
924 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
925 filter
->usmap
.name
= NULL
;
926 filter
->usmap
.map
= NULL
;
928 /* Clear neighbor's all address family flags. */
929 peer
->af_flags
[afi
][safi
] = 0;
931 /* Clear neighbor's all address family sflags. */
932 peer
->af_sflags
[afi
][safi
] = 0;
934 /* Clear neighbor's all address family capabilities. */
935 peer
->af_cap
[afi
][safi
] = 0;
938 peer
->orf_plist
[afi
][safi
] = NULL
;
939 sprintf(orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
940 prefix_bgp_orf_remove_all(afi
, orf_name
);
942 /* Set default neighbor send-community. */
943 if (!bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
944 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
945 SET_FLAG(peer
->af_flags
[afi
][safi
],
946 PEER_FLAG_SEND_EXT_COMMUNITY
);
947 SET_FLAG(peer
->af_flags
[afi
][safi
],
948 PEER_FLAG_SEND_LARGE_COMMUNITY
);
950 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
951 PEER_FLAG_SEND_COMMUNITY
);
952 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
953 PEER_FLAG_SEND_EXT_COMMUNITY
);
954 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
955 PEER_FLAG_SEND_LARGE_COMMUNITY
);
958 /* Clear neighbor default_originate_rmap */
959 if (peer
->default_rmap
[afi
][safi
].name
)
960 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
961 peer
->default_rmap
[afi
][safi
].name
= NULL
;
962 peer
->default_rmap
[afi
][safi
].map
= NULL
;
964 /* Clear neighbor maximum-prefix */
965 peer
->pmax
[afi
][safi
] = 0;
966 peer
->pmax_threshold
[afi
][safi
] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT
;
969 /* peer global config reset */
970 static void peer_global_config_reset(struct peer
*peer
)
974 peer
->change_local_as
= 0;
975 peer
->ttl
= (peer_sort(peer
) == BGP_PEER_IBGP
? MAXTTL
: 1);
976 if (peer
->update_source
) {
977 sockunion_free(peer
->update_source
);
978 peer
->update_source
= NULL
;
980 if (peer
->update_if
) {
981 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
982 peer
->update_if
= NULL
;
985 if (peer_sort(peer
) == BGP_PEER_IBGP
)
986 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
988 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
990 /* These are per-peer specific flags and so we must preserve them */
991 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
992 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
);
994 SET_FLAG(peer
->flags
, saved_flags
);
999 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1001 /* Reset some other configs back to defaults. */
1002 peer
->v_start
= BGP_INIT_START_TIMER
;
1003 peer
->password
= NULL
;
1004 peer
->local_id
= peer
->bgp
->router_id
;
1005 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
1006 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
1008 bfd_info_free(&(peer
->bfd_info
));
1010 /* Set back the CONFIG_NODE flag. */
1011 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1014 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
1015 static inline bgp_peer_sort_t
peer_calc_sort(struct peer
*peer
)
1022 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1023 if (peer
->as_type
== AS_INTERNAL
)
1024 return BGP_PEER_IBGP
;
1026 else if (peer
->as_type
== AS_EXTERNAL
)
1027 return BGP_PEER_EBGP
;
1029 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
)
1030 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
1035 peer1
= listnode_head(peer
->group
->peer
);
1040 return BGP_PEER_INTERNAL
;
1044 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
1045 if (peer
->local_as
== 0)
1046 return BGP_PEER_INTERNAL
;
1048 if (peer
->local_as
== peer
->as
) {
1049 if (bgp
->as
== bgp
->confed_id
) {
1050 if (peer
->local_as
== bgp
->as
)
1051 return BGP_PEER_IBGP
;
1053 return BGP_PEER_EBGP
;
1055 if (peer
->local_as
== bgp
->confed_id
)
1056 return BGP_PEER_EBGP
;
1058 return BGP_PEER_IBGP
;
1062 if (bgp_confederation_peers_check(bgp
, peer
->as
))
1063 return BGP_PEER_CONFED
;
1065 return BGP_PEER_EBGP
;
1067 if (peer
->as_type
!= AS_SPECIFIED
)
1068 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
1071 return (peer
->local_as
== 0
1073 : peer
->local_as
== peer
->as
? BGP_PEER_IBGP
1078 /* Calculate and cache the peer "sort" */
1079 bgp_peer_sort_t
peer_sort(struct peer
*peer
)
1081 peer
->sort
= peer_calc_sort(peer
);
1085 static void peer_free(struct peer
*peer
)
1087 assert(peer
->status
== Deleted
);
1091 /* this /ought/ to have been done already through bgp_stop earlier,
1092 * but just to be sure..
1094 bgp_timer_set(peer
);
1095 bgp_reads_off(peer
);
1096 bgp_writes_off(peer
);
1097 assert(!peer
->t_write
);
1098 assert(!peer
->t_read
);
1099 BGP_EVENT_FLUSH(peer
);
1101 pthread_mutex_destroy(&peer
->io_mtx
);
1103 /* Free connected nexthop, if present */
1104 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1105 && !peer_dynamic_neighbor(peer
))
1106 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
1109 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1112 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
1116 /* Free allocated host character. */
1118 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1122 if (peer
->domainname
) {
1123 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1124 peer
->domainname
= NULL
;
1128 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1129 peer
->ifname
= NULL
;
1132 /* Update source configuration. */
1133 if (peer
->update_source
) {
1134 sockunion_free(peer
->update_source
);
1135 peer
->update_source
= NULL
;
1138 if (peer
->update_if
) {
1139 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1140 peer
->update_if
= NULL
;
1143 if (peer
->notify
.data
)
1144 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1145 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1147 if (peer
->clear_node_queue
)
1148 work_queue_free_and_null(&peer
->clear_node_queue
);
1150 bgp_sync_delete(peer
);
1152 if (peer
->conf_if
) {
1153 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1154 peer
->conf_if
= NULL
;
1157 bfd_info_free(&(peer
->bfd_info
));
1159 bgp_unlock(peer
->bgp
);
1161 memset(peer
, 0, sizeof(struct peer
));
1163 XFREE(MTYPE_BGP_PEER
, peer
);
1166 /* increase reference count on a struct peer */
1167 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1169 assert(peer
&& (peer
->lock
>= 0));
1172 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1180 /* decrease reference count on a struct peer
1181 * struct peer is freed and NULL returned if last reference
1183 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1185 assert(peer
&& (peer
->lock
> 0));
1188 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1193 if (peer
->lock
== 0) {
1201 /* Allocate new peer object, implicitely locked. */
1202 struct peer
*peer_new(struct bgp
*bgp
)
1209 /* bgp argument is absolutely required */
1214 /* Allocate new peer. */
1215 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1217 /* Set default value. */
1219 peer
->v_start
= BGP_INIT_START_TIMER
;
1220 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1221 peer
->status
= Idle
;
1222 peer
->ostatus
= Idle
;
1223 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1224 peer
->bgp
= bgp_lock(bgp
);
1225 peer
= peer_lock(peer
); /* initial reference */
1226 peer
->password
= NULL
;
1228 /* Set default flags. */
1229 FOREACH_AFI_SAFI (afi
, safi
) {
1230 if (!bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
1231 SET_FLAG(peer
->af_flags
[afi
][safi
],
1232 PEER_FLAG_SEND_COMMUNITY
);
1233 SET_FLAG(peer
->af_flags
[afi
][safi
],
1234 PEER_FLAG_SEND_EXT_COMMUNITY
);
1235 SET_FLAG(peer
->af_flags
[afi
][safi
],
1236 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1238 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1239 PEER_FLAG_SEND_COMMUNITY
);
1240 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1241 PEER_FLAG_SEND_EXT_COMMUNITY
);
1242 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1243 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1247 /* set nexthop-unchanged for l2vpn evpn by default */
1248 SET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1249 PEER_FLAG_NEXTHOP_UNCHANGED
);
1251 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1253 /* Create buffers. */
1254 peer
->ibuf
= stream_fifo_new();
1255 peer
->obuf
= stream_fifo_new();
1256 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1258 /* We use a larger buffer for peer->obuf_work in the event that:
1259 * - We RX a BGP_UPDATE where the attributes alone are just
1260 * under BGP_MAX_PACKET_SIZE
1261 * - The user configures an outbound route-map that does many as-path
1262 * prepends or adds many communities. At most they can have
1263 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1264 * large they can make the attributes.
1266 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1267 * bounds checking for every single attribute as we construct an
1271 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1273 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1275 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1277 bgp_sync_init(peer
);
1279 /* Get service port number. */
1280 sp
= getservbyname("bgp", "tcp");
1281 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1283 QOBJ_REG(peer
, peer
);
1288 * This function is invoked when a duplicate peer structure associated with
1289 * a neighbor is being deleted. If this about-to-be-deleted structure is
1290 * the one with all the config, then we have to copy over the info.
1292 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1294 struct peer_af
*paf
;
1302 /* The following function is used by both peer group config copy to
1303 * individual peer and when we transfer config
1305 if (peer_src
->change_local_as
)
1306 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1308 /* peer flags apply */
1309 peer_dst
->flags
= peer_src
->flags
;
1310 peer_dst
->cap
= peer_src
->cap
;
1312 peer_dst
->local_as
= peer_src
->local_as
;
1313 peer_dst
->port
= peer_src
->port
;
1314 (void)peer_sort(peer_dst
);
1315 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1318 peer_dst
->holdtime
= peer_src
->holdtime
;
1319 peer_dst
->keepalive
= peer_src
->keepalive
;
1320 peer_dst
->connect
= peer_src
->connect
;
1321 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1322 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1323 peer_dst
->routeadv
= peer_src
->routeadv
;
1324 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1326 /* password apply */
1327 if (peer_src
->password
&& !peer_dst
->password
)
1328 peer_dst
->password
=
1329 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1331 FOREACH_AFI_SAFI (afi
, safi
) {
1332 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1333 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1334 peer_dst
->allowas_in
[afi
][safi
] =
1335 peer_src
->allowas_in
[afi
][safi
];
1336 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1339 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1340 paf
= peer_src
->peer_af_array
[afidx
];
1342 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1345 /* update-source apply */
1346 if (peer_src
->update_source
) {
1347 if (peer_dst
->update_source
)
1348 sockunion_free(peer_dst
->update_source
);
1349 if (peer_dst
->update_if
) {
1350 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1351 peer_dst
->update_if
= NULL
;
1353 peer_dst
->update_source
=
1354 sockunion_dup(peer_src
->update_source
);
1355 } else if (peer_src
->update_if
) {
1356 if (peer_dst
->update_if
)
1357 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1358 if (peer_dst
->update_source
) {
1359 sockunion_free(peer_dst
->update_source
);
1360 peer_dst
->update_source
= NULL
;
1362 peer_dst
->update_if
=
1363 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1366 if (peer_src
->ifname
) {
1367 if (peer_dst
->ifname
)
1368 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1371 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1375 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1376 struct interface
*ifp
)
1378 struct connected
*ifc
;
1381 struct listnode
*node
;
1383 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1384 * IPv4 address of the other end.
1386 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1387 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1388 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1389 if (p
.prefixlen
== 30) {
1390 peer
->su
.sa
.sa_family
= AF_INET
;
1391 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1393 peer
->su
.sin
.sin_addr
.s_addr
=
1395 else if (addr
% 4 == 2)
1396 peer
->su
.sin
.sin_addr
.s_addr
=
1398 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1399 peer
->su
.sin
.sin_len
=
1400 sizeof(struct sockaddr_in
);
1401 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1403 } else if (p
.prefixlen
== 31) {
1404 peer
->su
.sa
.sa_family
= AF_INET
;
1405 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1407 peer
->su
.sin
.sin_addr
.s_addr
=
1410 peer
->su
.sin
.sin_addr
.s_addr
=
1412 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1413 peer
->su
.sin
.sin_len
=
1414 sizeof(struct sockaddr_in
);
1415 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1417 } else if (bgp_debug_neighbor_events(peer
))
1419 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1427 static int bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1428 struct interface
*ifp
)
1430 struct nbr_connected
*ifc_nbr
;
1432 /* Have we learnt the peer's IPv6 link-local address? */
1433 if (ifp
->nbr_connected
1434 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1435 peer
->su
.sa
.sa_family
= AF_INET6
;
1436 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1437 sizeof(struct in6_addr
));
1439 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1441 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1449 * Set or reset the peer address socketunion structure based on the
1450 * learnt/derived peer address. If the address has changed, update the
1451 * password on the listen socket, if needed.
1453 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1455 struct interface
*ifp
;
1457 int peer_addr_updated
= 0;
1463 * Our peer structure is stored in the bgp->peerhash
1464 * release it before we modify anything.
1466 hash_release(peer
->bgp
->peerhash
, peer
);
1468 prev_family
= peer
->su
.sa
.sa_family
;
1469 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1471 /* If BGP unnumbered is not "v6only", we first see if we can
1473 * peer's IPv4 address.
1475 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1477 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1479 /* If "v6only" or we can't derive peer's IPv4 address, see if
1481 * learnt the peer's IPv6 link-local address. This is from the
1483 * IPv6 address in router advertisement.
1485 if (!peer_addr_updated
)
1487 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1489 /* If we could derive the peer address, we may need to install the
1491 * configured for the peer, if any, on the listen socket. Otherwise,
1493 * that peer's address is not available and uninstall the password, if
1496 if (peer_addr_updated
) {
1497 if (peer
->password
&& prev_family
== AF_UNSPEC
)
1500 if (peer
->password
&& prev_family
!= AF_UNSPEC
)
1501 bgp_md5_unset(peer
);
1502 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1503 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1507 * Since our su changed we need to del/add peer to the peerhash
1509 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1512 static void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
,
1515 struct bgp_node
*rn
, *nrn
;
1517 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
1518 rn
= bgp_route_next(rn
)) {
1519 if (rn
->info
!= NULL
) {
1520 /* Special handling for 2-level routing
1522 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1523 || safi
== SAFI_EVPN
) {
1524 for (nrn
= bgp_table_top(
1525 (struct bgp_table
*)(rn
->info
));
1526 nrn
; nrn
= bgp_route_next(nrn
))
1527 bgp_process(bgp
, nrn
, afi
, safi
);
1529 bgp_process(bgp
, rn
, afi
, safi
);
1534 /* Force a bestpath recalculation for all prefixes. This is used
1535 * when 'bgp bestpath' commands are entered.
1537 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1542 FOREACH_AFI_SAFI (afi
, safi
) {
1543 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1547 /* Create new BGP peer. */
1548 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1549 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1550 int as_type
, afi_t afi
, safi_t safi
,
1551 struct peer_group
*group
)
1555 char buf
[SU_ADDRSTRLEN
];
1557 peer
= peer_new(bgp
);
1559 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1560 bgp_peer_conf_if_to_su_update(peer
);
1562 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1563 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1566 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1568 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1569 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1571 peer
->local_as
= local_as
;
1572 peer
->as
= remote_as
;
1573 peer
->as_type
= as_type
;
1574 peer
->local_id
= bgp
->router_id
;
1575 peer
->v_holdtime
= bgp
->default_holdtime
;
1576 peer
->v_keepalive
= bgp
->default_keepalive
;
1577 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1578 ? BGP_DEFAULT_IBGP_ROUTEADV
1579 : BGP_DEFAULT_EBGP_ROUTEADV
;
1581 peer
= peer_lock(peer
); /* bgp peer list reference */
1582 peer
->group
= group
;
1583 listnode_add_sort(bgp
->peer
, peer
);
1584 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1586 /* Adjust update-group coalesce timer heuristics for # peers. */
1587 if (bgp
->heuristic_coalesce
) {
1588 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1590 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1591 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1594 active
= peer_active(peer
);
1596 /* Last read and reset time set */
1597 peer
->readtime
= peer
->resettime
= bgp_clock();
1599 /* Default TTL set. */
1600 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: 1;
1602 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1605 peer
->afc
[afi
][safi
] = 1;
1606 peer_af_create(peer
, afi
, safi
);
1609 /* auto shutdown if configured */
1610 if (bgp
->autoshutdown
)
1611 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1612 /* Set up peer's events and timers. */
1613 else if (!active
&& peer_active(peer
))
1614 bgp_timer_set(peer
);
1619 /* Make accept BGP peer. This function is only called from the test code */
1620 struct peer
*peer_create_accept(struct bgp
*bgp
)
1624 peer
= peer_new(bgp
);
1626 peer
= peer_lock(peer
); /* bgp peer list reference */
1627 listnode_add_sort(bgp
->peer
, peer
);
1633 * Return true if we have a peer configured to use this afi/safi
1635 int bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1637 struct listnode
*node
;
1640 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1641 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1644 if (peer
->afc
[afi
][safi
])
1651 /* Change peer's AS number. */
1652 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
)
1654 bgp_peer_sort_t type
;
1657 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1658 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1659 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1660 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1661 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1663 bgp_session_reset(peer
);
1665 type
= peer_sort(peer
);
1667 peer
->as_type
= as_specified
;
1669 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1670 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1671 && peer
->bgp
->as
!= as
)
1672 peer
->local_as
= peer
->bgp
->confed_id
;
1674 peer
->local_as
= peer
->bgp
->as
;
1676 /* Advertisement-interval reset */
1677 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1678 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1679 ? BGP_DEFAULT_IBGP_ROUTEADV
1680 : BGP_DEFAULT_EBGP_ROUTEADV
;
1684 if (peer_sort(peer
) == BGP_PEER_IBGP
)
1686 else if (type
== BGP_PEER_IBGP
)
1689 /* reflector-client reset */
1690 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
1691 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1692 PEER_FLAG_REFLECTOR_CLIENT
);
1693 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1694 PEER_FLAG_REFLECTOR_CLIENT
);
1695 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1696 PEER_FLAG_REFLECTOR_CLIENT
);
1697 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1698 PEER_FLAG_REFLECTOR_CLIENT
);
1699 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1700 PEER_FLAG_REFLECTOR_CLIENT
);
1701 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1702 PEER_FLAG_REFLECTOR_CLIENT
);
1703 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1704 PEER_FLAG_REFLECTOR_CLIENT
);
1705 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1706 PEER_FLAG_REFLECTOR_CLIENT
);
1707 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1708 PEER_FLAG_REFLECTOR_CLIENT
);
1709 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1710 PEER_FLAG_REFLECTOR_CLIENT
);
1711 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1712 PEER_FLAG_REFLECTOR_CLIENT
);
1713 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1714 PEER_FLAG_REFLECTOR_CLIENT
);
1715 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1716 PEER_FLAG_REFLECTOR_CLIENT
);
1719 /* local-as reset */
1720 if (peer_sort(peer
) != BGP_PEER_EBGP
) {
1721 peer
->change_local_as
= 0;
1722 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1723 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1727 /* If peer does not exist, create new one. If peer already exists,
1728 set AS number to the peer. */
1729 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1730 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1736 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1738 peer
= peer_lookup(bgp
, su
);
1741 /* Not allowed for a dynamic peer. */
1742 if (peer_dynamic_neighbor(peer
)) {
1744 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1747 /* When this peer is a member of peer-group. */
1749 if (peer
->group
->conf
->as
) {
1750 /* Return peer group's AS number. */
1751 *as
= peer
->group
->conf
->as
;
1752 return BGP_ERR_PEER_GROUP_MEMBER
;
1754 if (peer_sort(peer
->group
->conf
) == BGP_PEER_IBGP
) {
1755 if ((as_type
!= AS_INTERNAL
)
1756 && (bgp
->as
!= *as
)) {
1758 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1761 if ((as_type
!= AS_EXTERNAL
)
1762 && (bgp
->as
== *as
)) {
1764 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1769 /* Existing peer's AS number change. */
1770 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
1771 || (peer
->as_type
!= as_type
))
1772 peer_as_change(peer
, *as
, as_type
);
1775 return BGP_ERR_NO_INTERFACE_CONFIG
;
1777 /* If the peer is not part of our confederation, and its not an
1778 iBGP peer then spoof the source AS */
1779 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)
1780 && !bgp_confederation_peers_check(bgp
, *as
)
1782 local_as
= bgp
->confed_id
;
1786 /* If this is IPv4 unicast configuration and "no bgp default
1787 ipv4-unicast" is specified. */
1789 if (bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1790 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1791 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0,
1794 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
,
1801 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
1802 struct peer
*peer
, afi_t afi
,
1806 int out
= FILTER_OUT
;
1807 uint32_t pflags_ovrd
;
1808 uint8_t *pfilter_ovrd
;
1812 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
1813 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
1815 /* peer af_flags apply */
1816 peer
->af_flags
[afi
][safi
] |= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
1817 peer
->af_flags_invert
[afi
][safi
] |= conf
->af_flags_invert
[afi
][safi
];
1819 /* maximum-prefix */
1820 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
1821 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
1822 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
1823 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
1827 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
1828 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
1831 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
1832 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
1834 /* default-originate route-map */
1835 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
1836 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
1837 MTYPE_ROUTE_MAP_NAME
);
1838 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
1841 /* inbound filter apply */
1842 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
1843 PEER_STR_ATTR_INHERIT(peer
, group
,
1844 filter
[afi
][safi
].dlist
[in
].name
,
1845 MTYPE_BGP_FILTER_NAME
);
1846 PEER_ATTR_INHERIT(peer
, group
,
1847 filter
[afi
][safi
].dlist
[in
].alist
);
1850 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
1851 PEER_STR_ATTR_INHERIT(peer
, group
,
1852 filter
[afi
][safi
].plist
[in
].name
,
1853 MTYPE_BGP_FILTER_NAME
);
1854 PEER_ATTR_INHERIT(peer
, group
,
1855 filter
[afi
][safi
].plist
[in
].plist
);
1858 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
1859 PEER_STR_ATTR_INHERIT(peer
, group
,
1860 filter
[afi
][safi
].aslist
[in
].name
,
1861 MTYPE_BGP_FILTER_NAME
);
1862 PEER_ATTR_INHERIT(peer
, group
,
1863 filter
[afi
][safi
].aslist
[in
].aslist
);
1866 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
1867 PEER_STR_ATTR_INHERIT(peer
, group
,
1868 filter
[afi
][safi
].map
[in
].name
,
1869 MTYPE_BGP_FILTER_NAME
);
1870 PEER_ATTR_INHERIT(peer
, group
,
1871 filter
[afi
][safi
].map
[RMAP_IN
].map
);
1874 /* outbound filter apply */
1875 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
1876 PEER_STR_ATTR_INHERIT(peer
, group
,
1877 filter
[afi
][safi
].dlist
[out
].name
,
1878 MTYPE_BGP_FILTER_NAME
);
1879 PEER_ATTR_INHERIT(peer
, group
,
1880 filter
[afi
][safi
].dlist
[out
].alist
);
1883 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
1884 PEER_STR_ATTR_INHERIT(peer
, group
,
1885 filter
[afi
][safi
].plist
[out
].name
,
1886 MTYPE_BGP_FILTER_NAME
);
1887 PEER_ATTR_INHERIT(peer
, group
,
1888 filter
[afi
][safi
].plist
[out
].plist
);
1891 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
1892 PEER_STR_ATTR_INHERIT(peer
, group
,
1893 filter
[afi
][safi
].aslist
[out
].name
,
1894 MTYPE_BGP_FILTER_NAME
);
1895 PEER_ATTR_INHERIT(peer
, group
,
1896 filter
[afi
][safi
].aslist
[out
].aslist
);
1899 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
1900 PEER_STR_ATTR_INHERIT(peer
, group
,
1901 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
1902 MTYPE_BGP_FILTER_NAME
);
1903 PEER_ATTR_INHERIT(peer
, group
,
1904 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
1907 /* nondirectional filter apply */
1908 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
1909 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
1910 MTYPE_BGP_FILTER_NAME
);
1911 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
1915 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
1919 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1920 zlog_err("%s was called for peer-group %s", __func__
,
1925 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
1927 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1928 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1929 return BGP_ERR_PEER_SAFI_CONFLICT
;
1931 /* Nothing to do if we've already activated this peer */
1932 if (peer
->afc
[afi
][safi
])
1935 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1938 active
= peer_active(peer
);
1939 peer
->afc
[afi
][safi
] = 1;
1942 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
1944 if (!active
&& peer_active(peer
)) {
1945 bgp_timer_set(peer
);
1947 if (peer
->status
== Established
) {
1948 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
1949 peer
->afc_adv
[afi
][safi
] = 1;
1950 bgp_capability_send(peer
, afi
, safi
,
1952 CAPABILITY_ACTION_SET
);
1953 if (peer
->afc_recv
[afi
][safi
]) {
1954 peer
->afc_nego
[afi
][safi
] = 1;
1955 bgp_announce_route(peer
, afi
, safi
);
1958 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1959 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1960 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1963 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
1964 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1965 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1966 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1973 /* Activate the peer or peer group for specified AFI and SAFI. */
1974 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
1977 struct peer_group
*group
;
1978 struct listnode
*node
, *nnode
;
1979 struct peer
*tmp_peer
;
1982 /* Nothing to do if we've already activated this peer */
1983 if (peer
->afc
[afi
][safi
])
1988 /* This is a peer-group so activate all of the members of the
1989 * peer-group as well */
1990 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1992 /* Do not activate a peer for both SAFI_UNICAST and
1993 * SAFI_LABELED_UNICAST */
1994 if ((safi
== SAFI_UNICAST
1995 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1996 || (safi
== SAFI_LABELED_UNICAST
1997 && peer
->afc
[afi
][SAFI_UNICAST
]))
1998 return BGP_ERR_PEER_SAFI_CONFLICT
;
2000 peer
->afc
[afi
][safi
] = 1;
2001 group
= peer
->group
;
2003 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2004 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2007 ret
|= peer_activate_af(peer
, afi
, safi
);
2010 /* If this is the first peer to be activated for this
2011 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2012 if (safi
== SAFI_LABELED_UNICAST
2013 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2015 if (BGP_DEBUG(zebra
, ZEBRA
))
2017 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2019 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2020 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2023 if (safi
== SAFI_FLOWSPEC
) {
2024 /* connect to table manager */
2025 bgp_zebra_init_tm_connect(bgp
);
2030 static int non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2033 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2034 zlog_err("%s was called for peer-group %s", __func__
,
2039 /* Nothing to do if we've already deactivated this peer */
2040 if (!peer
->afc
[afi
][safi
])
2043 /* De-activate the address family configuration. */
2044 peer
->afc
[afi
][safi
] = 0;
2046 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2047 zlog_err("couldn't delete af structure for peer %s",
2052 if (peer
->status
== Established
) {
2053 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2054 peer
->afc_adv
[afi
][safi
] = 0;
2055 peer
->afc_nego
[afi
][safi
] = 0;
2057 if (peer_active_nego(peer
)) {
2058 bgp_capability_send(peer
, afi
, safi
,
2060 CAPABILITY_ACTION_UNSET
);
2061 bgp_clear_route(peer
, afi
, safi
);
2062 peer
->pcount
[afi
][safi
] = 0;
2064 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2065 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2066 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2069 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2070 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2071 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2078 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2081 struct peer_group
*group
;
2082 struct peer
*tmp_peer
;
2083 struct listnode
*node
, *nnode
;
2086 /* Nothing to do if we've already de-activated this peer */
2087 if (!peer
->afc
[afi
][safi
])
2090 /* This is a peer-group so de-activate all of the members of the
2091 * peer-group as well */
2092 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2093 peer
->afc
[afi
][safi
] = 0;
2094 group
= peer
->group
;
2096 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2097 zlog_err("couldn't delete af structure for peer %s",
2101 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2102 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2105 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2110 /* If this is the last peer to be deactivated for this
2111 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2112 if (safi
== SAFI_LABELED_UNICAST
2113 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2114 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2116 if (BGP_DEBUG(zebra
, ZEBRA
))
2118 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2120 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2121 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2126 int peer_afc_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
2129 return peer_activate(peer
, afi
, safi
);
2131 return peer_deactivate(peer
, afi
, safi
);
2134 static void peer_nsf_stop(struct peer
*peer
)
2139 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2140 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2142 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2143 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
2144 peer
->nsf
[afi
][safi
] = 0;
2146 if (peer
->t_gr_restart
) {
2147 BGP_TIMER_OFF(peer
->t_gr_restart
);
2148 if (bgp_debug_neighbor_events(peer
))
2149 zlog_debug("%s graceful restart timer stopped",
2152 if (peer
->t_gr_stale
) {
2153 BGP_TIMER_OFF(peer
->t_gr_stale
);
2154 if (bgp_debug_neighbor_events(peer
))
2156 "%s graceful restart stalepath timer stopped",
2159 bgp_clear_route_all(peer
);
2162 /* Delete peer from confguration.
2164 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2165 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2167 * This function /should/ take care to be idempotent, to guard against
2168 * it being called multiple times through stray events that come in
2169 * that happen to result in this function being called again. That
2170 * said, getting here for a "Deleted" peer is a bug in the neighbour
2173 int peer_delete(struct peer
*peer
)
2179 struct bgp_filter
*filter
;
2180 struct listnode
*pn
;
2183 assert(peer
->status
!= Deleted
);
2186 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2188 bgp_reads_off(peer
);
2189 bgp_writes_off(peer
);
2190 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2191 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2193 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2194 peer_nsf_stop(peer
);
2196 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2198 /* If this peer belongs to peer group, clear up the
2201 if (peer_dynamic_neighbor(peer
))
2202 peer_drop_dynamic_neighbor(peer
);
2204 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2206 peer
); /* group->peer list reference */
2207 list_delete_node(peer
->group
->peer
, pn
);
2212 /* Withdraw all information from routing table. We can not use
2213 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2214 * executed after peer structure is deleted.
2216 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2218 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2220 if (peer
->doppelganger
) {
2221 peer
->doppelganger
->doppelganger
= NULL
;
2222 peer
->doppelganger
= NULL
;
2225 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2226 bgp_fsm_change_status(peer
, Deleted
);
2228 /* Remove from NHT */
2229 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2230 bgp_unlink_nexthop_by_peer(peer
);
2232 /* Password configuration */
2233 if (peer
->password
) {
2234 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2235 peer
->password
= NULL
;
2237 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2238 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
2239 bgp_md5_unset(peer
);
2242 bgp_timer_set(peer
); /* stops all timers for Deleted */
2244 /* Delete from all peer list. */
2245 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2246 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2247 peer_unlock(peer
); /* bgp peer list reference */
2248 list_delete_node(bgp
->peer
, pn
);
2249 hash_release(bgp
->peerhash
, peer
);
2254 stream_fifo_free(peer
->ibuf
);
2259 stream_fifo_free(peer
->obuf
);
2263 if (peer
->ibuf_work
) {
2264 ringbuf_del(peer
->ibuf_work
);
2265 peer
->ibuf_work
= NULL
;
2268 if (peer
->obuf_work
) {
2269 stream_free(peer
->obuf_work
);
2270 peer
->obuf_work
= NULL
;
2273 if (peer
->scratch
) {
2274 stream_free(peer
->scratch
);
2275 peer
->scratch
= NULL
;
2278 /* Local and remote addresses. */
2279 if (peer
->su_local
) {
2280 sockunion_free(peer
->su_local
);
2281 peer
->su_local
= NULL
;
2284 if (peer
->su_remote
) {
2285 sockunion_free(peer
->su_remote
);
2286 peer
->su_remote
= NULL
;
2289 /* Free filter related memory. */
2290 FOREACH_AFI_SAFI (afi
, safi
) {
2291 filter
= &peer
->filter
[afi
][safi
];
2293 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2294 if (filter
->dlist
[i
].name
) {
2295 XFREE(MTYPE_BGP_FILTER_NAME
,
2296 filter
->dlist
[i
].name
);
2297 filter
->dlist
[i
].name
= NULL
;
2300 if (filter
->plist
[i
].name
) {
2301 XFREE(MTYPE_BGP_FILTER_NAME
,
2302 filter
->plist
[i
].name
);
2303 filter
->plist
[i
].name
= NULL
;
2306 if (filter
->aslist
[i
].name
) {
2307 XFREE(MTYPE_BGP_FILTER_NAME
,
2308 filter
->aslist
[i
].name
);
2309 filter
->aslist
[i
].name
= NULL
;
2313 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2314 if (filter
->map
[i
].name
) {
2315 XFREE(MTYPE_BGP_FILTER_NAME
,
2316 filter
->map
[i
].name
);
2317 filter
->map
[i
].name
= NULL
;
2321 if (filter
->usmap
.name
) {
2322 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2323 filter
->usmap
.name
= NULL
;
2326 if (peer
->default_rmap
[afi
][safi
].name
) {
2327 XFREE(MTYPE_ROUTE_MAP_NAME
,
2328 peer
->default_rmap
[afi
][safi
].name
);
2329 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2333 FOREACH_AFI_SAFI (afi
, safi
)
2334 peer_af_delete(peer
, afi
, safi
);
2336 if (peer
->hostname
) {
2337 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2338 peer
->hostname
= NULL
;
2341 if (peer
->domainname
) {
2342 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2343 peer
->domainname
= NULL
;
2346 peer_unlock(peer
); /* initial reference */
2351 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2353 return strcmp(g1
->name
, g2
->name
);
2356 /* Peer group cofiguration. */
2357 static struct peer_group
*peer_group_new(void)
2359 return (struct peer_group
*)XCALLOC(MTYPE_PEER_GROUP
,
2360 sizeof(struct peer_group
));
2363 static void peer_group_free(struct peer_group
*group
)
2365 XFREE(MTYPE_PEER_GROUP
, group
);
2368 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2370 struct peer_group
*group
;
2371 struct listnode
*node
, *nnode
;
2373 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2374 if (strcmp(group
->name
, name
) == 0)
2380 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2382 struct peer_group
*group
;
2385 group
= peer_group_lookup(bgp
, name
);
2389 group
= peer_group_new();
2392 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2393 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2394 group
->peer
= list_new();
2395 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2396 group
->listen_range
[afi
] = list_new();
2397 group
->conf
= peer_new(bgp
);
2398 if (!bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2399 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2400 if (group
->conf
->host
)
2401 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2402 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2403 group
->conf
->group
= group
;
2404 group
->conf
->as
= 0;
2405 group
->conf
->ttl
= 1;
2406 group
->conf
->gtsm_hops
= 0;
2407 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2408 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2409 listnode_add_sort(bgp
->group
, group
);
2414 static void peer_group2peer_config_copy(struct peer_group
*group
,
2423 peer
->as
= conf
->as
;
2426 if (conf
->change_local_as
)
2427 peer
->change_local_as
= conf
->change_local_as
;
2430 peer
->ttl
= conf
->ttl
;
2433 peer
->gtsm_hops
= conf
->gtsm_hops
;
2435 /* These are per-peer specific flags and so we must preserve them */
2436 peer
->flags
|= conf
->flags
& ~peer
->flags_override
;
2437 peer
->flags_invert
|= conf
->flags_invert
;
2439 /* peer timers apply */
2440 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2441 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2442 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2445 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2446 PEER_ATTR_INHERIT(peer
, group
, connect
);
2447 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2448 peer
->v_connect
= conf
->connect
;
2450 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2453 /* advertisement-interval apply */
2454 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2455 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2456 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2457 peer
->v_routeadv
= conf
->routeadv
;
2459 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2460 ? BGP_DEFAULT_IBGP_ROUTEADV
2461 : BGP_DEFAULT_EBGP_ROUTEADV
;
2464 /* password apply */
2465 if (conf
->password
&& !peer
->password
)
2466 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, conf
->password
);
2468 if (!BGP_PEER_SU_UNSPEC(peer
))
2471 /* update-source apply */
2472 if (conf
->update_source
) {
2473 if (peer
->update_source
)
2474 sockunion_free(peer
->update_source
);
2475 if (peer
->update_if
) {
2476 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2477 peer
->update_if
= NULL
;
2479 peer
->update_source
= sockunion_dup(conf
->update_source
);
2480 } else if (conf
->update_if
) {
2481 if (peer
->update_if
)
2482 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2483 if (peer
->update_source
) {
2484 sockunion_free(peer
->update_source
);
2485 peer
->update_source
= NULL
;
2488 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2491 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2494 /* Peer group's remote AS configuration. */
2495 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2498 struct peer_group
*group
;
2500 struct listnode
*node
, *nnode
;
2502 group
= peer_group_lookup(bgp
, group_name
);
2506 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2510 /* When we setup peer-group AS number all peer group member's AS
2511 number must be updated to same number. */
2512 peer_as_change(group
->conf
, *as
, as_type
);
2514 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2515 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2516 || (peer
->as_type
!= as_type
))
2517 peer_as_change(peer
, *as
, as_type
);
2523 int peer_group_delete(struct peer_group
*group
)
2527 struct prefix
*prefix
;
2529 struct listnode
*node
, *nnode
;
2534 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2535 other
= peer
->doppelganger
;
2537 if (other
&& other
->status
!= Deleted
) {
2538 other
->group
= NULL
;
2542 list_delete_and_null(&group
->peer
);
2544 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2545 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2547 prefix_free(prefix
);
2549 list_delete_and_null(&group
->listen_range
[afi
]);
2552 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2555 bfd_info_free(&(group
->conf
->bfd_info
));
2557 group
->conf
->group
= NULL
;
2558 peer_delete(group
->conf
);
2560 /* Delete from all peer_group list. */
2561 listnode_delete(bgp
->group
, group
);
2563 peer_group_free(group
);
2568 int peer_group_remote_as_delete(struct peer_group
*group
)
2570 struct peer
*peer
, *other
;
2571 struct listnode
*node
, *nnode
;
2573 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2574 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2577 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2578 other
= peer
->doppelganger
;
2582 if (other
&& other
->status
!= Deleted
) {
2583 other
->group
= NULL
;
2587 list_delete_all_node(group
->peer
);
2589 group
->conf
->as
= 0;
2590 group
->conf
->as_type
= AS_UNSPECIFIED
;
2595 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2597 struct prefix
*prefix
;
2598 struct listnode
*node
, *nnode
;
2601 afi
= family2afi(range
->family
);
2603 /* Group needs remote AS configured. */
2604 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2605 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2607 /* Ensure no duplicates. Currently we don't care about overlaps. */
2608 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2609 if (prefix_same(range
, prefix
))
2613 prefix
= prefix_new();
2614 prefix_copy(prefix
, range
);
2615 listnode_add(group
->listen_range
[afi
], prefix
);
2619 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
2621 struct prefix
*prefix
, prefix2
;
2622 struct listnode
*node
, *nnode
;
2625 char buf
[PREFIX2STR_BUFFER
];
2627 afi
= family2afi(range
->family
);
2629 /* Identify the listen range. */
2630 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2631 if (prefix_same(range
, prefix
))
2636 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2638 prefix2str(prefix
, buf
, sizeof(buf
));
2640 /* Dispose off any dynamic neighbors that exist due to this listen range
2642 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2643 if (!peer_dynamic_neighbor(peer
))
2646 sockunion2hostprefix(&peer
->su
, &prefix2
);
2647 if (prefix_match(prefix
, &prefix2
)) {
2648 if (bgp_debug_neighbor_events(peer
))
2650 "Deleting dynamic neighbor %s group %s upon "
2651 "delete of listen range %s",
2652 peer
->host
, group
->name
, buf
);
2657 /* Get rid of the listen range */
2658 listnode_delete(group
->listen_range
[afi
], prefix
);
2663 /* Bind specified peer to peer group. */
2664 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2665 struct peer_group
*group
, as_t
*as
)
2667 int first_member
= 0;
2670 int cap_enhe_preset
= 0;
2672 /* Lookup the peer. */
2674 peer
= peer_lookup(bgp
, su
);
2676 /* The peer exist, bind it to the peer-group */
2678 /* When the peer already belongs to a peer-group, check the
2680 if (peer_group_active(peer
)) {
2682 /* The peer is already bound to the peer-group,
2685 if (strcmp(peer
->group
->name
, group
->name
) == 0)
2688 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2691 /* The peer has not specified a remote-as, inherit it from the
2693 if (peer
->as_type
== AS_UNSPECIFIED
) {
2694 peer
->as_type
= group
->conf
->as_type
;
2695 peer
->as
= group
->conf
->as
;
2698 if (!group
->conf
->as
) {
2699 if (peer_sort(group
->conf
) != BGP_PEER_INTERNAL
2700 && peer_sort(group
->conf
) != peer_sort(peer
)) {
2703 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2706 if (peer_sort(group
->conf
) == BGP_PEER_INTERNAL
)
2710 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2711 cap_enhe_preset
= 1;
2713 peer_group2peer_config_copy(group
, peer
);
2716 * Capability extended-nexthop is enabled for an interface
2718 * default. So, fix that up here.
2720 if (peer
->conf_if
&& cap_enhe_preset
)
2721 peer_flag_set(peer
, PEER_FLAG_CAPABILITY_ENHE
);
2723 FOREACH_AFI_SAFI (afi
, safi
) {
2724 if (group
->conf
->afc
[afi
][safi
]) {
2725 peer
->afc
[afi
][safi
] = 1;
2727 if (peer_af_find(peer
, afi
, safi
)
2728 || peer_af_create(peer
, afi
, safi
)) {
2729 peer_group2peer_config_copy_af(
2730 group
, peer
, afi
, safi
);
2732 } else if (peer
->afc
[afi
][safi
])
2733 peer_deactivate(peer
, afi
, safi
);
2737 assert(group
&& peer
->group
== group
);
2739 struct listnode
*pn
;
2740 pn
= listnode_lookup(bgp
->peer
, peer
);
2741 list_delete_node(bgp
->peer
, pn
);
2742 peer
->group
= group
;
2743 listnode_add_sort(bgp
->peer
, peer
);
2745 peer
= peer_lock(peer
); /* group->peer list reference */
2746 listnode_add(group
->peer
, peer
);
2750 /* Advertisement-interval reset */
2751 if (!CHECK_FLAG(group
->conf
->flags
,
2752 PEER_FLAG_ROUTEADV
)) {
2753 group
->conf
->v_routeadv
=
2754 (peer_sort(group
->conf
)
2756 ? BGP_DEFAULT_IBGP_ROUTEADV
2757 : BGP_DEFAULT_EBGP_ROUTEADV
;
2760 /* ebgp-multihop reset */
2761 if (peer_sort(group
->conf
) == BGP_PEER_IBGP
)
2762 group
->conf
->ttl
= MAXTTL
;
2764 /* local-as reset */
2765 if (peer_sort(group
->conf
) != BGP_PEER_EBGP
) {
2766 group
->conf
->change_local_as
= 0;
2767 UNSET_FLAG(peer
->flags
,
2768 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2769 UNSET_FLAG(peer
->flags
,
2770 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2774 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2776 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2777 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2778 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2779 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2781 bgp_session_reset(peer
);
2785 /* Create a new peer. */
2787 if ((group
->conf
->as_type
== AS_SPECIFIED
)
2788 && (!group
->conf
->as
)) {
2789 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2792 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
2793 group
->conf
->as_type
, 0, 0, group
);
2795 peer
= peer_lock(peer
); /* group->peer list reference */
2796 listnode_add(group
->peer
, peer
);
2798 peer_group2peer_config_copy(group
, peer
);
2800 /* If the peer-group is active for this afi/safi then activate
2802 FOREACH_AFI_SAFI (afi
, safi
) {
2803 if (group
->conf
->afc
[afi
][safi
]) {
2804 peer
->afc
[afi
][safi
] = 1;
2805 peer_af_create(peer
, afi
, safi
);
2806 peer_group2peer_config_copy_af(group
, peer
, afi
,
2808 } else if (peer
->afc
[afi
][safi
])
2809 peer_deactivate(peer
, afi
, safi
);
2812 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2814 /* Set up peer's events and timers. */
2815 if (peer_active(peer
))
2816 bgp_timer_set(peer
);
2822 int peer_group_unbind(struct bgp
*bgp
, struct peer
*peer
,
2823 struct peer_group
*group
)
2829 if (group
!= peer
->group
)
2830 return BGP_ERR_PEER_GROUP_MISMATCH
;
2832 FOREACH_AFI_SAFI (afi
, safi
) {
2833 if (peer
->afc
[afi
][safi
]) {
2834 peer
->afc
[afi
][safi
] = 0;
2835 peer_af_flag_reset(peer
, afi
, safi
);
2837 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2839 "couldn't delete af structure for peer %s",
2845 assert(listnode_lookup(group
->peer
, peer
));
2846 peer_unlock(peer
); /* peer group list reference */
2847 listnode_delete(group
->peer
, peer
);
2849 other
= peer
->doppelganger
;
2851 if (group
->conf
->as
) {
2853 if (other
&& other
->status
!= Deleted
) {
2856 listnode_delete(group
->peer
, other
);
2858 other
->group
= NULL
;
2864 bgp_bfd_deregister_peer(peer
);
2865 peer_global_config_reset(peer
);
2867 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2868 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2869 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2870 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2872 bgp_session_reset(peer
);
2877 static int bgp_startup_timer_expire(struct thread
*thread
)
2881 bgp
= THREAD_ARG(thread
);
2882 bgp
->t_startup
= NULL
;
2888 * On shutdown we call the cleanup function which
2889 * does a free of the link list nodes, free up
2890 * the data we are pointing at too.
2892 static void bgp_vrf_string_name_delete(void *data
)
2896 XFREE(MTYPE_TMP
, vname
);
2899 /* BGP instance creation by `router bgp' commands. */
2900 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
2901 enum bgp_instance_type inst_type
)
2907 if ((bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
))) == NULL
)
2910 if (BGP_DEBUG(zebra
, ZEBRA
)) {
2911 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2912 zlog_debug("Creating Default VRF, AS %u", *as
);
2914 zlog_debug("Creating %s %s, AS %u",
2915 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
2922 bgp
->heuristic_coalesce
= true;
2923 bgp
->inst_type
= inst_type
;
2924 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
2926 bgp
->peer_self
= peer_new(bgp
);
2927 if (bgp
->peer_self
->host
)
2928 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2929 bgp
->peer_self
->host
=
2930 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2931 if (bgp
->peer_self
->hostname
!= NULL
) {
2932 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
2933 bgp
->peer_self
->hostname
= NULL
;
2935 if (cmd_hostname_get())
2936 bgp
->peer_self
->hostname
=
2937 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
2939 if (bgp
->peer_self
->domainname
!= NULL
) {
2940 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
2941 bgp
->peer_self
->domainname
= NULL
;
2943 if (cmd_domainname_get())
2944 bgp
->peer_self
->domainname
=
2945 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
2946 bgp
->peer
= list_new();
2947 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
2948 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
2950 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
2952 bgp
->group
= list_new();
2953 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
2955 FOREACH_AFI_SAFI (afi
, safi
) {
2956 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2957 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2958 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2960 /* Enable maximum-paths */
2961 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
2963 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
2967 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2968 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2969 bgp
->default_subgroup_pkt_queue_max
=
2970 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2971 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2972 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2973 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2974 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2975 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2976 bgp
->dynamic_neighbors_count
= 0;
2977 #if DFLT_BGP_IMPORT_CHECK
2978 bgp_flag_set(bgp
, BGP_FLAG_IMPORT_CHECK
);
2980 #if DFLT_BGP_SHOW_HOSTNAME
2981 bgp_flag_set(bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2983 #if DFLT_BGP_LOG_NEIGHBOR_CHANGES
2984 bgp_flag_set(bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2986 #if DFLT_BGP_DETERMINISTIC_MED
2987 bgp_flag_set(bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2989 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2994 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
2995 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2997 assert(bgp
->rfapi_cfg
);
2999 #endif /* ENABLE_BGP_VNC */
3001 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3002 bgp
->vpn_policy
[afi
].bgp
= bgp
;
3003 bgp
->vpn_policy
[afi
].afi
= afi
;
3004 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
3005 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
3008 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
3009 bgp
->vpn_policy
[afi
].import_vrf
->del
=
3010 bgp_vrf_string_name_delete
;
3011 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
3012 bgp
->vpn_policy
[afi
].export_vrf
->del
=
3013 bgp_vrf_string_name_delete
;
3016 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
3018 /* TODO - The startup timer needs to be run for the whole of BGP
3020 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
3021 bgp
->restart_time
, &bgp
->t_startup
);
3024 /* printable name we can use in debug messages */
3025 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3026 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3036 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3038 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3039 snprintf(bgp
->name_pretty
, len
, "%s %s",
3040 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3046 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3047 memory_order_relaxed
);
3048 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3049 memory_order_relaxed
);
3050 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3054 update_bgp_group_init(bgp
);
3056 /* assign a unique rd id for auto derivation of vrf's RD */
3057 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3064 /* Return the "default VRF" instance of BGP. */
3065 struct bgp
*bgp_get_default(void)
3068 struct listnode
*node
, *nnode
;
3070 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3071 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3076 /* Lookup BGP entry. */
3077 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3080 struct listnode
*node
, *nnode
;
3082 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3084 && ((bgp
->name
== NULL
&& name
== NULL
)
3085 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3090 /* Lookup BGP structure by view name. */
3091 struct bgp
*bgp_lookup_by_name(const char *name
)
3094 struct listnode
*node
, *nnode
;
3096 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3097 if ((bgp
->name
== NULL
&& name
== NULL
)
3098 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3103 /* Lookup BGP instance based on VRF id. */
3104 /* Note: Only to be used for incoming messages from Zebra. */
3105 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3109 /* Lookup VRF (in tree) and follow link. */
3110 vrf
= vrf_lookup_by_id(vrf_id
);
3113 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3116 /* handle socket creation or deletion, if necessary
3117 * this is called for all new BGP instances
3119 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3124 /* Create BGP server socket, if listen mode not disabled */
3125 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3127 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3129 * suppress vrf socket
3131 if (create
== FALSE
) {
3132 bgp_close_vrf_socket(bgp
);
3136 return BGP_ERR_INVALID_VALUE
;
3138 * if vrf_id did not change
3140 if (vrf
->vrf_id
== old_vrf_id
)
3142 if (old_vrf_id
!= VRF_UNKNOWN
) {
3143 /* look for old socket. close it. */
3144 bgp_close_vrf_socket(bgp
);
3146 /* if backend is not yet identified ( VRF_UNKNOWN) then
3147 * creation will be done later
3149 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3151 ret
= bgp_socket(bgp
, bm
->port
, bm
->address
);
3153 return BGP_ERR_INVALID_VALUE
;
3156 return bgp_check_main_socket(create
, bgp
);
3159 /* Called from VTY commands. */
3160 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3161 enum bgp_instance_type inst_type
)
3164 struct vrf
*vrf
= NULL
;
3166 /* Multiple instance check. */
3167 if (bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
3169 bgp
= bgp_lookup_by_name(name
);
3171 bgp
= bgp_get_default();
3173 /* Already exists. */
3175 if (bgp
->as
!= *as
) {
3177 return BGP_ERR_INSTANCE_MISMATCH
;
3179 if (bgp
->inst_type
!= inst_type
)
3180 return BGP_ERR_INSTANCE_MISMATCH
;
3185 /* BGP instance name can not be specified for single instance.
3188 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3190 /* Get default BGP structure if exists. */
3191 bgp
= bgp_get_default();
3194 if (bgp
->as
!= *as
) {
3196 return BGP_ERR_AS_MISMATCH
;
3203 bgp
= bgp_create(as
, name
, inst_type
);
3204 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3205 bgp_address_init(bgp
);
3206 bgp_tip_hash_init(bgp
);
3210 bgp
->t_rmap_def_originate_eval
= NULL
;
3212 /* If Default instance or VRF, link to the VRF structure, if present. */
3213 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3214 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3215 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3217 bgp_vrf_link(bgp
, vrf
);
3219 /* BGP server socket already processed if BGP instance
3220 * already part of the list
3222 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3223 listnode_add(bm
->bgp
, bgp
);
3225 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3226 bgp_zebra_instance_register(bgp
);
3233 * Make BGP instance "up". Applies only to VRFs (non-default) and
3234 * implies the VRF has been learnt from Zebra.
3236 void bgp_instance_up(struct bgp
*bgp
)
3239 struct listnode
*node
, *next
;
3241 /* Register with zebra. */
3242 bgp_zebra_instance_register(bgp
);
3244 /* Kick off any peers that may have been configured. */
3245 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3246 if (!BGP_PEER_START_SUPPRESSED(peer
))
3247 BGP_EVENT_ADD(peer
, BGP_Start
);
3250 /* Process any networks that have been configured. */
3251 bgp_static_add(bgp
);
3255 * Make BGP instance "down". Applies only to VRFs (non-default) and
3256 * implies the VRF has been deleted by Zebra.
3258 void bgp_instance_down(struct bgp
*bgp
)
3261 struct listnode
*node
;
3262 struct listnode
*next
;
3265 if (bgp
->t_rmap_def_originate_eval
) {
3266 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3267 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3271 /* Bring down peers, so corresponding routes are purged. */
3272 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3273 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3274 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3275 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3277 bgp_session_reset(peer
);
3280 /* Purge network and redistributed routes. */
3281 bgp_purge_static_redist_routes(bgp
);
3283 /* Cleanup registered nexthops (flags) */
3284 bgp_cleanup_nexthops(bgp
);
3287 /* Delete BGP instance. */
3288 int bgp_delete(struct bgp
*bgp
)
3291 struct peer_group
*group
;
3292 struct listnode
*node
, *next
;
3298 THREAD_OFF(bgp
->t_startup
);
3300 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3301 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3302 zlog_debug("Deleting Default VRF");
3304 zlog_debug("Deleting %s %s",
3305 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3311 /* unmap from RT list */
3312 bgp_evpn_vrf_delete(bgp
);
3315 if (bgp
->t_rmap_def_originate_eval
) {
3316 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3317 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3321 /* Inform peers we're going down. */
3322 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3323 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3324 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3325 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3328 /* Delete static routes (networks). */
3329 bgp_static_delete(bgp
);
3331 /* Unset redistribution. */
3332 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3333 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3334 if (i
!= ZEBRA_ROUTE_BGP
)
3335 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3337 /* Free peers and peer-groups. */
3338 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3339 peer_group_delete(group
);
3341 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3344 if (bgp
->peer_self
) {
3345 peer_delete(bgp
->peer_self
);
3346 bgp
->peer_self
= NULL
;
3349 update_bgp_group_free(bgp
);
3351 /* TODO - Other memory may need to be freed - e.g., NHT */
3356 bgp_cleanup_routes(bgp
);
3358 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3359 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3362 &bgp
->vpn_policy
[afi
]
3363 .import_redirect_rtlist
);
3364 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3366 /* Remove visibility via the master list - there may however still be
3367 * routes to be processed still referencing the struct bgp.
3369 listnode_delete(bm
->bgp
, bgp
);
3371 /* Deregister from Zebra, if needed */
3372 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3373 bgp_zebra_instance_deregister(bgp
);
3375 /* Free interfaces in this instance. */
3378 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3379 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3381 bgp_vrf_unlink(bgp
, vrf
);
3383 thread_master_free_unused(bm
->master
);
3384 bgp_unlock(bgp
); /* initial reference */
3389 void bgp_free(struct bgp
*bgp
)
3393 struct bgp_table
*table
;
3394 struct bgp_node
*rn
;
3395 struct bgp_rmap
*rmap
;
3399 list_delete_and_null(&bgp
->group
);
3400 list_delete_and_null(&bgp
->peer
);
3402 if (bgp
->peerhash
) {
3403 hash_free(bgp
->peerhash
);
3404 bgp
->peerhash
= NULL
;
3407 FOREACH_AFI_SAFI (afi
, safi
) {
3408 /* Special handling for 2-level routing tables. */
3409 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3410 || safi
== SAFI_EVPN
) {
3411 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
3412 rn
= bgp_route_next(rn
)) {
3413 table
= (struct bgp_table
*)rn
->info
;
3414 bgp_table_finish(&table
);
3417 if (bgp
->route
[afi
][safi
])
3418 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3419 if (bgp
->aggregate
[afi
][safi
])
3420 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3421 if (bgp
->rib
[afi
][safi
])
3422 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3423 rmap
= &bgp
->table_map
[afi
][safi
];
3425 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3428 bgp_scan_finish(bgp
);
3429 bgp_address_destroy(bgp
);
3430 bgp_tip_hash_destroy(bgp
);
3432 /* release the auto RD id */
3433 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3435 bgp_evpn_cleanup(bgp
);
3436 bgp_pbr_cleanup(bgp
);
3438 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3439 vpn_policy_direction_t dir
;
3441 if (bgp
->vpn_policy
[afi
].import_vrf
)
3442 list_delete_and_null(&bgp
->vpn_policy
[afi
].import_vrf
);
3443 if (bgp
->vpn_policy
[afi
].export_vrf
)
3444 list_delete_and_null(&bgp
->vpn_policy
[afi
].export_vrf
);
3446 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3447 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3448 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3449 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3450 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3451 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3455 XFREE(MTYPE_BGP
, bgp
->name
);
3456 if (bgp
->name_pretty
)
3457 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3459 XFREE(MTYPE_BGP
, bgp
);
3462 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3465 struct listnode
*node
, *nnode
;
3471 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3472 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3473 && !CHECK_FLAG(peer
->sflags
,
3474 PEER_STATUS_ACCEPT_PEER
))
3476 } else if (bm
->bgp
!= NULL
) {
3477 struct listnode
*bgpnode
, *nbgpnode
;
3479 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3480 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3482 && !strcmp(peer
->conf_if
, conf_if
)
3483 && !CHECK_FLAG(peer
->sflags
,
3484 PEER_STATUS_ACCEPT_PEER
))
3490 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
3493 struct listnode
*node
, *nnode
;
3499 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3500 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
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
->hostname
, hostname
)
3511 && !CHECK_FLAG(peer
->sflags
,
3512 PEER_STATUS_ACCEPT_PEER
))
3518 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
3520 struct peer
*peer
= NULL
;
3521 struct peer tmp_peer
;
3523 memset(&tmp_peer
, 0, sizeof(struct peer
));
3526 * We do not want to find the doppelganger peer so search for the peer
3528 * the hash that has PEER_FLAG_CONFIG_NODE
3530 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3535 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3536 } else if (bm
->bgp
!= NULL
) {
3537 struct listnode
*bgpnode
, *nbgpnode
;
3539 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
3540 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3549 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
3550 union sockunion
*su
,
3551 struct peer_group
*group
)
3557 /* Create peer first; we've already checked group config is valid. */
3558 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3559 group
->conf
->as_type
, 0, 0, group
);
3564 peer
= peer_lock(peer
);
3565 listnode_add(group
->peer
, peer
);
3567 peer_group2peer_config_copy(group
, peer
);
3570 * Bind peer for all AFs configured for the group. We don't call
3571 * peer_group_bind as that is sub-optimal and does some stuff we don't
3574 FOREACH_AFI_SAFI (afi
, safi
) {
3575 if (!group
->conf
->afc
[afi
][safi
])
3577 peer
->afc
[afi
][safi
] = 1;
3579 if (!peer_af_find(peer
, afi
, safi
))
3580 peer_af_create(peer
, afi
, safi
);
3582 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
3585 /* Mark as dynamic, but also as a "config node" for other things to
3587 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3588 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3594 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
3595 struct prefix
*prefix
)
3597 struct listnode
*node
, *nnode
;
3598 struct prefix
*range
;
3601 afi
= family2afi(prefix
->family
);
3603 if (group
->listen_range
[afi
])
3604 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
3606 if (prefix_match(range
, prefix
))
3613 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
3614 struct prefix
**listen_range
)
3616 struct prefix
*range
= NULL
;
3617 struct peer_group
*group
= NULL
;
3618 struct listnode
*node
, *nnode
;
3620 *listen_range
= NULL
;
3622 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3623 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3626 } else if (bm
->bgp
!= NULL
) {
3627 struct listnode
*bgpnode
, *nbgpnode
;
3629 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3630 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3631 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3637 *listen_range
= range
;
3638 return (group
&& range
) ? group
: NULL
;
3641 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
3643 struct peer_group
*group
;
3646 struct prefix prefix
;
3647 struct prefix
*listen_range
;
3649 char buf
[PREFIX2STR_BUFFER
];
3650 char buf1
[PREFIX2STR_BUFFER
];
3652 sockunion2hostprefix(su
, &prefix
);
3654 /* See if incoming connection matches a configured listen range. */
3655 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
3666 prefix2str(&prefix
, buf
, sizeof(buf
));
3667 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3669 if (bgp_debug_neighbor_events(NULL
))
3671 "Dynamic Neighbor %s matches group %s listen range %s",
3672 buf
, group
->name
, buf1
);
3674 /* Are we within the listen limit? */
3675 dncount
= gbgp
->dynamic_neighbors_count
;
3677 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
3678 if (bgp_debug_neighbor_events(NULL
))
3679 zlog_debug("Dynamic Neighbor %s rejected - at limit %d",
3680 inet_sutop(su
, buf
),
3681 gbgp
->dynamic_neighbors_limit
);
3685 /* Ensure group is not disabled. */
3686 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
3687 if (bgp_debug_neighbor_events(NULL
))
3689 "Dynamic Neighbor %s rejected - group %s disabled",
3694 /* Check that at least one AF is activated for the group. */
3695 if (!peer_group_af_configured(group
)) {
3696 if (bgp_debug_neighbor_events(NULL
))
3698 "Dynamic Neighbor %s rejected - no AF activated for group %s",
3703 /* Create dynamic peer and bind to associated group. */
3704 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
3707 gbgp
->dynamic_neighbors_count
= ++dncount
;
3709 if (bgp_debug_neighbor_events(peer
))
3710 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
3711 peer
->host
, group
->name
, dncount
);
3716 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
3719 if (peer
->group
->bgp
) {
3720 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3722 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3724 if (bgp_debug_neighbor_events(peer
))
3725 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
3726 peer
->group
->name
, dncount
);
3729 /* If peer is configured at least one address family return 1. */
3730 int peer_active(struct peer
*peer
)
3732 if (BGP_PEER_SU_UNSPEC(peer
))
3734 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3735 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3736 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3737 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
3738 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3739 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3740 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3741 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3742 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
3743 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
3744 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
3749 /* If peer is negotiated at least one address family return 1. */
3750 int peer_active_nego(struct peer
*peer
)
3752 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3753 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3754 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3755 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3756 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3757 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
3758 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3759 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3760 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3761 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3762 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
3763 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
3764 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
3769 /* peer_flag_change_type. */
3770 enum peer_change_type
{
3773 peer_change_reset_in
,
3774 peer_change_reset_out
,
3777 static void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
3778 enum peer_change_type type
)
3780 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
3783 if (peer
->status
!= Established
)
3786 if (type
== peer_change_reset
) {
3787 /* If we're resetting session, we've to delete both peer struct
3789 if ((peer
->doppelganger
)
3790 && (peer
->doppelganger
->status
!= Deleted
)
3791 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3792 PEER_FLAG_CONFIG_NODE
)))
3793 peer_delete(peer
->doppelganger
);
3795 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3796 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3797 } else if (type
== peer_change_reset_in
) {
3798 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3799 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3800 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
3802 if ((peer
->doppelganger
)
3803 && (peer
->doppelganger
->status
!= Deleted
)
3804 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3805 PEER_FLAG_CONFIG_NODE
)))
3806 peer_delete(peer
->doppelganger
);
3808 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3809 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3811 } else if (type
== peer_change_reset_out
) {
3812 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3813 bgp_announce_route(peer
, afi
, safi
);
3817 struct peer_flag_action
{
3821 /* This flag can be set for peer-group member. */
3822 uint8_t not_for_member
;
3824 /* Action when the flag is changed. */
3825 enum peer_change_type type
;
3827 /* Peer down cause */
3831 static const struct peer_flag_action peer_flag_action_list
[] = {
3832 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3833 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3834 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3835 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3836 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3837 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3838 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3839 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3840 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
3841 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
3842 {PEER_FLAG_TIMER
, 0, peer_change_none
},
3843 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
3846 static const struct peer_flag_action peer_af_flag_action_list
[] = {
3847 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3848 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3849 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3850 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3851 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3852 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3853 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3854 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3855 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3856 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3857 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
3858 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3859 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3860 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3861 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3862 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3863 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
3864 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
3865 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3866 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3867 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3868 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
3869 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3870 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
3871 {PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3872 {PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3873 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3876 /* Proper action set. */
3877 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
3878 int size
, struct peer_flag_action
*action
,
3885 const struct peer_flag_action
*match
= NULL
;
3887 /* Check peer's frag action. */
3888 for (i
= 0; i
< size
; i
++) {
3889 match
= &action_list
[i
];
3891 if (match
->flag
== 0)
3894 if (match
->flag
& flag
) {
3897 if (match
->type
== peer_change_reset_in
)
3899 if (match
->type
== peer_change_reset_out
)
3901 if (match
->type
== peer_change_reset
) {
3905 if (match
->not_for_member
)
3906 action
->not_for_member
= 1;
3910 /* Set peer clear type. */
3911 if (reset_in
&& reset_out
)
3912 action
->type
= peer_change_reset
;
3914 action
->type
= peer_change_reset_in
;
3916 action
->type
= peer_change_reset_out
;
3918 action
->type
= peer_change_none
;
3923 static void peer_flag_modify_action(struct peer
*peer
, uint32_t flag
)
3925 if (flag
== PEER_FLAG_SHUTDOWN
) {
3926 if (CHECK_FLAG(peer
->flags
, flag
)) {
3927 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3928 peer_nsf_stop(peer
);
3930 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3931 if (peer
->t_pmax_restart
) {
3932 BGP_TIMER_OFF(peer
->t_pmax_restart
);
3933 if (bgp_debug_neighbor_events(peer
))
3935 "%s Maximum-prefix restart timer canceled",
3939 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3940 peer_nsf_stop(peer
);
3942 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3943 char *msg
= peer
->tx_shutdown_message
;
3946 if (!msg
&& peer_group_active(peer
))
3947 msg
= peer
->group
->conf
3948 ->tx_shutdown_message
;
3949 msglen
= msg
? strlen(msg
) : 0;
3954 uint8_t msgbuf
[129];
3957 memcpy(msgbuf
+ 1, msg
, msglen
);
3959 bgp_notify_send_with_data(
3960 peer
, BGP_NOTIFY_CEASE
,
3961 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3962 msgbuf
, msglen
+ 1);
3965 peer
, BGP_NOTIFY_CEASE
,
3966 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3968 bgp_session_reset(peer
);
3970 peer
->v_start
= BGP_INIT_START_TIMER
;
3971 BGP_EVENT_ADD(peer
, BGP_Stop
);
3973 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3974 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3975 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3976 else if (flag
== PEER_FLAG_PASSIVE
)
3977 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3978 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3979 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3981 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3982 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3984 bgp_session_reset(peer
);
3987 /* Change specified peer flag. */
3988 static int peer_flag_modify(struct peer
*peer
, uint32_t flag
, int set
)
3992 bool invert
, member_invert
;
3993 struct peer
*member
;
3994 struct listnode
*node
, *nnode
;
3995 struct peer_flag_action action
;
3997 memset(&action
, 0, sizeof(struct peer_flag_action
));
3998 size
= sizeof peer_flag_action_list
/ sizeof(struct peer_flag_action
);
4000 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4001 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4004 /* Abort if no flag action exists. */
4006 return BGP_ERR_INVALID_FLAG
;
4008 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4009 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4010 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4011 return BGP_ERR_PEER_FLAG_CONFLICT
;
4013 /* Handle flag updates where desired state matches current state. */
4014 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4015 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4016 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4020 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4021 COND_FLAG(peer
->flags_override
, flag
, invert
);
4026 /* Inherit from peer-group or set/unset flags accordingly. */
4027 if (peer_group_active(peer
) && set
== invert
)
4028 peer_flag_inherit(peer
, flag
);
4030 COND_FLAG(peer
->flags
, flag
, set
);
4032 /* Check if handling a regular peer. */
4033 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4034 /* Update flag override state accordingly. */
4035 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4037 /* Execute flag action on peer. */
4038 if (action
.type
== peer_change_reset
)
4039 peer_flag_modify_action(peer
, flag
);
4041 /* Skip peer-group mechanics for regular peers. */
4046 * Update peer-group members, unless they are explicitely overriding
4047 * peer-group configuration.
4049 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4050 /* Skip peers with overridden configuration. */
4051 if (CHECK_FLAG(member
->flags_override
, flag
))
4054 /* Check if only member without group is inverted. */
4056 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4058 /* Skip peers with equivalent configuration. */
4059 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4062 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4065 /* Update flag on peer-group member. */
4066 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4068 /* Execute flag action on peer-group member. */
4069 if (action
.type
== peer_change_reset
)
4070 peer_flag_modify_action(member
, flag
);
4076 int peer_flag_set(struct peer
*peer
, uint32_t flag
)
4078 return peer_flag_modify(peer
, flag
, 1);
4081 int peer_flag_unset(struct peer
*peer
, uint32_t flag
)
4083 return peer_flag_modify(peer
, flag
, 0);
4086 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4087 uint32_t flag
, bool set
)
4091 int addpath_tx_used
;
4092 bool invert
, member_invert
;
4094 struct peer
*member
;
4095 struct listnode
*node
, *nnode
;
4096 struct peer_flag_action action
;
4098 memset(&action
, 0, sizeof(struct peer_flag_action
));
4099 size
= sizeof peer_af_flag_action_list
4100 / sizeof(struct peer_flag_action
);
4102 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4103 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4106 /* Abort if flag action exists. */
4108 return BGP_ERR_INVALID_FLAG
;
4110 /* Special check for reflector client. */
4111 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
4112 && peer_sort(peer
) != BGP_PEER_IBGP
)
4113 return BGP_ERR_NOT_INTERNAL_PEER
;
4115 /* Special check for remove-private-AS. */
4116 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
4117 && peer_sort(peer
) == BGP_PEER_IBGP
)
4118 return BGP_ERR_REMOVE_PRIVATE_AS
;
4120 /* as-override is not allowed for IBGP peers */
4121 if (flag
& PEER_FLAG_AS_OVERRIDE
&& peer_sort(peer
) == BGP_PEER_IBGP
)
4122 return BGP_ERR_AS_OVERRIDE
;
4124 /* Handle flag updates where desired state matches current state. */
4125 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4126 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4127 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4132 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4133 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4140 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4141 * if we are setting/unsetting flags which conflict with this flag
4142 * handle accordingly
4144 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4148 * if we are setting NEXTHOP_SELF, we need to unset the
4149 * NEXTHOP_UNCHANGED flag
4151 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4152 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4153 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4154 PEER_FLAG_NEXTHOP_UNCHANGED
);
4158 * if we are unsetting NEXTHOP_SELF, we need to set the
4159 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4161 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4162 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4163 SET_FLAG(peer
->af_flags
[afi
][safi
],
4164 PEER_FLAG_NEXTHOP_UNCHANGED
);
4168 /* Inherit from peer-group or set/unset flags accordingly. */
4169 if (peer_group_active(peer
) && set
== invert
)
4170 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4172 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4174 /* Execute action when peer is established. */
4175 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4176 && peer
->status
== Established
) {
4177 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4178 bgp_clear_adj_in(peer
, afi
, safi
);
4180 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4181 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4182 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4183 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4184 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4185 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4186 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4187 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4189 peer_change_action(peer
, afi
, safi
, action
.type
);
4193 /* Check if handling a regular peer. */
4194 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4195 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4199 * Update peer-group members, unless they are explicitely
4200 * overriding peer-group configuration.
4202 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4204 /* Skip peers with overridden configuration. */
4205 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4209 /* Check if only member without group is inverted. */
4211 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4215 /* Skip peers with equivalent configuration. */
4216 if (set
!= member_invert
4217 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4220 if (set
== member_invert
4221 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4224 /* Update flag on peer-group member. */
4225 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4226 set
!= member_invert
);
4228 /* Execute flag action on peer-group member. */
4229 if (member
->status
== Established
) {
4230 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4231 bgp_clear_adj_in(member
, afi
, safi
);
4233 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4234 member
->last_reset
=
4235 PEER_DOWN_RR_CLIENT_CHANGE
;
4237 == PEER_FLAG_RSERVER_CLIENT
)
4238 member
->last_reset
=
4239 PEER_DOWN_RS_CLIENT_CHANGE
;
4241 == PEER_FLAG_ORF_PREFIX_SM
)
4242 member
->last_reset
=
4243 PEER_DOWN_CAPABILITY_CHANGE
;
4245 == PEER_FLAG_ORF_PREFIX_RM
)
4246 member
->last_reset
=
4247 PEER_DOWN_CAPABILITY_CHANGE
;
4249 peer_change_action(member
, afi
, safi
,
4256 /* Track if addpath TX is in use */
4257 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
4258 | PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
4260 addpath_tx_used
= 0;
4263 addpath_tx_used
= 1;
4265 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
) {
4266 if (!bgp_flag_check(
4267 bgp
, BGP_FLAG_DETERMINISTIC_MED
)) {
4269 "%s: enabling bgp deterministic-med, this is required"
4270 " for addpath-tx-bestpath-per-AS",
4274 BGP_FLAG_DETERMINISTIC_MED
);
4275 bgp_recalculate_all_bestpaths(bgp
);
4279 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
,
4281 if (CHECK_FLAG(member
->af_flags
[afi
][safi
],
4282 PEER_FLAG_ADDPATH_TX_ALL_PATHS
)
4284 member
->af_flags
[afi
][safi
],
4285 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
4286 addpath_tx_used
= 1;
4292 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4298 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4300 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4303 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4305 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4309 int peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4311 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4312 peer
->tx_shutdown_message
=
4313 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4317 int peer_tx_shutdown_message_unset(struct peer
*peer
)
4319 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4324 /* EBGP multihop configuration. */
4325 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4327 struct peer_group
*group
;
4328 struct listnode
*node
, *nnode
;
4331 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4334 /* see comment in peer_ttl_security_hops_set() */
4335 if (ttl
!= MAXTTL
) {
4336 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4337 group
= peer
->group
;
4338 if (group
->conf
->gtsm_hops
!= 0)
4339 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4341 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4343 if (peer1
->sort
== BGP_PEER_IBGP
)
4346 if (peer1
->gtsm_hops
!= 0)
4347 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4350 if (peer
->gtsm_hops
!= 0)
4351 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4357 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4358 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
) {
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
);
4366 group
= peer
->group
;
4367 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4368 if (peer
->sort
== BGP_PEER_IBGP
)
4371 peer
->ttl
= group
->conf
->ttl
;
4373 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4374 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4375 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4377 bgp_session_reset(peer
);
4383 int peer_ebgp_multihop_unset(struct peer
*peer
)
4385 struct peer_group
*group
;
4386 struct listnode
*node
, *nnode
;
4388 if (peer
->sort
== BGP_PEER_IBGP
)
4391 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4392 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4394 if (peer_group_active(peer
))
4395 peer
->ttl
= peer
->group
->conf
->ttl
;
4399 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4400 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4401 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4402 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4404 bgp_session_reset(peer
);
4406 group
= peer
->group
;
4407 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4408 if (peer
->sort
== BGP_PEER_IBGP
)
4413 if (peer
->fd
>= 0) {
4414 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4416 peer
, BGP_NOTIFY_CEASE
,
4417 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4419 bgp_session_reset(peer
);
4426 /* Neighbor description. */
4427 int peer_description_set(struct peer
*peer
, const char *desc
)
4430 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4432 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
4437 int peer_description_unset(struct peer
*peer
)
4440 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4447 /* Neighbor update-source. */
4448 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
4450 struct peer_group
*group
;
4451 struct listnode
*node
, *nnode
;
4453 if (peer
->update_if
) {
4454 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4455 && strcmp(peer
->update_if
, ifname
) == 0)
4458 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4459 peer
->update_if
= NULL
;
4462 if (peer
->update_source
) {
4463 sockunion_free(peer
->update_source
);
4464 peer
->update_source
= NULL
;
4467 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4469 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4470 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4471 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4472 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4473 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4475 bgp_session_reset(peer
);
4479 /* peer-group member updates. */
4480 group
= peer
->group
;
4481 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4482 if (peer
->update_if
) {
4483 if (strcmp(peer
->update_if
, ifname
) == 0)
4486 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4487 peer
->update_if
= NULL
;
4490 if (peer
->update_source
) {
4491 sockunion_free(peer
->update_source
);
4492 peer
->update_source
= NULL
;
4495 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4497 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4498 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4499 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4500 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4502 bgp_session_reset(peer
);
4507 int peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
4509 struct peer_group
*group
;
4510 struct listnode
*node
, *nnode
;
4512 if (peer
->update_source
) {
4513 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4514 && sockunion_cmp(peer
->update_source
, su
) == 0)
4516 sockunion_free(peer
->update_source
);
4517 peer
->update_source
= NULL
;
4520 if (peer
->update_if
) {
4521 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4522 peer
->update_if
= NULL
;
4525 peer
->update_source
= sockunion_dup(su
);
4527 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4528 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4529 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4530 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4531 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4533 bgp_session_reset(peer
);
4537 /* peer-group member updates. */
4538 group
= peer
->group
;
4539 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4540 if (peer
->update_source
) {
4541 if (sockunion_cmp(peer
->update_source
, su
) == 0)
4543 sockunion_free(peer
->update_source
);
4544 peer
->update_source
= NULL
;
4547 if (peer
->update_if
) {
4548 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4549 peer
->update_if
= NULL
;
4552 peer
->update_source
= sockunion_dup(su
);
4554 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4555 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4556 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4557 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4559 bgp_session_reset(peer
);
4564 int peer_update_source_unset(struct peer
*peer
)
4566 union sockunion
*su
;
4567 struct peer_group
*group
;
4568 struct listnode
*node
, *nnode
;
4570 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
) && !peer
->update_source
4571 && !peer
->update_if
)
4574 if (peer
->update_source
) {
4575 sockunion_free(peer
->update_source
);
4576 peer
->update_source
= NULL
;
4578 if (peer
->update_if
) {
4579 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4580 peer
->update_if
= NULL
;
4583 if (peer_group_active(peer
)) {
4584 group
= peer
->group
;
4586 if (group
->conf
->update_source
) {
4587 su
= sockunion_dup(group
->conf
->update_source
);
4588 peer
->update_source
= su
;
4589 } else if (group
->conf
->update_if
)
4590 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
,
4591 group
->conf
->update_if
);
4594 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4595 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4596 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4597 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4598 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4600 bgp_session_reset(peer
);
4604 /* peer-group member updates. */
4605 group
= peer
->group
;
4606 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4607 if (!peer
->update_source
&& !peer
->update_if
)
4610 if (peer
->update_source
) {
4611 sockunion_free(peer
->update_source
);
4612 peer
->update_source
= NULL
;
4615 if (peer
->update_if
) {
4616 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4617 peer
->update_if
= NULL
;
4620 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4621 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4622 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4623 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4625 bgp_session_reset(peer
);
4630 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
4633 struct peer
*member
;
4634 struct listnode
*node
, *nnode
;
4636 /* Set flag and configuration on peer. */
4637 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
4639 if (!peer
->default_rmap
[afi
][safi
].name
4640 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
4641 if (peer
->default_rmap
[afi
][safi
].name
)
4642 XFREE(MTYPE_ROUTE_MAP_NAME
,
4643 peer
->default_rmap
[afi
][safi
].name
);
4645 peer
->default_rmap
[afi
][safi
].name
=
4646 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4647 peer
->default_rmap
[afi
][safi
].map
=
4648 route_map_lookup_by_name(rmap
);
4651 if (peer
->default_rmap
[afi
][safi
].name
)
4652 XFREE(MTYPE_ROUTE_MAP_NAME
,
4653 peer
->default_rmap
[afi
][safi
].name
);
4655 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4656 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4659 /* Check if handling a regular peer. */
4660 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4661 /* Update peer route announcements. */
4662 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4663 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4664 bgp_default_originate(peer
, afi
, safi
, 0);
4665 bgp_announce_route(peer
, afi
, safi
);
4668 /* Skip peer-group mechanics for regular peers. */
4673 * Set flag and configuration on all peer-group members, unless they are
4674 * explicitely overriding peer-group configuration.
4676 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4677 /* Skip peers with overridden configuration. */
4678 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4679 PEER_FLAG_DEFAULT_ORIGINATE
))
4682 /* Set flag and configuration on peer-group member. */
4683 SET_FLAG(member
->af_flags
[afi
][safi
],
4684 PEER_FLAG_DEFAULT_ORIGINATE
);
4686 if (member
->default_rmap
[afi
][safi
].name
)
4687 XFREE(MTYPE_ROUTE_MAP_NAME
,
4688 member
->default_rmap
[afi
][safi
].name
);
4690 member
->default_rmap
[afi
][safi
].name
=
4691 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4692 member
->default_rmap
[afi
][safi
].map
=
4693 route_map_lookup_by_name(rmap
);
4696 /* Update peer route announcements. */
4697 if (member
->status
== Established
4698 && member
->afc_nego
[afi
][safi
]) {
4699 update_group_adjust_peer(
4700 peer_af_find(member
, afi
, safi
));
4701 bgp_default_originate(member
, afi
, safi
, 0);
4702 bgp_announce_route(member
, afi
, safi
);
4709 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4711 struct peer
*member
;
4712 struct listnode
*node
, *nnode
;
4714 /* Inherit configuration from peer-group if peer is member. */
4715 if (peer_group_active(peer
)) {
4716 peer_af_flag_inherit(peer
, afi
, safi
,
4717 PEER_FLAG_DEFAULT_ORIGINATE
);
4718 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
4719 default_rmap
[afi
][safi
].name
,
4720 MTYPE_ROUTE_MAP_NAME
);
4721 PEER_ATTR_INHERIT(peer
, peer
->group
,
4722 default_rmap
[afi
][safi
].map
);
4724 /* Otherwise remove flag and configuration from peer. */
4725 peer_af_flag_unset(peer
, afi
, safi
,
4726 PEER_FLAG_DEFAULT_ORIGINATE
);
4727 if (peer
->default_rmap
[afi
][safi
].name
)
4728 XFREE(MTYPE_ROUTE_MAP_NAME
,
4729 peer
->default_rmap
[afi
][safi
].name
);
4730 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4731 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4734 /* Check if handling a regular peer. */
4735 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4736 /* Update peer route announcements. */
4737 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4738 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4739 bgp_default_originate(peer
, afi
, safi
, 1);
4740 bgp_announce_route(peer
, afi
, safi
);
4743 /* Skip peer-group mechanics for regular peers. */
4748 * Remove flag and configuration from all peer-group members, unless
4749 * they are explicitely overriding peer-group configuration.
4751 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4752 /* Skip peers with overridden configuration. */
4753 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4754 PEER_FLAG_DEFAULT_ORIGINATE
))
4757 /* Remove flag and configuration on peer-group member. */
4758 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4759 PEER_FLAG_DEFAULT_ORIGINATE
);
4760 if (peer
->default_rmap
[afi
][safi
].name
)
4761 XFREE(MTYPE_ROUTE_MAP_NAME
,
4762 peer
->default_rmap
[afi
][safi
].name
);
4763 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4764 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4766 /* Update peer route announcements. */
4767 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4768 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4769 bgp_default_originate(peer
, afi
, safi
, 1);
4770 bgp_announce_route(peer
, afi
, safi
);
4777 int peer_port_set(struct peer
*peer
, uint16_t port
)
4783 int peer_port_unset(struct peer
*peer
)
4785 peer
->port
= BGP_PORT_DEFAULT
;
4790 * Helper function that is called after the name of the policy
4791 * being used by a peer has changed (AF specific). Automatically
4792 * initiates inbound or outbound processing as needed.
4794 static void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
4798 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4799 if (peer
->status
== Established
)
4800 bgp_announce_route(peer
, afi
, safi
);
4802 if (peer
->status
!= Established
)
4805 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4806 PEER_FLAG_SOFT_RECONFIG
))
4807 bgp_soft_reconfig_in(peer
, afi
, safi
);
4808 else if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4809 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4810 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
4815 /* neighbor weight. */
4816 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
4818 struct peer
*member
;
4819 struct listnode
*node
, *nnode
;
4821 /* Set flag and configuration on peer. */
4822 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4823 if (peer
->weight
[afi
][safi
] != weight
) {
4824 peer
->weight
[afi
][safi
] = weight
;
4825 peer_on_policy_change(peer
, afi
, safi
, 0);
4828 /* Skip peer-group mechanics for regular peers. */
4829 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4833 * Set flag and configuration on all peer-group members, unless they are
4834 * explicitely overriding peer-group configuration.
4836 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4837 /* Skip peers with overridden configuration. */
4838 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4842 /* Set flag and configuration on peer-group member. */
4843 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4844 if (member
->weight
[afi
][safi
] != weight
) {
4845 member
->weight
[afi
][safi
] = weight
;
4846 peer_on_policy_change(member
, afi
, safi
, 0);
4853 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4855 struct peer
*member
;
4856 struct listnode
*node
, *nnode
;
4858 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4861 /* Inherit configuration from peer-group if peer is member. */
4862 if (peer_group_active(peer
)) {
4863 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4864 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
4866 peer_on_policy_change(peer
, afi
, safi
, 0);
4870 /* Remove flag and configuration from peer. */
4871 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4872 peer
->weight
[afi
][safi
] = 0;
4873 peer_on_policy_change(peer
, afi
, safi
, 0);
4875 /* Skip peer-group mechanics for regular peers. */
4876 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4880 * Remove flag and configuration from all peer-group members, unless
4881 * they are explicitely overriding peer-group configuration.
4883 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4884 /* Skip peers with overridden configuration. */
4885 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4889 /* Skip peers where flag is already disabled. */
4890 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4893 /* Remove flag and configuration on peer-group member. */
4894 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4895 member
->weight
[afi
][safi
] = 0;
4896 peer_on_policy_change(member
, afi
, safi
, 0);
4902 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
4904 struct peer
*member
;
4905 struct listnode
*node
, *nnode
;
4907 if (keepalive
> 65535)
4908 return BGP_ERR_INVALID_VALUE
;
4910 if (holdtime
> 65535)
4911 return BGP_ERR_INVALID_VALUE
;
4913 if (holdtime
< 3 && holdtime
!= 0)
4914 return BGP_ERR_INVALID_VALUE
;
4916 /* Set flag and configuration on peer. */
4917 peer_flag_set(peer
, PEER_FLAG_TIMER
);
4918 peer
->holdtime
= holdtime
;
4919 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4921 /* Skip peer-group mechanics for regular peers. */
4922 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4926 * Set flag and configuration on all peer-group members, unless they are
4927 * explicitely overriding peer-group configuration.
4929 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4930 /* Skip peers with overridden configuration. */
4931 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
4934 /* Set flag and configuration on peer-group member. */
4935 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
4936 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
4937 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
4943 int peer_timers_unset(struct peer
*peer
)
4945 struct peer
*member
;
4946 struct listnode
*node
, *nnode
;
4948 /* Inherit configuration from peer-group if peer is member. */
4949 if (peer_group_active(peer
)) {
4950 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
4951 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
4952 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
4954 /* Otherwise remove flag and configuration from peer. */
4955 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
4957 peer
->keepalive
= 0;
4960 /* Skip peer-group mechanics for regular peers. */
4961 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4965 * Remove flag and configuration from all peer-group members, unless
4966 * they are explicitely overriding peer-group configuration.
4968 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4969 /* Skip peers with overridden configuration. */
4970 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
4973 /* Remove flag and configuration on peer-group member. */
4974 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
4975 member
->holdtime
= 0;
4976 member
->keepalive
= 0;
4982 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
4984 struct peer
*member
;
4985 struct listnode
*node
, *nnode
;
4987 if (connect
> 65535)
4988 return BGP_ERR_INVALID_VALUE
;
4990 /* Set flag and configuration on peer. */
4991 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
4992 peer
->connect
= connect
;
4993 peer
->v_connect
= connect
;
4995 /* Skip peer-group mechanics for regular peers. */
4996 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5000 * Set flag and configuration on all peer-group members, unless they are
5001 * explicitely overriding peer-group configuration.
5003 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5004 /* Skip peers with overridden configuration. */
5005 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5008 /* Set flag and configuration on peer-group member. */
5009 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5010 member
->connect
= connect
;
5011 member
->v_connect
= connect
;
5017 int peer_timers_connect_unset(struct peer
*peer
)
5019 struct peer
*member
;
5020 struct listnode
*node
, *nnode
;
5022 /* Inherit configuration from peer-group if peer is member. */
5023 if (peer_group_active(peer
)) {
5024 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5025 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5027 /* Otherwise remove flag and configuration from peer. */
5028 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5032 /* Set timer with fallback to default value. */
5034 peer
->v_connect
= peer
->connect
;
5036 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
5038 /* Skip peer-group mechanics for regular peers. */
5039 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5043 * Remove flag and configuration from all peer-group members, unless
5044 * they are explicitely overriding peer-group configuration.
5046 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5047 /* Skip peers with overridden configuration. */
5048 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5051 /* Remove flag and configuration on peer-group member. */
5052 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5053 member
->connect
= 0;
5054 member
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
5060 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5062 struct peer
*member
;
5063 struct listnode
*node
, *nnode
;
5066 return BGP_ERR_INVALID_VALUE
;
5068 /* Set flag and configuration on peer. */
5069 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5070 peer
->routeadv
= routeadv
;
5071 peer
->v_routeadv
= routeadv
;
5073 /* Check if handling a regular peer. */
5074 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5075 /* Update peer route announcements. */
5076 update_group_adjust_peer_afs(peer
);
5077 if (peer
->status
== Established
)
5078 bgp_announce_route_all(peer
);
5080 /* Skip peer-group mechanics for regular peers. */
5085 * Set flag and configuration on all peer-group members, unless they are
5086 * explicitely overriding peer-group configuration.
5088 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5089 /* Skip peers with overridden configuration. */
5090 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5093 /* Set flag and configuration on peer-group member. */
5094 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5095 member
->routeadv
= routeadv
;
5096 member
->v_routeadv
= routeadv
;
5098 /* Update peer route announcements. */
5099 update_group_adjust_peer_afs(member
);
5100 if (member
->status
== Established
)
5101 bgp_announce_route_all(member
);
5107 int peer_advertise_interval_unset(struct peer
*peer
)
5109 struct peer
*member
;
5110 struct listnode
*node
, *nnode
;
5112 /* Inherit configuration from peer-group if peer is member. */
5113 if (peer_group_active(peer
)) {
5114 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
5115 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
5117 /* Otherwise remove flag and configuration from peer. */
5118 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
5122 /* Set timer with fallback to default value. */
5124 peer
->v_routeadv
= peer
->routeadv
;
5126 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
5127 ? BGP_DEFAULT_IBGP_ROUTEADV
5128 : BGP_DEFAULT_EBGP_ROUTEADV
;
5130 /* Check if handling a regular peer. */
5131 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5132 /* Update peer route announcements. */
5133 update_group_adjust_peer_afs(peer
);
5134 if (peer
->status
== Established
)
5135 bgp_announce_route_all(peer
);
5137 /* Skip peer-group mechanics for regular peers. */
5142 * Remove flag and configuration from all peer-group members, unless
5143 * they are explicitely overriding peer-group configuration.
5145 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5146 /* Skip peers with overridden configuration. */
5147 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5150 /* Remove flag and configuration on peer-group member. */
5151 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5152 member
->routeadv
= 0;
5153 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
5154 ? BGP_DEFAULT_IBGP_ROUTEADV
5155 : BGP_DEFAULT_EBGP_ROUTEADV
;
5157 /* Update peer route announcements. */
5158 update_group_adjust_peer_afs(member
);
5159 if (member
->status
== Established
)
5160 bgp_announce_route_all(member
);
5166 /* neighbor interface */
5167 void peer_interface_set(struct peer
*peer
, const char *str
)
5170 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5171 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
5174 void peer_interface_unset(struct peer
*peer
)
5177 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5178 peer
->ifname
= NULL
;
5182 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5183 int allow_num
, int origin
)
5185 struct peer
*member
;
5186 struct listnode
*node
, *nnode
;
5188 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
5189 return BGP_ERR_INVALID_VALUE
;
5191 /* Set flag and configuration on peer. */
5192 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5194 if (peer
->allowas_in
[afi
][safi
] != 0
5195 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5196 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5197 peer_af_flag_set(peer
, afi
, safi
,
5198 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5199 peer
->allowas_in
[afi
][safi
] = 0;
5200 peer_on_policy_change(peer
, afi
, safi
, 0);
5203 if (peer
->allowas_in
[afi
][safi
] != allow_num
5204 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5205 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5207 peer_af_flag_unset(peer
, afi
, safi
,
5208 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5209 peer
->allowas_in
[afi
][safi
] = allow_num
;
5210 peer_on_policy_change(peer
, afi
, safi
, 0);
5214 /* Skip peer-group mechanics for regular peers. */
5215 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5219 * Set flag and configuration on all peer-group members, unless
5220 * they are explicitely overriding peer-group configuration.
5222 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5223 /* Skip peers with overridden configuration. */
5224 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5225 PEER_FLAG_ALLOWAS_IN
))
5228 /* Set flag and configuration on peer-group member. */
5229 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5231 if (member
->allowas_in
[afi
][safi
] != 0
5232 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
5233 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5234 SET_FLAG(member
->af_flags
[afi
][safi
],
5235 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5236 member
->allowas_in
[afi
][safi
] = 0;
5237 peer_on_policy_change(peer
, afi
, safi
, 0);
5240 if (member
->allowas_in
[afi
][safi
] != allow_num
5241 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
5242 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5243 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5244 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5245 member
->allowas_in
[afi
][safi
] = allow_num
;
5246 peer_on_policy_change(peer
, afi
, safi
, 0);
5254 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5256 struct peer
*member
;
5257 struct listnode
*node
, *nnode
;
5259 /* Skip peer if flag is already disabled. */
5260 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
5263 /* Inherit configuration from peer-group if peer is member. */
5264 if (peer_group_active(peer
)) {
5265 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5266 peer_af_flag_inherit(peer
, afi
, safi
,
5267 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5268 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
5269 peer_on_policy_change(peer
, afi
, safi
, 0);
5274 /* Remove flag and configuration from peer. */
5275 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5276 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5277 peer
->allowas_in
[afi
][safi
] = 0;
5278 peer_on_policy_change(peer
, afi
, safi
, 0);
5280 /* Skip peer-group mechanics if handling a regular peer. */
5281 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5285 * Remove flags and configuration from all peer-group members, unless
5286 * they are explicitely overriding peer-group configuration.
5288 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5289 /* Skip peers with overridden configuration. */
5290 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5291 PEER_FLAG_ALLOWAS_IN
))
5294 /* Skip peers where flag is already disabled. */
5295 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
],
5296 PEER_FLAG_ALLOWAS_IN
))
5299 /* Remove flags and configuration on peer-group member. */
5300 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5301 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5302 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5303 member
->allowas_in
[afi
][safi
] = 0;
5304 peer_on_policy_change(member
, afi
, safi
, 0);
5310 int peer_local_as_set(struct peer
*peer
, as_t as
, int no_prepend
,
5313 struct bgp
*bgp
= peer
->bgp
;
5314 struct peer_group
*group
;
5315 struct listnode
*node
, *nnode
;
5317 if (peer_sort(peer
) != BGP_PEER_EBGP
5318 && peer_sort(peer
) != BGP_PEER_INTERNAL
)
5319 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5322 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5325 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5327 if (peer
->change_local_as
== as
5328 && ((CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
5330 || (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
5332 && ((CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)
5334 || (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)
5338 peer
->change_local_as
= as
;
5340 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5342 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5345 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5347 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5349 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5350 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5351 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5352 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5353 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5355 bgp_session_reset(peer
);
5359 group
= peer
->group
;
5360 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5361 peer
->change_local_as
= as
;
5363 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5365 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5368 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5370 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5372 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5373 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5374 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5375 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5377 BGP_EVENT_ADD(peer
, BGP_Stop
);
5383 int peer_local_as_unset(struct peer
*peer
)
5385 struct peer_group
*group
;
5386 struct listnode
*node
, *nnode
;
5388 if (!peer
->change_local_as
)
5391 peer
->change_local_as
= 0;
5392 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5393 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5395 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5396 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5397 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5398 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5399 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5401 BGP_EVENT_ADD(peer
, BGP_Stop
);
5406 group
= peer
->group
;
5407 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5408 peer
->change_local_as
= 0;
5409 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5410 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5412 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5413 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5414 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5415 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5417 bgp_session_reset(peer
);
5422 /* Set password for authenticating with the peer. */
5423 int peer_password_set(struct peer
*peer
, const char *password
)
5425 struct listnode
*nn
, *nnode
;
5426 int len
= password
? strlen(password
) : 0;
5427 int ret
= BGP_SUCCESS
;
5429 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5430 return BGP_ERR_INVALID_VALUE
;
5432 if (peer
->password
&& strcmp(peer
->password
, password
) == 0
5433 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5437 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5439 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5441 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5442 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5443 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5444 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5446 bgp_session_reset(peer
);
5448 if (BGP_PEER_SU_UNSPEC(peer
))
5451 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
5452 : BGP_ERR_TCPSIG_FAILED
;
5455 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, nn
, nnode
, peer
)) {
5456 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
5460 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5462 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5464 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5465 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5466 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5468 bgp_session_reset(peer
);
5470 if (!BGP_PEER_SU_UNSPEC(peer
)) {
5471 if (bgp_md5_set(peer
) < 0)
5472 ret
= BGP_ERR_TCPSIG_FAILED
;
5479 int peer_password_unset(struct peer
*peer
)
5481 struct listnode
*nn
, *nnode
;
5483 if (!peer
->password
&& !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5486 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5487 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5488 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5489 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5491 bgp_session_reset(peer
);
5494 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5496 peer
->password
= NULL
;
5498 if (!BGP_PEER_SU_UNSPEC(peer
))
5499 bgp_md5_unset(peer
);
5504 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5505 peer
->password
= NULL
;
5507 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, nn
, nnode
, peer
)) {
5508 if (!peer
->password
)
5511 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5512 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5513 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5515 bgp_session_reset(peer
);
5517 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5518 peer
->password
= NULL
;
5520 if (!BGP_PEER_SU_UNSPEC(peer
))
5521 bgp_md5_unset(peer
);
5528 /* Set distribute list to the peer. */
5529 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5532 struct peer
*member
;
5533 struct bgp_filter
*filter
;
5534 struct listnode
*node
, *nnode
;
5536 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5537 return BGP_ERR_INVALID_VALUE
;
5539 /* Set configuration on peer. */
5540 filter
= &peer
->filter
[afi
][safi
];
5541 if (filter
->plist
[direct
].name
)
5542 return BGP_ERR_PEER_FILTER_CONFLICT
;
5543 if (filter
->dlist
[direct
].name
)
5544 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5545 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5546 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5548 /* Check if handling a regular peer. */
5549 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5550 /* Set override-flag and process peer route updates. */
5551 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5552 PEER_FT_DISTRIBUTE_LIST
);
5553 peer_on_policy_change(peer
, afi
, safi
,
5554 (direct
== FILTER_OUT
) ? 1 : 0);
5556 /* Skip peer-group mechanics for regular peers. */
5561 * Set configuration on all peer-group members, un less they are
5562 * explicitely overriding peer-group configuration.
5564 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5565 /* Skip peers with overridden configuration. */
5566 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5567 PEER_FT_DISTRIBUTE_LIST
))
5570 /* Set configuration on peer-group member. */
5571 filter
= &member
->filter
[afi
][safi
];
5572 if (filter
->dlist
[direct
].name
)
5573 XFREE(MTYPE_BGP_FILTER_NAME
,
5574 filter
->dlist
[direct
].name
);
5575 filter
->dlist
[direct
].name
=
5576 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5577 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5579 /* Process peer route updates. */
5580 peer_on_policy_change(member
, afi
, safi
,
5581 (direct
== FILTER_OUT
) ? 1 : 0);
5587 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5589 struct peer
*member
;
5590 struct bgp_filter
*filter
;
5591 struct listnode
*node
, *nnode
;
5593 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5594 return BGP_ERR_INVALID_VALUE
;
5596 /* Unset override-flag unconditionally. */
5597 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5598 PEER_FT_DISTRIBUTE_LIST
);
5600 /* Inherit configuration from peer-group if peer is member. */
5601 if (peer_group_active(peer
)) {
5602 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5603 filter
[afi
][safi
].dlist
[direct
].name
,
5604 MTYPE_BGP_FILTER_NAME
);
5605 PEER_ATTR_INHERIT(peer
, peer
->group
,
5606 filter
[afi
][safi
].dlist
[direct
].alist
);
5608 /* Otherwise remove configuration from peer. */
5609 filter
= &peer
->filter
[afi
][safi
];
5610 if (filter
->dlist
[direct
].name
)
5611 XFREE(MTYPE_BGP_FILTER_NAME
,
5612 filter
->dlist
[direct
].name
);
5613 filter
->dlist
[direct
].name
= NULL
;
5614 filter
->dlist
[direct
].alist
= NULL
;
5617 /* Check if handling a regular peer. */
5618 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5619 /* Process peer route updates. */
5620 peer_on_policy_change(peer
, afi
, safi
,
5621 (direct
== FILTER_OUT
) ? 1 : 0);
5623 /* Skip peer-group mechanics for regular peers. */
5628 * Remove configuration on all peer-group members, unless they are
5629 * explicitely overriding peer-group configuration.
5631 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5632 /* Skip peers with overridden configuration. */
5633 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5634 PEER_FT_DISTRIBUTE_LIST
))
5637 /* Remove configuration on peer-group member. */
5638 filter
= &member
->filter
[afi
][safi
];
5639 if (filter
->dlist
[direct
].name
)
5640 XFREE(MTYPE_BGP_FILTER_NAME
,
5641 filter
->dlist
[direct
].name
);
5642 filter
->dlist
[direct
].name
= NULL
;
5643 filter
->dlist
[direct
].alist
= NULL
;
5645 /* Process peer route updates. */
5646 peer_on_policy_change(member
, afi
, safi
,
5647 (direct
== FILTER_OUT
) ? 1 : 0);
5653 /* Update distribute list. */
5654 static void peer_distribute_update(struct access_list
*access
)
5659 struct listnode
*mnode
, *mnnode
;
5660 struct listnode
*node
, *nnode
;
5663 struct peer_group
*group
;
5664 struct bgp_filter
*filter
;
5666 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5668 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
5669 access
->name
, 0, 0);
5670 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5671 FOREACH_AFI_SAFI (afi
, safi
) {
5672 filter
= &peer
->filter
[afi
][safi
];
5674 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5676 if (filter
->dlist
[direct
].name
)
5677 filter
->dlist
[direct
]
5678 .alist
= access_list_lookup(
5680 filter
->dlist
[direct
]
5683 filter
->dlist
[direct
].alist
=
5688 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5689 FOREACH_AFI_SAFI (afi
, safi
) {
5690 filter
= &group
->conf
->filter
[afi
][safi
];
5692 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5694 if (filter
->dlist
[direct
].name
)
5695 filter
->dlist
[direct
]
5696 .alist
= access_list_lookup(
5698 filter
->dlist
[direct
]
5701 filter
->dlist
[direct
].alist
=
5707 vnc_prefix_list_update(bgp
);
5712 /* Set prefix list to the peer. */
5713 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5716 struct peer
*member
;
5717 struct bgp_filter
*filter
;
5718 struct listnode
*node
, *nnode
;
5720 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5721 return BGP_ERR_INVALID_VALUE
;
5723 /* Set configuration on peer. */
5724 filter
= &peer
->filter
[afi
][safi
];
5725 if (filter
->dlist
[direct
].name
)
5726 return BGP_ERR_PEER_FILTER_CONFLICT
;
5727 if (filter
->plist
[direct
].name
)
5728 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5729 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5730 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5732 /* Check if handling a regular peer. */
5733 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5734 /* Set override-flag and process peer route updates. */
5735 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5736 PEER_FT_PREFIX_LIST
);
5737 peer_on_policy_change(peer
, afi
, safi
,
5738 (direct
== FILTER_OUT
) ? 1 : 0);
5740 /* Skip peer-group mechanics for regular peers. */
5745 * Set configuration on all peer-group members, unless they are
5746 * explicitely overriding peer-group configuration.
5748 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5749 /* Skip peers with overridden configuration. */
5750 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5751 PEER_FT_PREFIX_LIST
))
5754 /* Set configuration on peer-group member. */
5755 filter
= &member
->filter
[afi
][safi
];
5756 if (filter
->plist
[direct
].name
)
5757 XFREE(MTYPE_BGP_FILTER_NAME
,
5758 filter
->plist
[direct
].name
);
5759 filter
->plist
[direct
].name
=
5760 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5761 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5763 /* Process peer route updates. */
5764 peer_on_policy_change(member
, afi
, safi
,
5765 (direct
== FILTER_OUT
) ? 1 : 0);
5771 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
5774 struct peer
*member
;
5775 struct bgp_filter
*filter
;
5776 struct listnode
*node
, *nnode
;
5778 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5779 return BGP_ERR_INVALID_VALUE
;
5781 /* Unset override-flag unconditionally. */
5782 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5783 PEER_FT_PREFIX_LIST
);
5785 /* Inherit configuration from peer-group if peer is member. */
5786 if (peer_group_active(peer
)) {
5787 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5788 filter
[afi
][safi
].plist
[direct
].name
,
5789 MTYPE_BGP_FILTER_NAME
);
5790 PEER_ATTR_INHERIT(peer
, peer
->group
,
5791 filter
[afi
][safi
].plist
[direct
].plist
);
5793 /* Otherwise remove configuration from peer. */
5794 filter
= &peer
->filter
[afi
][safi
];
5795 if (filter
->plist
[direct
].name
)
5796 XFREE(MTYPE_BGP_FILTER_NAME
,
5797 filter
->plist
[direct
].name
);
5798 filter
->plist
[direct
].name
= NULL
;
5799 filter
->plist
[direct
].plist
= NULL
;
5802 /* Check if handling a regular peer. */
5803 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5804 /* Process peer route updates. */
5805 peer_on_policy_change(peer
, afi
, safi
,
5806 (direct
== FILTER_OUT
) ? 1 : 0);
5808 /* Skip peer-group mechanics for regular peers. */
5813 * Remove configuration on all peer-group members, unless they are
5814 * explicitely overriding peer-group configuration.
5816 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5817 /* Skip peers with overridden configuration. */
5818 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5819 PEER_FT_PREFIX_LIST
))
5822 /* Remove configuration on peer-group member. */
5823 filter
= &member
->filter
[afi
][safi
];
5824 if (filter
->plist
[direct
].name
)
5825 XFREE(MTYPE_BGP_FILTER_NAME
,
5826 filter
->plist
[direct
].name
);
5827 filter
->plist
[direct
].name
= NULL
;
5828 filter
->plist
[direct
].plist
= NULL
;
5830 /* Process peer route updates. */
5831 peer_on_policy_change(member
, afi
, safi
,
5832 (direct
== FILTER_OUT
) ? 1 : 0);
5838 /* Update prefix-list list. */
5839 static void peer_prefix_list_update(struct prefix_list
*plist
)
5841 struct listnode
*mnode
, *mnnode
;
5842 struct listnode
*node
, *nnode
;
5845 struct peer_group
*group
;
5846 struct bgp_filter
*filter
;
5851 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5854 * Update the prefix-list on update groups.
5856 update_group_policy_update(
5857 bgp
, BGP_POLICY_PREFIX_LIST
,
5858 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5860 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5861 FOREACH_AFI_SAFI (afi
, safi
) {
5862 filter
= &peer
->filter
[afi
][safi
];
5864 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5866 if (filter
->plist
[direct
].name
)
5867 filter
->plist
[direct
]
5868 .plist
= prefix_list_lookup(
5870 filter
->plist
[direct
]
5873 filter
->plist
[direct
].plist
=
5878 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5879 FOREACH_AFI_SAFI (afi
, safi
) {
5880 filter
= &group
->conf
->filter
[afi
][safi
];
5882 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5884 if (filter
->plist
[direct
].name
)
5885 filter
->plist
[direct
]
5886 .plist
= prefix_list_lookup(
5888 filter
->plist
[direct
]
5891 filter
->plist
[direct
].plist
=
5899 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5902 struct peer
*member
;
5903 struct bgp_filter
*filter
;
5904 struct listnode
*node
, *nnode
;
5906 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5907 return BGP_ERR_INVALID_VALUE
;
5909 /* Set configuration on peer. */
5910 filter
= &peer
->filter
[afi
][safi
];
5911 if (filter
->aslist
[direct
].name
)
5912 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5913 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5914 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
5916 /* Check if handling a regular peer. */
5917 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5918 /* Set override-flag and process peer route updates. */
5919 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5920 PEER_FT_FILTER_LIST
);
5921 peer_on_policy_change(peer
, afi
, safi
,
5922 (direct
== FILTER_OUT
) ? 1 : 0);
5924 /* Skip peer-group mechanics for regular peers. */
5929 * Set configuration on all peer-group members, unless they are
5930 * explicitely overriding peer-group configuration.
5932 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5933 /* Skip peers with overridden configuration. */
5934 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5935 PEER_FT_FILTER_LIST
))
5938 /* Set configuration on peer-group member. */
5939 filter
= &member
->filter
[afi
][safi
];
5940 if (filter
->aslist
[direct
].name
)
5941 XFREE(MTYPE_BGP_FILTER_NAME
,
5942 filter
->aslist
[direct
].name
);
5943 filter
->aslist
[direct
].name
=
5944 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5945 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
5947 /* Process peer route updates. */
5948 peer_on_policy_change(member
, afi
, safi
,
5949 (direct
== FILTER_OUT
) ? 1 : 0);
5955 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5957 struct peer
*member
;
5958 struct bgp_filter
*filter
;
5959 struct listnode
*node
, *nnode
;
5961 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5962 return BGP_ERR_INVALID_VALUE
;
5964 /* Unset override-flag unconditionally. */
5965 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5966 PEER_FT_FILTER_LIST
);
5968 /* Inherit configuration from peer-group if peer is member. */
5969 if (peer_group_active(peer
)) {
5970 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5971 filter
[afi
][safi
].aslist
[direct
].name
,
5972 MTYPE_BGP_FILTER_NAME
);
5973 PEER_ATTR_INHERIT(peer
, peer
->group
,
5974 filter
[afi
][safi
].aslist
[direct
].aslist
);
5976 /* Otherwise remove configuration from peer. */
5977 filter
= &peer
->filter
[afi
][safi
];
5978 if (filter
->aslist
[direct
].name
)
5979 XFREE(MTYPE_BGP_FILTER_NAME
,
5980 filter
->aslist
[direct
].name
);
5981 filter
->aslist
[direct
].name
= NULL
;
5982 filter
->aslist
[direct
].aslist
= NULL
;
5985 /* Check if handling a regular peer. */
5986 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5987 /* Process peer route updates. */
5988 peer_on_policy_change(peer
, afi
, safi
,
5989 (direct
== FILTER_OUT
) ? 1 : 0);
5991 /* Skip peer-group mechanics for regular peers. */
5996 * Remove configuration on all peer-group members, unless they are
5997 * explicitely overriding peer-group configuration.
5999 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6000 /* Skip peers with overridden configuration. */
6001 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6002 PEER_FT_FILTER_LIST
))
6005 /* Remove configuration on peer-group member. */
6006 filter
= &member
->filter
[afi
][safi
];
6007 if (filter
->aslist
[direct
].name
)
6008 XFREE(MTYPE_BGP_FILTER_NAME
,
6009 filter
->aslist
[direct
].name
);
6010 filter
->aslist
[direct
].name
= NULL
;
6011 filter
->aslist
[direct
].aslist
= NULL
;
6013 /* Process peer route updates. */
6014 peer_on_policy_change(member
, afi
, safi
,
6015 (direct
== FILTER_OUT
) ? 1 : 0);
6021 static void peer_aslist_update(const char *aslist_name
)
6026 struct listnode
*mnode
, *mnnode
;
6027 struct listnode
*node
, *nnode
;
6030 struct peer_group
*group
;
6031 struct bgp_filter
*filter
;
6033 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6034 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
6037 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6038 FOREACH_AFI_SAFI (afi
, safi
) {
6039 filter
= &peer
->filter
[afi
][safi
];
6041 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6043 if (filter
->aslist
[direct
].name
)
6044 filter
->aslist
[direct
]
6045 .aslist
= as_list_lookup(
6046 filter
->aslist
[direct
]
6049 filter
->aslist
[direct
].aslist
=
6054 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6055 FOREACH_AFI_SAFI (afi
, safi
) {
6056 filter
= &group
->conf
->filter
[afi
][safi
];
6058 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6060 if (filter
->aslist
[direct
].name
)
6061 filter
->aslist
[direct
]
6062 .aslist
= as_list_lookup(
6063 filter
->aslist
[direct
]
6066 filter
->aslist
[direct
].aslist
=
6074 static void peer_aslist_add(char *aslist_name
)
6076 peer_aslist_update(aslist_name
);
6077 route_map_notify_dependencies((char *)aslist_name
,
6078 RMAP_EVENT_ASLIST_ADDED
);
6081 static void peer_aslist_del(const char *aslist_name
)
6083 peer_aslist_update(aslist_name
);
6084 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
6088 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6091 struct peer
*member
;
6092 struct bgp_filter
*filter
;
6093 struct listnode
*node
, *nnode
;
6095 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6096 return BGP_ERR_INVALID_VALUE
;
6098 /* Set configuration on peer. */
6099 filter
= &peer
->filter
[afi
][safi
];
6100 if (filter
->map
[direct
].name
)
6101 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6102 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6103 filter
->map
[direct
].map
= route_map_lookup_by_name(name
);
6105 /* Check if handling a regular peer. */
6106 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6107 /* Set override-flag and process peer route updates. */
6108 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6110 peer_on_policy_change(peer
, afi
, safi
,
6111 (direct
== RMAP_OUT
) ? 1 : 0);
6113 /* Skip peer-group mechanics for regular peers. */
6118 * Set configuration on all peer-group members, unless they are
6119 * explicitely overriding peer-group configuration.
6121 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6122 /* Skip peers with overridden configuration. */
6123 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6127 /* Set configuration on peer-group member. */
6128 filter
= &member
->filter
[afi
][safi
];
6129 if (filter
->map
[direct
].name
)
6130 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6131 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6132 filter
->map
[direct
].map
= route_map_lookup_by_name(name
);
6134 /* Process peer route updates. */
6135 peer_on_policy_change(member
, afi
, safi
,
6136 (direct
== RMAP_OUT
) ? 1 : 0);
6141 /* Unset route-map from the peer. */
6142 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6144 struct peer
*member
;
6145 struct bgp_filter
*filter
;
6146 struct listnode
*node
, *nnode
;
6148 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6149 return BGP_ERR_INVALID_VALUE
;
6151 /* Unset override-flag unconditionally. */
6152 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
6154 /* Inherit configuration from peer-group if peer is member. */
6155 if (peer_group_active(peer
)) {
6156 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6157 filter
[afi
][safi
].map
[direct
].name
,
6158 MTYPE_BGP_FILTER_NAME
);
6159 PEER_ATTR_INHERIT(peer
, peer
->group
,
6160 filter
[afi
][safi
].map
[direct
].map
);
6162 /* Otherwise remove configuration from peer. */
6163 filter
= &peer
->filter
[afi
][safi
];
6164 if (filter
->map
[direct
].name
)
6165 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6166 filter
->map
[direct
].name
= NULL
;
6167 filter
->map
[direct
].map
= NULL
;
6170 /* Check if handling a regular peer. */
6171 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6172 /* Process peer route updates. */
6173 peer_on_policy_change(peer
, afi
, safi
,
6174 (direct
== RMAP_OUT
) ? 1 : 0);
6176 /* Skip peer-group mechanics for regular peers. */
6181 * Remove configuration on all peer-group members, unless they are
6182 * explicitely overriding peer-group configuration.
6184 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6185 /* Skip peers with overridden configuration. */
6186 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6190 /* Remove configuration on peer-group member. */
6191 filter
= &member
->filter
[afi
][safi
];
6192 if (filter
->map
[direct
].name
)
6193 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6194 filter
->map
[direct
].name
= NULL
;
6195 filter
->map
[direct
].map
= NULL
;
6197 /* Process peer route updates. */
6198 peer_on_policy_change(member
, afi
, safi
,
6199 (direct
== RMAP_OUT
) ? 1 : 0);
6205 /* Set unsuppress-map to the peer. */
6206 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6209 struct peer
*member
;
6210 struct bgp_filter
*filter
;
6211 struct listnode
*node
, *nnode
;
6213 /* Set configuration on peer. */
6214 filter
= &peer
->filter
[afi
][safi
];
6215 if (filter
->usmap
.name
)
6216 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6217 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6218 filter
->usmap
.map
= route_map_lookup_by_name(name
);
6220 /* Check if handling a regular peer. */
6221 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6222 /* Set override-flag and process peer route updates. */
6223 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
6224 PEER_FT_UNSUPPRESS_MAP
);
6225 peer_on_policy_change(peer
, afi
, safi
, 1);
6227 /* Skip peer-group mechanics for regular peers. */
6232 * Set configuration on all peer-group members, unless they are
6233 * explicitely overriding peer-group configuration.
6235 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6236 /* Skip peers with overridden configuration. */
6237 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6238 PEER_FT_UNSUPPRESS_MAP
))
6241 /* Set configuration on peer-group member. */
6242 filter
= &member
->filter
[afi
][safi
];
6243 if (filter
->usmap
.name
)
6244 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6245 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6246 filter
->usmap
.map
= route_map_lookup_by_name(name
);
6248 /* Process peer route updates. */
6249 peer_on_policy_change(member
, afi
, safi
, 1);
6255 /* Unset route-map from the peer. */
6256 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6258 struct peer
*member
;
6259 struct bgp_filter
*filter
;
6260 struct listnode
*node
, *nnode
;
6262 /* Unset override-flag unconditionally. */
6263 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
6265 /* Inherit configuration from peer-group if peer is member. */
6266 if (peer_group_active(peer
)) {
6267 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6268 filter
[afi
][safi
].usmap
.name
,
6269 MTYPE_BGP_FILTER_NAME
);
6270 PEER_ATTR_INHERIT(peer
, peer
->group
,
6271 filter
[afi
][safi
].usmap
.map
);
6273 /* Otherwise remove configuration from peer. */
6274 filter
= &peer
->filter
[afi
][safi
];
6275 if (filter
->usmap
.name
)
6276 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6277 filter
->usmap
.name
= NULL
;
6278 filter
->usmap
.map
= NULL
;
6281 /* Check if handling a regular peer. */
6282 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6283 /* Process peer route updates. */
6284 peer_on_policy_change(peer
, afi
, safi
, 1);
6286 /* Skip peer-group mechanics for regular peers. */
6291 * Remove configuration on all peer-group members, unless they are
6292 * explicitely overriding peer-group configuration.
6294 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6295 /* Skip peers with overridden configuration. */
6296 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6297 PEER_FT_UNSUPPRESS_MAP
))
6300 /* Remove configuration on peer-group member. */
6301 filter
= &member
->filter
[afi
][safi
];
6302 if (filter
->usmap
.name
)
6303 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6304 filter
->usmap
.name
= NULL
;
6305 filter
->usmap
.map
= NULL
;
6307 /* Process peer route updates. */
6308 peer_on_policy_change(member
, afi
, safi
, 1);
6314 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6315 uint32_t max
, uint8_t threshold
, int warning
,
6318 struct peer
*member
;
6319 struct listnode
*node
, *nnode
;
6321 /* Set flags and configuration on peer. */
6322 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6324 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6326 peer_af_flag_unset(peer
, afi
, safi
,
6327 PEER_FLAG_MAX_PREFIX_WARNING
);
6329 peer
->pmax
[afi
][safi
] = max
;
6330 peer
->pmax_threshold
[afi
][safi
] = threshold
;
6331 peer
->pmax_restart
[afi
][safi
] = restart
;
6333 /* Check if handling a regular peer. */
6334 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6335 /* Re-check if peer violates maximum-prefix. */
6336 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6337 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
6339 /* Skip peer-group mechanics for regular peers. */
6344 * Set flags and configuration on all peer-group members, unless they
6345 * are explicitely overriding peer-group configuration.
6347 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6348 /* Skip peers with overridden configuration. */
6349 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6350 PEER_FLAG_MAX_PREFIX
))
6353 /* Set flag and configuration on peer-group member. */
6354 member
->pmax
[afi
][safi
] = max
;
6355 member
->pmax_threshold
[afi
][safi
] = threshold
;
6356 member
->pmax_restart
[afi
][safi
] = restart
;
6358 SET_FLAG(member
->af_flags
[afi
][safi
],
6359 PEER_FLAG_MAX_PREFIX_WARNING
);
6361 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6362 PEER_FLAG_MAX_PREFIX_WARNING
);
6364 /* Re-check if peer violates maximum-prefix. */
6365 if ((member
->status
== Established
) && (member
->afc
[afi
][safi
]))
6366 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
6372 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6374 struct peer
*member
;
6375 struct listnode
*node
, *nnode
;
6377 /* Inherit configuration from peer-group if peer is member. */
6378 if (peer_group_active(peer
)) {
6379 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6380 peer_af_flag_inherit(peer
, afi
, safi
,
6381 PEER_FLAG_MAX_PREFIX_WARNING
);
6382 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
6383 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
6384 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
6389 /* Remove flags and configuration from peer. */
6390 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6391 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6392 peer
->pmax
[afi
][safi
] = 0;
6393 peer
->pmax_threshold
[afi
][safi
] = 0;
6394 peer
->pmax_restart
[afi
][safi
] = 0;
6397 * Remove flags and configuration from all peer-group members, unless
6398 * they are explicitely overriding peer-group configuration.
6400 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6401 /* Skip peers with overridden configuration. */
6402 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6403 PEER_FLAG_MAX_PREFIX
))
6406 /* Remove flag and configuration on peer-group member. */
6407 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6408 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6409 PEER_FLAG_MAX_PREFIX_WARNING
);
6410 member
->pmax
[afi
][safi
] = 0;
6411 member
->pmax_threshold
[afi
][safi
] = 0;
6412 member
->pmax_restart
[afi
][safi
] = 0;
6418 int is_ebgp_multihop_configured(struct peer
*peer
)
6420 struct peer_group
*group
;
6421 struct listnode
*node
, *nnode
;
6424 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6425 group
= peer
->group
;
6426 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
6427 && (group
->conf
->ttl
!= 1))
6430 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
6431 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
6432 && (peer1
->ttl
!= 1))
6436 if ((peer_sort(peer
) != BGP_PEER_IBGP
) && (peer
->ttl
!= 1))
6442 /* Set # of hops between us and BGP peer. */
6443 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
6445 struct peer_group
*group
;
6446 struct listnode
*node
, *nnode
;
6449 zlog_debug("peer_ttl_security_hops_set: set gtsm_hops to %d for %s",
6450 gtsm_hops
, peer
->host
);
6452 /* We cannot configure ttl-security hops when ebgp-multihop is already
6453 set. For non peer-groups, the check is simple. For peer-groups,
6455 slightly messy, because we need to check both the peer-group
6457 and all peer-group members for any trace of ebgp-multihop
6459 before actually applying the ttl-security rules. Cisco really made a
6460 mess of this configuration parameter, and OpenBGPD got it right.
6463 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
)) {
6464 if (is_ebgp_multihop_configured(peer
))
6465 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6467 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6468 peer
->gtsm_hops
= gtsm_hops
;
6470 /* Calling ebgp multihop also resets the session.
6471 * On restart, NHT will get setup correctly as will the
6472 * min & max ttls on the socket. The return value is
6475 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
6480 group
= peer
->group
;
6481 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6483 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6485 /* Calling ebgp multihop also resets the
6487 * On restart, NHT will get setup correctly as
6489 * min & max ttls on the socket. The return
6493 peer_ebgp_multihop_set(peer
, MAXTTL
);
6497 /* Post the first gtsm setup or if its ibgp, maxttl setting
6499 * necessary, just set the minttl.
6501 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6502 peer
->gtsm_hops
= gtsm_hops
;
6505 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6506 MAXTTL
+ 1 - gtsm_hops
);
6507 if ((peer
->status
< Established
) && peer
->doppelganger
6508 && (peer
->doppelganger
->fd
>= 0))
6509 sockopt_minttl(peer
->su
.sa
.sa_family
,
6510 peer
->doppelganger
->fd
,
6511 MAXTTL
+ 1 - gtsm_hops
);
6513 group
= peer
->group
;
6514 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6516 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6518 /* Change setting of existing peer
6519 * established then change value (may break
6521 * not established yet (teardown session and
6523 * no session then do nothing (will get
6524 * handled by next connection)
6526 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6528 peer
->su
.sa
.sa_family
, peer
->fd
,
6529 MAXTTL
+ 1 - peer
->gtsm_hops
);
6530 if ((peer
->status
< Established
)
6531 && peer
->doppelganger
6532 && (peer
->doppelganger
->fd
>= 0))
6533 sockopt_minttl(peer
->su
.sa
.sa_family
,
6534 peer
->doppelganger
->fd
,
6535 MAXTTL
+ 1 - gtsm_hops
);
6543 int peer_ttl_security_hops_unset(struct peer
*peer
)
6545 struct peer_group
*group
;
6546 struct listnode
*node
, *nnode
;
6549 zlog_debug("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s",
6552 /* if a peer-group member, then reset to peer-group default rather than
6554 if (peer_group_active(peer
))
6555 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6557 peer
->gtsm_hops
= 0;
6559 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6560 /* Invoking ebgp_multihop_set will set the TTL back to the
6562 * value as well as restting the NHT and such. The session is
6565 if (peer
->sort
== BGP_PEER_EBGP
)
6566 ret
= peer_ebgp_multihop_unset(peer
);
6569 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6572 if ((peer
->status
< Established
) && peer
->doppelganger
6573 && (peer
->doppelganger
->fd
>= 0))
6574 sockopt_minttl(peer
->su
.sa
.sa_family
,
6575 peer
->doppelganger
->fd
, 0);
6578 group
= peer
->group
;
6579 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
6580 peer
->gtsm_hops
= 0;
6581 if (peer
->sort
== BGP_PEER_EBGP
)
6582 ret
= peer_ebgp_multihop_unset(peer
);
6585 sockopt_minttl(peer
->su
.sa
.sa_family
,
6588 if ((peer
->status
< Established
)
6589 && peer
->doppelganger
6590 && (peer
->doppelganger
->fd
>= 0))
6591 sockopt_minttl(peer
->su
.sa
.sa_family
,
6592 peer
->doppelganger
->fd
,
6602 * If peer clear is invoked in a loop for all peers on the BGP instance,
6603 * it may end up freeing the doppelganger, and if this was the next node
6604 * to the current node, we would end up accessing the freed next node.
6605 * Pass along additional parameter which can be updated if next node
6606 * is freed; only required when walking the peer list on BGP instance.
6608 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
6610 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)) {
6611 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
)) {
6612 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6613 if (peer
->t_pmax_restart
) {
6614 BGP_TIMER_OFF(peer
->t_pmax_restart
);
6615 if (bgp_debug_neighbor_events(peer
))
6617 "%s Maximum-prefix restart timer canceled",
6620 BGP_EVENT_ADD(peer
, BGP_Start
);
6624 peer
->v_start
= BGP_INIT_START_TIMER
;
6625 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6626 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6627 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6629 bgp_session_reset_safe(peer
, nnode
);
6634 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
6635 enum bgp_clear_type stype
)
6637 struct peer_af
*paf
;
6639 if (peer
->status
!= Established
)
6642 if (!peer
->afc
[afi
][safi
])
6643 return BGP_ERR_AF_UNCONFIGURED
;
6645 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
6647 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
6648 /* Clear the "neighbor x.x.x.x default-originate" flag */
6649 paf
= peer_af_find(peer
, afi
, safi
);
6650 if (paf
&& paf
->subgroup
6651 && CHECK_FLAG(paf
->subgroup
->sflags
,
6652 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6653 UNSET_FLAG(paf
->subgroup
->sflags
,
6654 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6656 bgp_announce_route(peer
, afi
, safi
);
6659 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6660 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6661 PEER_CAP_ORF_PREFIX_SM_ADV
)
6662 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6663 PEER_CAP_ORF_PREFIX_RM_RCV
)
6664 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6665 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
6666 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6667 uint8_t prefix_type
;
6669 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6670 PEER_CAP_ORF_PREFIX_RM_RCV
))
6671 prefix_type
= ORF_TYPE_PREFIX
;
6673 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6675 if (filter
->plist
[FILTER_IN
].plist
) {
6676 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6677 PEER_STATUS_ORF_PREFIX_SEND
))
6678 bgp_route_refresh_send(
6679 peer
, afi
, safi
, prefix_type
,
6681 bgp_route_refresh_send(peer
, afi
, safi
,
6683 REFRESH_IMMEDIATE
, 0);
6685 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6686 PEER_STATUS_ORF_PREFIX_SEND
))
6687 bgp_route_refresh_send(
6688 peer
, afi
, safi
, prefix_type
,
6689 REFRESH_IMMEDIATE
, 1);
6691 bgp_route_refresh_send(peer
, afi
, safi
,
6698 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6699 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6700 /* If neighbor has soft reconfiguration inbound flag.
6701 Use Adj-RIB-In database. */
6702 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6703 PEER_FLAG_SOFT_RECONFIG
))
6704 bgp_soft_reconfig_in(peer
, afi
, safi
);
6706 /* If neighbor has route refresh capability, send route
6708 message to the peer. */
6709 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6710 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6711 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0,
6714 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6720 /* Display peer uptime.*/
6721 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, uint8_t use_json
,
6724 time_t uptime1
, epoch_tbuf
;
6727 /* Check buffer length. */
6728 if (len
< BGP_UPTIME_LEN
) {
6730 zlog_warn("peer_uptime (): buffer shortage %lu",
6731 (unsigned long)len
);
6732 /* XXX: should return status instead of buf... */
6733 snprintf(buf
, len
, "<error> ");
6738 /* If there is no connection has been done before print `never'. */
6741 json_object_string_add(json
, "peerUptime", "never");
6742 json_object_int_add(json
, "peerUptimeMsec", 0);
6744 snprintf(buf
, len
, "never");
6748 /* Get current time. */
6749 uptime1
= bgp_clock();
6751 tm
= gmtime(&uptime1
);
6753 if (uptime1
< ONE_DAY_SECOND
)
6754 snprintf(buf
, len
, "%02d:%02d:%02d", tm
->tm_hour
, tm
->tm_min
,
6756 else if (uptime1
< ONE_WEEK_SECOND
)
6757 snprintf(buf
, len
, "%dd%02dh%02dm", tm
->tm_yday
, tm
->tm_hour
,
6759 else if (uptime1
< ONE_YEAR_SECOND
)
6760 snprintf(buf
, len
, "%02dw%dd%02dh", tm
->tm_yday
/ 7,
6761 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7), tm
->tm_hour
);
6763 snprintf(buf
, len
, "%02dy%02dw%dd", tm
->tm_year
- 70,
6765 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7));
6768 epoch_tbuf
= time(NULL
) - uptime1
;
6769 json_object_string_add(json
, "peerUptime", buf
);
6770 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
6771 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
6778 static void bgp_config_write_filter(struct vty
*vty
, struct peer
*peer
,
6779 afi_t afi
, safi_t safi
)
6781 struct bgp_filter
*filter
;
6785 filter
= &peer
->filter
[afi
][safi
];
6787 /* distribute-list. */
6788 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_DISTRIBUTE_LIST
,
6790 vty_out(vty
, " neighbor %s distribute-list %s in\n", addr
,
6791 filter
->dlist
[FILTER_IN
].name
);
6793 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_DISTRIBUTE_LIST
,
6795 vty_out(vty
, " neighbor %s distribute-list %s out\n", addr
,
6796 filter
->dlist
[FILTER_OUT
].name
);
6799 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_PREFIX_LIST
,
6801 vty_out(vty
, " neighbor %s prefix-list %s in\n", addr
,
6802 filter
->plist
[FILTER_IN
].name
);
6804 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_PREFIX_LIST
,
6806 vty_out(vty
, " neighbor %s prefix-list %s out\n", addr
,
6807 filter
->plist
[FILTER_OUT
].name
);
6810 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_ROUTE_MAP
, RMAP_IN
))
6811 vty_out(vty
, " neighbor %s route-map %s in\n", addr
,
6812 filter
->map
[RMAP_IN
].name
);
6814 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_ROUTE_MAP
,
6816 vty_out(vty
, " neighbor %s route-map %s out\n", addr
,
6817 filter
->map
[RMAP_OUT
].name
);
6819 /* unsuppress-map */
6820 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_UNSUPPRESS_MAP
, 0))
6821 vty_out(vty
, " neighbor %s unsuppress-map %s\n", addr
,
6822 filter
->usmap
.name
);
6825 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_FILTER_LIST
,
6827 vty_out(vty
, " neighbor %s filter-list %s in\n", addr
,
6828 filter
->aslist
[FILTER_IN
].name
);
6830 if (peergroup_filter_check(peer
, afi
, safi
, PEER_FT_FILTER_LIST
,
6832 vty_out(vty
, " neighbor %s filter-list %s out\n", addr
,
6833 filter
->aslist
[FILTER_OUT
].name
);
6836 /* BGP peer configuration display function. */
6837 static void bgp_config_write_peer_global(struct vty
*vty
, struct bgp
*bgp
,
6840 struct peer
*g_peer
= NULL
;
6841 char buf
[SU_ADDRSTRLEN
];
6843 int if_pg_printed
= FALSE
;
6844 int if_ras_printed
= FALSE
;
6846 /* Skip dynamic neighbors. */
6847 if (peer_dynamic_neighbor(peer
))
6851 addr
= peer
->conf_if
;
6855 /************************************
6856 ****** Global to the neighbor ******
6857 ************************************/
6858 if (peer
->conf_if
) {
6859 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6860 vty_out(vty
, " neighbor %s interface v6only", addr
);
6862 vty_out(vty
, " neighbor %s interface", addr
);
6864 if (peer_group_active(peer
)) {
6865 vty_out(vty
, " peer-group %s", peer
->group
->name
);
6866 if_pg_printed
= TRUE
;
6867 } else if (peer
->as_type
== AS_SPECIFIED
) {
6868 vty_out(vty
, " remote-as %u", peer
->as
);
6869 if_ras_printed
= TRUE
;
6870 } else if (peer
->as_type
== AS_INTERNAL
) {
6871 vty_out(vty
, " remote-as internal");
6872 if_ras_printed
= TRUE
;
6873 } else if (peer
->as_type
== AS_EXTERNAL
) {
6874 vty_out(vty
, " remote-as external");
6875 if_ras_printed
= TRUE
;
6881 /* remote-as and peer-group */
6882 /* peer is a member of a peer-group */
6883 if (peer_group_active(peer
)) {
6884 g_peer
= peer
->group
->conf
;
6886 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
) {
6887 if (peer
->as_type
== AS_SPECIFIED
) {
6888 vty_out(vty
, " neighbor %s remote-as %u\n",
6890 } else if (peer
->as_type
== AS_INTERNAL
) {
6892 " neighbor %s remote-as internal\n",
6894 } else if (peer
->as_type
== AS_EXTERNAL
) {
6896 " neighbor %s remote-as external\n",
6901 /* For swpX peers we displayed the peer-group
6902 * via 'neighbor swpX interface peer-group WORD' */
6904 vty_out(vty
, " neighbor %s peer-group %s\n", addr
,
6908 /* peer is NOT a member of a peer-group */
6910 /* peer is a peer-group, declare the peer-group */
6911 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6912 vty_out(vty
, " neighbor %s peer-group\n", addr
);
6915 if (!if_ras_printed
) {
6916 if (peer
->as_type
== AS_SPECIFIED
) {
6917 vty_out(vty
, " neighbor %s remote-as %u\n",
6919 } else if (peer
->as_type
== AS_INTERNAL
) {
6921 " neighbor %s remote-as internal\n",
6923 } else if (peer
->as_type
== AS_EXTERNAL
) {
6925 " neighbor %s remote-as external\n",
6932 if (peer
->change_local_as
) {
6933 if (!peer_group_active(peer
)
6934 || peer
->change_local_as
!= g_peer
->change_local_as
6935 || peergroup_flag_check(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
6936 || peergroup_flag_check(peer
,
6937 PEER_FLAG_LOCAL_AS_REPLACE_AS
)) {
6938 vty_out(vty
, " neighbor %s local-as %u", addr
,
6939 peer
->change_local_as
);
6941 if (peergroup_flag_check(peer
,
6942 PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6943 vty_out(vty
, " no-prepend");
6944 if (peergroup_flag_check(peer
,
6945 PEER_FLAG_LOCAL_AS_REPLACE_AS
))
6946 vty_out(vty
, " replace-as");
6954 vty_out(vty
, " neighbor %s description %s\n", addr
, peer
->desc
);
6958 if (peergroup_flag_check(peer
, PEER_FLAG_SHUTDOWN
)) {
6959 if (peer
->tx_shutdown_message
)
6960 vty_out(vty
, " neighbor %s shutdown message %s\n", addr
,
6961 peer
->tx_shutdown_message
);
6963 vty_out(vty
, " neighbor %s shutdown\n", addr
);
6967 if (peer
->bfd_info
) {
6968 if (!peer_group_active(peer
) || !g_peer
->bfd_info
) {
6969 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6974 if (peer
->password
) {
6975 if (!peer_group_active(peer
) || !g_peer
->password
6976 || strcmp(peer
->password
, g_peer
->password
) != 0) {
6977 vty_out(vty
, " neighbor %s password %s\n", addr
,
6983 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
)) {
6984 if (!peer_group_active(peer
)) {
6985 vty_out(vty
, " neighbor %s solo\n", addr
);
6990 if (peer
->port
!= BGP_PORT_DEFAULT
) {
6991 vty_out(vty
, " neighbor %s port %d\n", addr
, peer
->port
);
6994 /* Local interface name */
6996 vty_out(vty
, " neighbor %s interface %s\n", addr
, peer
->ifname
);
7000 if (peergroup_flag_check(peer
, PEER_FLAG_PASSIVE
))
7001 vty_out(vty
, " neighbor %s passive\n", addr
);
7004 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1
7005 && !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
)) {
7006 if (!peer_group_active(peer
) || g_peer
->ttl
!= peer
->ttl
) {
7007 vty_out(vty
, " neighbor %s ebgp-multihop %d\n", addr
,
7012 /* ttl-security hops */
7013 if (peer
->gtsm_hops
!= 0) {
7014 if (!peer_group_active(peer
)
7015 || g_peer
->gtsm_hops
!= peer
->gtsm_hops
) {
7016 vty_out(vty
, " neighbor %s ttl-security hops %d\n",
7017 addr
, peer
->gtsm_hops
);
7021 /* disable-connected-check */
7022 if (peergroup_flag_check(peer
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
7023 vty_out(vty
, " neighbor %s disable-connected-check\n", addr
);
7025 /* enforce-first-as */
7026 if (peergroup_flag_check(peer
, PEER_FLAG_ENFORCE_FIRST_AS
))
7027 vty_out(vty
, " neighbor %s enforce-first-as\n", addr
);
7030 if (peer
->update_if
) {
7031 if (!peer_group_active(peer
) || !g_peer
->update_if
7032 || strcmp(g_peer
->update_if
, peer
->update_if
) != 0) {
7033 vty_out(vty
, " neighbor %s update-source %s\n", addr
,
7037 if (peer
->update_source
) {
7038 if (!peer_group_active(peer
) || !g_peer
->update_source
7039 || sockunion_cmp(g_peer
->update_source
, peer
->update_source
)
7041 vty_out(vty
, " neighbor %s update-source %s\n", addr
,
7042 sockunion2str(peer
->update_source
, buf
,
7047 /* advertisement-interval */
7048 if (peergroup_flag_check(peer
, PEER_FLAG_ROUTEADV
))
7049 vty_out(vty
, " neighbor %s advertisement-interval %u\n", addr
,
7053 if (peergroup_flag_check(peer
, PEER_FLAG_TIMER
))
7054 vty_out(vty
, " neighbor %s timers %u %u\n", addr
,
7055 peer
->keepalive
, peer
->holdtime
);
7057 /* timers connect */
7058 if (peergroup_flag_check(peer
, PEER_FLAG_TIMER_CONNECT
))
7059 vty_out(vty
, " neighbor %s timers connect %u\n", addr
,
7062 /* capability dynamic */
7063 if (peergroup_flag_check(peer
, PEER_FLAG_DYNAMIC_CAPABILITY
))
7064 vty_out(vty
, " neighbor %s capability dynamic\n", addr
);
7066 /* capability extended-nexthop */
7067 if (peergroup_flag_check(peer
, PEER_FLAG_CAPABILITY_ENHE
)) {
7068 if (CHECK_FLAG(peer
->flags_invert
, PEER_FLAG_CAPABILITY_ENHE
))
7070 " no neighbor %s capability extended-nexthop\n",
7074 " neighbor %s capability extended-nexthop\n",
7078 /* dont-capability-negotiation */
7079 if (peergroup_flag_check(peer
, PEER_FLAG_DONT_CAPABILITY
))
7080 vty_out(vty
, " neighbor %s dont-capability-negotiate\n", addr
);
7082 /* override-capability */
7083 if (peergroup_flag_check(peer
, PEER_FLAG_OVERRIDE_CAPABILITY
))
7084 vty_out(vty
, " neighbor %s override-capability\n", addr
);
7086 /* strict-capability-match */
7087 if (peergroup_flag_check(peer
, PEER_FLAG_STRICT_CAP_MATCH
))
7088 vty_out(vty
, " neighbor %s strict-capability-match\n", addr
);
7091 /* BGP peer configuration display function. */
7092 static void bgp_config_write_peer_af(struct vty
*vty
, struct bgp
*bgp
,
7093 struct peer
*peer
, afi_t afi
, safi_t safi
)
7095 struct peer
*g_peer
= NULL
;
7097 bool flag_scomm
, flag_secomm
, flag_slcomm
;
7099 /* Skip dynamic neighbors. */
7100 if (peer_dynamic_neighbor(peer
))
7104 addr
= peer
->conf_if
;
7108 /************************************
7109 ****** Per AF to the neighbor ******
7110 ************************************/
7111 if (peer_group_active(peer
)) {
7112 g_peer
= peer
->group
->conf
;
7114 /* If the peer-group is active but peer is not, print a 'no
7116 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
]) {
7117 vty_out(vty
, " no neighbor %s activate\n", addr
);
7120 /* If the peer-group is not active but peer is, print an
7122 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
]) {
7123 vty_out(vty
, " neighbor %s activate\n", addr
);
7126 if (peer
->afc
[afi
][safi
]) {
7127 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
)) {
7128 if (bgp_flag_check(bgp
,
7129 BGP_FLAG_NO_DEFAULT_IPV4
)) {
7130 vty_out(vty
, " neighbor %s activate\n",
7134 vty_out(vty
, " neighbor %s activate\n", addr
);
7136 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
)) {
7137 if (!bgp_flag_check(bgp
,
7138 BGP_FLAG_NO_DEFAULT_IPV4
)) {
7140 " no neighbor %s activate\n",
7147 /* addpath TX knobs */
7148 if (peergroup_af_flag_check(peer
, afi
, safi
,
7149 PEER_FLAG_ADDPATH_TX_ALL_PATHS
)) {
7150 vty_out(vty
, " neighbor %s addpath-tx-all-paths\n", addr
);
7153 if (peergroup_af_flag_check(peer
, afi
, safi
,
7154 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
7155 vty_out(vty
, " neighbor %s addpath-tx-bestpath-per-AS\n",
7159 /* ORF capability. */
7160 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
)
7161 || peergroup_af_flag_check(peer
, afi
, safi
,
7162 PEER_FLAG_ORF_PREFIX_RM
)) {
7163 vty_out(vty
, " neighbor %s capability orf prefix-list", addr
);
7165 if (peergroup_af_flag_check(peer
, afi
, safi
,
7166 PEER_FLAG_ORF_PREFIX_SM
)
7167 && peergroup_af_flag_check(peer
, afi
, safi
,
7168 PEER_FLAG_ORF_PREFIX_RM
))
7169 vty_out(vty
, " both");
7170 else if (peergroup_af_flag_check(peer
, afi
, safi
,
7171 PEER_FLAG_ORF_PREFIX_SM
))
7172 vty_out(vty
, " send");
7174 vty_out(vty
, " receive");
7178 /* Route reflector client. */
7179 if (peergroup_af_flag_check(peer
, afi
, safi
,
7180 PEER_FLAG_REFLECTOR_CLIENT
)) {
7181 vty_out(vty
, " neighbor %s route-reflector-client\n", addr
);
7184 /* next-hop-self force */
7185 if (peergroup_af_flag_check(peer
, afi
, safi
,
7186 PEER_FLAG_FORCE_NEXTHOP_SELF
)) {
7187 vty_out(vty
, " neighbor %s next-hop-self force\n", addr
);
7191 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
)) {
7192 vty_out(vty
, " neighbor %s next-hop-self\n", addr
);
7195 /* remove-private-AS */
7196 if (peergroup_af_flag_check(peer
, afi
, safi
,
7197 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)) {
7198 vty_out(vty
, " neighbor %s remove-private-AS all replace-AS\n",
7202 else if (peergroup_af_flag_check(peer
, afi
, safi
,
7203 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)) {
7204 vty_out(vty
, " neighbor %s remove-private-AS replace-AS\n",
7208 else if (peergroup_af_flag_check(peer
, afi
, safi
,
7209 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)) {
7210 vty_out(vty
, " neighbor %s remove-private-AS all\n", addr
);
7213 else if (peergroup_af_flag_check(peer
, afi
, safi
,
7214 PEER_FLAG_REMOVE_PRIVATE_AS
)) {
7215 vty_out(vty
, " neighbor %s remove-private-AS\n", addr
);
7219 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
)) {
7220 vty_out(vty
, " neighbor %s as-override\n", addr
);
7223 /* send-community print. */
7224 flag_scomm
= peergroup_af_flag_check(peer
, afi
, safi
,
7225 PEER_FLAG_SEND_COMMUNITY
);
7226 flag_secomm
= peergroup_af_flag_check(peer
, afi
, safi
,
7227 PEER_FLAG_SEND_EXT_COMMUNITY
);
7228 flag_slcomm
= peergroup_af_flag_check(peer
, afi
, safi
,
7229 PEER_FLAG_SEND_LARGE_COMMUNITY
);
7231 if (!bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
7232 if (flag_scomm
&& flag_secomm
&& flag_slcomm
) {
7233 vty_out(vty
, " no neighbor %s send-community all\n",
7238 " no neighbor %s send-community\n",
7242 " no neighbor %s send-community extended\n",
7247 " no neighbor %s send-community large\n",
7251 if (flag_scomm
&& flag_secomm
&& flag_slcomm
) {
7252 vty_out(vty
, " neighbor %s send-community all\n",
7254 } else if (flag_scomm
&& flag_secomm
) {
7255 vty_out(vty
, " neighbor %s send-community both\n",
7259 vty_out(vty
, " neighbor %s send-community\n",
7263 " neighbor %s send-community extended\n",
7267 " neighbor %s send-community large\n",
7272 /* Default information */
7273 if (peergroup_af_flag_check(peer
, afi
, safi
,
7274 PEER_FLAG_DEFAULT_ORIGINATE
)) {
7275 vty_out(vty
, " neighbor %s default-originate", addr
);
7277 if (peer
->default_rmap
[afi
][safi
].name
)
7278 vty_out(vty
, " route-map %s",
7279 peer
->default_rmap
[afi
][safi
].name
);
7284 /* Soft reconfiguration inbound. */
7285 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
)) {
7286 vty_out(vty
, " neighbor %s soft-reconfiguration inbound\n",
7290 /* maximum-prefix. */
7291 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
)) {
7292 vty_out(vty
, " neighbor %s maximum-prefix %lu", addr
,
7293 peer
->pmax
[afi
][safi
]);
7295 if (peer
->pmax_threshold
[afi
][safi
]
7296 != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
7297 vty_out(vty
, " %u", peer
->pmax_threshold
[afi
][safi
]);
7298 if (peer_af_flag_check(peer
, afi
, safi
,
7299 PEER_FLAG_MAX_PREFIX_WARNING
))
7300 vty_out(vty
, " warning-only");
7301 if (peer
->pmax_restart
[afi
][safi
])
7302 vty_out(vty
, " restart %u",
7303 peer
->pmax_restart
[afi
][safi
]);
7308 /* Route server client. */
7309 if (peergroup_af_flag_check(peer
, afi
, safi
,
7310 PEER_FLAG_RSERVER_CLIENT
)) {
7311 vty_out(vty
, " neighbor %s route-server-client\n", addr
);
7314 /* Nexthop-local unchanged. */
7315 if (peergroup_af_flag_check(peer
, afi
, safi
,
7316 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
)) {
7317 vty_out(vty
, " neighbor %s nexthop-local unchanged\n", addr
);
7320 /* allowas-in <1-10> */
7321 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)) {
7322 if (peer_af_flag_check(peer
, afi
, safi
,
7323 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
7324 vty_out(vty
, " neighbor %s allowas-in origin\n", addr
);
7325 } else if (peer
->allowas_in
[afi
][safi
] == 3) {
7326 vty_out(vty
, " neighbor %s allowas-in\n", addr
);
7328 vty_out(vty
, " neighbor %s allowas-in %d\n", addr
,
7329 peer
->allowas_in
[afi
][safi
]);
7334 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7335 vty_out(vty
, " neighbor %s weight %lu\n", addr
,
7336 peer
->weight
[afi
][safi
]);
7339 bgp_config_write_filter(vty
, peer
, afi
, safi
);
7341 /* atribute-unchanged. */
7342 if (peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7343 || (safi
!= SAFI_EVPN
7344 && peer_af_flag_check(peer
, afi
, safi
,
7345 PEER_FLAG_NEXTHOP_UNCHANGED
))
7346 || peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
)) {
7348 if (!peer_group_active(peer
)
7349 || peergroup_af_flag_check(peer
, afi
, safi
,
7350 PEER_FLAG_AS_PATH_UNCHANGED
)
7351 || peergroup_af_flag_check(peer
, afi
, safi
,
7352 PEER_FLAG_NEXTHOP_UNCHANGED
)
7353 || peergroup_af_flag_check(peer
, afi
, safi
,
7354 PEER_FLAG_MED_UNCHANGED
)) {
7357 " neighbor %s attribute-unchanged%s%s%s\n",
7359 peer_af_flag_check(peer
, afi
, safi
,
7360 PEER_FLAG_AS_PATH_UNCHANGED
)
7363 peer_af_flag_check(peer
, afi
, safi
,
7364 PEER_FLAG_NEXTHOP_UNCHANGED
)
7367 peer_af_flag_check(peer
, afi
, safi
,
7368 PEER_FLAG_MED_UNCHANGED
)
7375 /* Address family based peer configuration display. */
7376 static void bgp_config_write_family(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7380 struct peer_group
*group
;
7381 struct listnode
*node
, *nnode
;
7384 vty_frame(vty
, " !\n address-family ");
7385 if (afi
== AFI_IP
) {
7386 if (safi
== SAFI_UNICAST
)
7387 vty_frame(vty
, "ipv4 unicast");
7388 else if (safi
== SAFI_LABELED_UNICAST
)
7389 vty_frame(vty
, "ipv4 labeled-unicast");
7390 else if (safi
== SAFI_MULTICAST
)
7391 vty_frame(vty
, "ipv4 multicast");
7392 else if (safi
== SAFI_MPLS_VPN
)
7393 vty_frame(vty
, "ipv4 vpn");
7394 else if (safi
== SAFI_ENCAP
)
7395 vty_frame(vty
, "ipv4 encap");
7396 else if (safi
== SAFI_FLOWSPEC
)
7397 vty_frame(vty
, "ipv4 flowspec");
7398 } else if (afi
== AFI_IP6
) {
7399 if (safi
== SAFI_UNICAST
)
7400 vty_frame(vty
, "ipv6 unicast");
7401 else if (safi
== SAFI_LABELED_UNICAST
)
7402 vty_frame(vty
, "ipv6 labeled-unicast");
7403 else if (safi
== SAFI_MULTICAST
)
7404 vty_frame(vty
, "ipv6 multicast");
7405 else if (safi
== SAFI_MPLS_VPN
)
7406 vty_frame(vty
, "ipv6 vpn");
7407 else if (safi
== SAFI_ENCAP
)
7408 vty_frame(vty
, "ipv6 encap");
7409 else if (safi
== SAFI_FLOWSPEC
)
7410 vty_frame(vty
, "ipv6 flowspec");
7411 } else if (afi
== AFI_L2VPN
) {
7412 if (safi
== SAFI_EVPN
)
7413 vty_frame(vty
, "l2vpn evpn");
7415 vty_frame(vty
, "\n");
7417 bgp_config_write_distance(vty
, bgp
, afi
, safi
);
7419 bgp_config_write_network(vty
, bgp
, afi
, safi
);
7421 bgp_config_write_redistribute(vty
, bgp
, afi
, safi
);
7423 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
7424 bgp_config_write_peer_af(vty
, bgp
, group
->conf
, afi
, safi
);
7426 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7427 /* Skip dynamic neighbors. */
7428 if (peer_dynamic_neighbor(peer
))
7431 /* Do not display doppelganger peers */
7432 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7433 bgp_config_write_peer_af(vty
, bgp
, peer
, afi
, safi
);
7436 bgp_config_write_maxpaths(vty
, bgp
, afi
, safi
);
7437 bgp_config_write_table_map(vty
, bgp
, afi
, safi
);
7439 if (safi
== SAFI_EVPN
)
7440 bgp_config_write_evpn_info(vty
, bgp
, afi
, safi
);
7442 if (safi
== SAFI_FLOWSPEC
)
7443 bgp_fs_config_write_pbr(vty
, bgp
, afi
, safi
);
7445 if (safi
== SAFI_UNICAST
) {
7446 bgp_vpn_policy_config_write_afi(vty
, bgp
, afi
);
7447 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
7448 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT
)) {
7450 vty_out(vty
, " export vpn\n");
7452 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
7453 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT
)) {
7455 vty_out(vty
, " import vpn\n");
7457 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
7458 BGP_CONFIG_VRF_TO_VRF_IMPORT
)) {
7459 struct listnode
*node
;
7462 for (ALL_LIST_ELEMENTS_RO(
7463 bgp
->vpn_policy
[afi
].import_vrf
, node
,
7465 vty_out(vty
, " import vrf %s\n", name
);
7469 vty_endframe(vty
, " exit-address-family\n");
7472 /* clang-format off */
7473 #if defined(VERSION_TYPE_DEV) && CONFDATE > 20180517
7474 CPP_NOTICE("bgpd: remove 'bgp enforce-first-as' config migration from bgp_config_write")
7476 /* clang-format on */
7478 int bgp_config_write(struct vty
*vty
)
7482 struct peer_group
*group
;
7484 struct listnode
*node
, *nnode
;
7485 struct listnode
*mnode
, *mnnode
;
7487 /* BGP Multiple instance. */
7488 if (!bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
7489 vty_out(vty
, "no bgp multiple-instance\n");
7493 /* BGP Config type. */
7494 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
7495 vty_out(vty
, "bgp config-type cisco\n");
7499 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7500 vty_out(vty
, "bgp route-map delay-timer %u\n",
7501 bm
->rmap_update_timer
);
7504 vty_out(vty
, "!\n");
7506 /* BGP configuration. */
7507 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
7509 /* skip all auto created vrf as they dont have user config */
7510 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_AUTO
))
7513 /* Migrate deprecated 'bgp enforce-first-as'
7514 * config to 'neighbor * enforce-first-as' configs
7516 if (bgp_flag_check(bgp
, BGP_FLAG_ENFORCE_FIRST_AS
)) {
7517 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
7518 peer_flag_set(peer
, PEER_FLAG_ENFORCE_FIRST_AS
);
7519 bgp_flag_unset(bgp
, BGP_FLAG_ENFORCE_FIRST_AS
);
7522 /* Router bgp ASN */
7523 vty_out(vty
, "router bgp %u", bgp
->as
);
7525 if (bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
7527 vty_out(vty
, " %s %s",
7529 == BGP_INSTANCE_TYPE_VIEW
)
7536 /* No Synchronization */
7537 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
))
7538 vty_out(vty
, " no synchronization\n");
7540 /* BGP fast-external-failover. */
7541 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7542 vty_out(vty
, " no bgp fast-external-failover\n");
7544 /* BGP router ID. */
7545 if (bgp
->router_id_static
.s_addr
!= 0)
7546 vty_out(vty
, " bgp router-id %s\n",
7547 inet_ntoa(bgp
->router_id_static
));
7549 /* BGP log-neighbor-changes. */
7550 if (!!bgp_flag_check(bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7551 != DFLT_BGP_LOG_NEIGHBOR_CHANGES
)
7552 vty_out(vty
, " %sbgp log-neighbor-changes\n",
7554 BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7558 /* BGP configuration. */
7559 if (bgp_flag_check(bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7560 vty_out(vty
, " bgp always-compare-med\n");
7562 /* BGP default ipv4-unicast. */
7563 if (bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7564 vty_out(vty
, " no bgp default ipv4-unicast\n");
7566 /* BGP default local-preference. */
7567 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7568 vty_out(vty
, " bgp default local-preference %u\n",
7569 bgp
->default_local_pref
);
7571 /* BGP default show-hostname */
7572 if (!!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7573 != DFLT_BGP_SHOW_HOSTNAME
)
7574 vty_out(vty
, " %sbgp default show-hostname\n",
7575 bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7579 /* BGP default subgroup-pkt-queue-max. */
7580 if (bgp
->default_subgroup_pkt_queue_max
7581 != BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7582 vty_out(vty
, " bgp default subgroup-pkt-queue-max %u\n",
7583 bgp
->default_subgroup_pkt_queue_max
);
7585 /* BGP default autoshutdown neighbors */
7586 if (bgp
->autoshutdown
)
7587 vty_out(vty
, " bgp default shutdown\n");
7589 /* BGP client-to-client reflection. */
7590 if (bgp_flag_check(bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7591 vty_out(vty
, " no bgp client-to-client reflection\n");
7593 /* BGP cluster ID. */
7594 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7595 vty_out(vty
, " bgp cluster-id %s\n",
7596 inet_ntoa(bgp
->cluster_id
));
7598 /* Disable ebgp connected nexthop check */
7599 if (bgp_flag_check(bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7601 " bgp disable-ebgp-connected-route-check\n");
7603 /* Confederation identifier*/
7604 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7605 vty_out(vty
, " bgp confederation identifier %i\n",
7608 /* Confederation peer */
7609 if (bgp
->confed_peers_cnt
> 0) {
7612 vty_out(vty
, " bgp confederation peers");
7614 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7615 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7620 /* BGP deterministic-med. */
7621 if (!!bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7622 != DFLT_BGP_DETERMINISTIC_MED
)
7623 vty_out(vty
, " %sbgp deterministic-med\n",
7624 bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7628 /* BGP update-delay. */
7629 bgp_config_write_update_delay(vty
, bgp
);
7631 if (bgp
->v_maxmed_onstartup
7632 != BGP_MAXMED_ONSTARTUP_UNCONFIGURED
) {
7633 vty_out(vty
, " bgp max-med on-startup %u",
7634 bgp
->v_maxmed_onstartup
);
7635 if (bgp
->maxmed_onstartup_value
7636 != BGP_MAXMED_VALUE_DEFAULT
)
7638 bgp
->maxmed_onstartup_value
);
7641 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
) {
7642 vty_out(vty
, " bgp max-med administrative");
7643 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7644 vty_out(vty
, " %u", bgp
->maxmed_admin_value
);
7649 bgp_config_write_wpkt_quanta(vty
, bgp
);
7651 bgp_config_write_rpkt_quanta(vty
, bgp
);
7654 bgp_config_write_coalesce_time(vty
, bgp
);
7656 /* BGP graceful-restart. */
7657 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7659 " bgp graceful-restart stalepath-time %u\n",
7660 bgp
->stalepath_time
);
7661 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7662 vty_out(vty
, " bgp graceful-restart restart-time %u\n",
7664 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7665 vty_out(vty
, " bgp graceful-restart\n");
7667 /* BGP graceful-shutdown */
7668 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
))
7669 vty_out(vty
, " bgp graceful-shutdown\n");
7671 /* BGP graceful-restart Preserve State F bit. */
7672 if (bgp_flag_check(bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
7674 " bgp graceful-restart preserve-fw-state\n");
7676 /* BGP bestpath method. */
7677 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_IGNORE
))
7678 vty_out(vty
, " bgp bestpath as-path ignore\n");
7679 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_CONFED
))
7680 vty_out(vty
, " bgp bestpath as-path confed\n");
7682 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
)) {
7683 if (bgp_flag_check(bgp
,
7684 BGP_FLAG_MULTIPATH_RELAX_AS_SET
)) {
7686 " bgp bestpath as-path multipath-relax as-set\n");
7689 " bgp bestpath as-path multipath-relax\n");
7693 if (bgp_flag_check(bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7695 " bgp route-reflector allow-outbound-policy\n");
7697 if (bgp_flag_check(bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7698 vty_out(vty
, " bgp bestpath compare-routerid\n");
7699 if (bgp_flag_check(bgp
, BGP_FLAG_MED_CONFED
)
7700 || bgp_flag_check(bgp
, BGP_FLAG_MED_MISSING_AS_WORST
)) {
7701 vty_out(vty
, " bgp bestpath med");
7702 if (bgp_flag_check(bgp
, BGP_FLAG_MED_CONFED
))
7703 vty_out(vty
, " confed");
7704 if (bgp_flag_check(bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7705 vty_out(vty
, " missing-as-worst");
7709 /* BGP network import check. */
7710 if (!!bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
7711 != DFLT_BGP_IMPORT_CHECK
)
7712 vty_out(vty
, " %sbgp network import-check\n",
7713 bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
7717 /* BGP flag dampening. */
7718 if (CHECK_FLAG(bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7719 BGP_CONFIG_DAMPENING
))
7720 bgp_config_write_damp(vty
);
7722 /* BGP timers configuration. */
7723 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7724 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7725 vty_out(vty
, " timers bgp %u %u\n",
7726 bgp
->default_keepalive
, bgp
->default_holdtime
);
7729 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
7730 bgp_config_write_peer_global(vty
, bgp
, group
->conf
);
7733 /* Normal neighbor configuration. */
7734 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7735 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7736 bgp_config_write_peer_global(vty
, bgp
, peer
);
7739 /* listen range and limit for dynamic BGP neighbors */
7740 bgp_config_write_listen(vty
, bgp
);
7742 /* No auto-summary */
7743 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
))
7744 vty_out(vty
, " no auto-summary\n");
7746 /* IPv4 unicast configuration. */
7747 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7749 /* IPv4 multicast configuration. */
7750 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7752 /* IPv4 labeled-unicast configuration. */
7753 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_LABELED_UNICAST
);
7755 /* IPv4 VPN configuration. */
7756 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7758 /* ENCAPv4 configuration. */
7759 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7761 /* FLOWSPEC v4 configuration. */
7762 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_FLOWSPEC
);
7764 /* IPv6 unicast configuration. */
7765 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7767 /* IPv6 multicast configuration. */
7768 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7770 /* IPv6 labeled-unicast configuration. */
7771 bgp_config_write_family(vty
, bgp
, AFI_IP6
,
7772 SAFI_LABELED_UNICAST
);
7774 /* IPv6 VPN configuration. */
7775 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7777 /* ENCAPv6 configuration. */
7778 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7780 /* FLOWSPEC v6 configuration. */
7781 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_FLOWSPEC
);
7783 /* EVPN configuration. */
7784 bgp_config_write_family(vty
, bgp
, AFI_L2VPN
, SAFI_EVPN
);
7787 bgp_rfapi_cfg_write(vty
, bgp
);
7790 vty_out(vty
, "!\n");
7795 void bgp_master_init(struct thread_master
*master
)
7799 memset(&bgp_master
, 0, sizeof(struct bgp_master
));
7802 bm
->bgp
= list_new();
7803 bm
->listen_sockets
= list_new();
7804 bm
->port
= BGP_PORT_DEFAULT
;
7805 bm
->master
= master
;
7806 bm
->start_time
= bgp_clock();
7807 bm
->t_rmap_update
= NULL
;
7808 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7809 bm
->terminating
= false;
7811 bgp_process_queue_init();
7813 /* init the rd id space.
7814 assign 0th index in the bitfield,
7815 so that we start with id 1
7817 bf_init(bm
->rd_idspace
, UINT16_MAX
);
7818 bf_assign_zero_index(bm
->rd_idspace
);
7820 /* Enable multiple instances by default. */
7821 bgp_option_set(BGP_OPT_MULTIPLE_INSTANCE
);
7823 /* mpls label dynamic allocation pool */
7824 bgp_lp_init(bm
->master
, &bm
->labelpool
);
7826 QOBJ_REG(bm
, bgp_master
);
7830 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7831 * instance delete (non-default only) or BGP exit.
7833 static void bgp_if_finish(struct bgp
*bgp
)
7835 struct vrf
*vrf
= vrf_lookup_by_id(bgp
->vrf_id
);
7836 struct interface
*ifp
;
7838 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
7841 FOR_ALL_INTERFACES (vrf
, ifp
) {
7842 struct listnode
*c_node
, *c_nnode
;
7843 struct connected
*c
;
7845 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
7846 bgp_connected_delete(bgp
, c
);
7850 extern void bgp_snmp_init(void);
7852 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
7854 struct vrf
*vrf
= NULL
;
7855 struct listnode
*next
;
7858 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
7859 if (vrf
->vrf_id
!= VRF_DEFAULT
)
7860 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
7863 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
7864 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
7867 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
7871 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
7872 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
7873 {.completions
= NULL
},
7876 static void bgp_pthreads_init()
7880 struct frr_pthread_attr io
= {
7882 .start
= frr_pthread_attr_default
.start
,
7883 .stop
= frr_pthread_attr_default
.stop
,
7885 struct frr_pthread_attr ka
= {
7886 .id
= PTHREAD_KEEPALIVES
,
7887 .start
= bgp_keepalives_start
,
7888 .stop
= bgp_keepalives_stop
,
7890 frr_pthread_new(&io
, "BGP I/O thread");
7891 frr_pthread_new(&ka
, "BGP Keepalives thread");
7894 void bgp_pthreads_run()
7896 struct frr_pthread
*io
= frr_pthread_get(PTHREAD_IO
);
7897 struct frr_pthread
*ka
= frr_pthread_get(PTHREAD_KEEPALIVES
);
7899 frr_pthread_run(io
, NULL
);
7900 frr_pthread_run(ka
, NULL
);
7902 /* Wait until threads are ready. */
7903 frr_pthread_wait_running(io
);
7904 frr_pthread_wait_running(ka
);
7907 void bgp_pthreads_finish()
7909 frr_pthread_stop_all();
7910 frr_pthread_finish();
7916 /* allocates some vital data structures used by peer commands in
7919 /* pre-init pthreads */
7920 bgp_pthreads_init();
7923 bgp_zebra_init(bm
->master
);
7926 vnc_zebra_init(bm
->master
);
7929 /* BGP VTY commands installation. */
7937 bgp_route_map_init();
7938 bgp_scan_vty_init();
7943 bgp_ethernetvpn_init();
7944 bgp_flowspec_vty_init();
7946 /* Access list initialize. */
7948 access_list_add_hook(peer_distribute_update
);
7949 access_list_delete_hook(peer_distribute_update
);
7951 /* Filter list initialize. */
7953 as_list_add_hook(peer_aslist_add
);
7954 as_list_delete_hook(peer_aslist_del
);
7956 /* Prefix list initialize.*/
7958 prefix_list_add_hook(peer_prefix_list_update
);
7959 prefix_list_delete_hook(peer_prefix_list_update
);
7961 /* Community list initialize. */
7962 bgp_clist
= community_list_init();
7967 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
7970 void bgp_terminate(void)
7974 struct listnode
*node
, *nnode
;
7975 struct listnode
*mnode
, *mnnode
;
7979 /* Close the listener sockets first as this prevents peers from
7981 * to reconnect on receiving the peer unconfig message. In the presence
7982 * of a large number of peers this will ensure that no peer is left with
7983 * a dangling connection
7985 /* reverse bgp_master_init */
7988 if (bm
->listen_sockets
)
7989 list_delete_and_null(&bm
->listen_sockets
);
7991 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
))
7992 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
7993 if (peer
->status
== Established
7994 || peer
->status
== OpenSent
7995 || peer
->status
== OpenConfirm
)
7996 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7997 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7999 if (bm
->process_main_queue
)
8000 work_queue_free_and_null(&bm
->process_main_queue
);
8002 if (bm
->t_rmap_update
)
8003 BGP_TIMER_OFF(bm
->t_rmap_update
);