1 /* BGP-4, BGP-4+ daemon program
2 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "sockunion.h"
38 #include "workqueue.h"
46 #include "frr_pthread.h"
49 #include "bgpd/bgpd.h"
50 #include "bgpd/bgp_table.h"
51 #include "bgpd/bgp_aspath.h"
52 #include "bgpd/bgp_route.h"
53 #include "bgpd/bgp_dump.h"
54 #include "bgpd/bgp_debug.h"
55 #include "bgpd/bgp_errors.h"
56 #include "bgpd/bgp_community.h"
57 #include "bgpd/bgp_attr.h"
58 #include "bgpd/bgp_regex.h"
59 #include "bgpd/bgp_clist.h"
60 #include "bgpd/bgp_fsm.h"
61 #include "bgpd/bgp_packet.h"
62 #include "bgpd/bgp_zebra.h"
63 #include "bgpd/bgp_open.h"
64 #include "bgpd/bgp_filter.h"
65 #include "bgpd/bgp_nexthop.h"
66 #include "bgpd/bgp_damp.h"
67 #include "bgpd/bgp_mplsvpn.h"
69 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
70 #include "bgpd/rfapi/rfapi_backend.h"
72 #include "bgpd/bgp_evpn.h"
73 #include "bgpd/bgp_advertise.h"
74 #include "bgpd/bgp_network.h"
75 #include "bgpd/bgp_vty.h"
76 #include "bgpd/bgp_mpath.h"
77 #include "bgpd/bgp_nht.h"
78 #include "bgpd/bgp_updgrp.h"
79 #include "bgpd/bgp_bfd.h"
80 #include "bgpd/bgp_memory.h"
81 #include "bgpd/bgp_evpn_vty.h"
82 #include "bgpd/bgp_keepalives.h"
83 #include "bgpd/bgp_io.h"
84 #include "bgpd/bgp_ecommunity.h"
85 #include "bgpd/bgp_flowspec.h"
86 #include "bgpd/bgp_labelpool.h"
87 #include "bgpd/bgp_pbr.h"
88 #include "bgpd/bgp_addpath.h"
89 #include "bgpd/bgp_evpn_private.h"
90 #include "bgpd/bgp_evpn_mh.h"
91 #include "bgpd/bgp_mac.h"
93 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
94 DEFINE_MTYPE_STATIC(BGPD
, BGP_EVPN_INFO
, "BGP EVPN instance information");
95 DEFINE_QOBJ_TYPE(bgp_master
)
97 DEFINE_QOBJ_TYPE(peer
)
98 DEFINE_HOOK(bgp_inst_delete
, (struct bgp
*bgp
), (bgp
))
100 /* BGP process wide configuration. */
101 static struct bgp_master bgp_master
;
103 /* BGP process wide configuration pointer to export. */
104 struct bgp_master
*bm
;
106 /* BGP community-list. */
107 struct community_list_handler
*bgp_clist
;
109 unsigned int multipath_num
= MULTIPATH_NUM
;
111 static void bgp_if_finish(struct bgp
*bgp
);
112 static void peer_drop_dynamic_neighbor(struct peer
*peer
);
114 extern struct zclient
*zclient
;
116 /* handle main socket creation or deletion */
117 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
119 static int bgp_server_main_created
;
122 if (bgp_server_main_created
)
124 if (bgp_socket(bgp
, bm
->port
, bm
->address
) < 0)
125 return BGP_ERR_INVALID_VALUE
;
126 bgp_server_main_created
= 1;
129 if (!bgp_server_main_created
)
132 bgp_server_main_created
= 0;
136 void bgp_session_reset(struct peer
*peer
)
138 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
139 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
140 peer_delete(peer
->doppelganger
);
142 BGP_EVENT_ADD(peer
, BGP_Stop
);
146 * During session reset, we may delete the doppelganger peer, which would
147 * be the next node to the current node. If the session reset was invoked
148 * during walk of peer list, we would end up accessing the freed next
149 * node. This function moves the next node along.
151 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
156 n
= (nnode
) ? *nnode
: NULL
;
157 npeer
= (n
) ? listgetdata(n
) : NULL
;
159 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
160 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
161 PEER_FLAG_CONFIG_NODE
))) {
162 if (peer
->doppelganger
== npeer
)
163 /* nnode and *nnode are confirmed to be non-NULL here */
164 *nnode
= (*nnode
)->next
;
165 peer_delete(peer
->doppelganger
);
168 BGP_EVENT_ADD(peer
, BGP_Stop
);
171 /* BGP global flag manipulation. */
172 int bgp_option_set(int flag
)
176 case BGP_OPT_NO_LISTEN
:
177 case BGP_OPT_NO_ZEBRA
:
178 SET_FLAG(bm
->options
, flag
);
181 return BGP_ERR_INVALID_FLAG
;
186 int bgp_option_unset(int flag
)
190 case BGP_OPT_NO_ZEBRA
:
192 UNSET_FLAG(bm
->options
, flag
);
195 return BGP_ERR_INVALID_FLAG
;
200 int bgp_option_check(int flag
)
202 return CHECK_FLAG(bm
->options
, flag
);
205 /* Internal function to set BGP structure configureation flag. */
206 static void bgp_config_set(struct bgp
*bgp
, int config
)
208 SET_FLAG(bgp
->config
, config
);
211 static void bgp_config_unset(struct bgp
*bgp
, int config
)
213 UNSET_FLAG(bgp
->config
, config
);
216 static int bgp_config_check(struct bgp
*bgp
, int config
)
218 return CHECK_FLAG(bgp
->config
, config
);
221 /* Set BGP router identifier; distinguish between explicit config and other
224 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
,
228 struct listnode
*node
, *nnode
;
230 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
233 /* EVPN uses router id in RD, withdraw them */
234 if (is_evpn_enabled())
235 bgp_evpn_handle_router_id_update(bgp
, true);
237 vpn_handle_router_id_update(bgp
, true, is_config
);
239 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
241 /* Set all peer's local identifier with this value. */
242 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
243 IPV4_ADDR_COPY(&peer
->local_id
, id
);
245 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
246 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
247 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
248 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
252 /* EVPN uses router id in RD, update them */
253 if (is_evpn_enabled())
254 bgp_evpn_handle_router_id_update(bgp
, false);
256 vpn_handle_router_id_update(bgp
, false, is_config
);
261 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
263 struct listnode
*node
, *nnode
;
265 struct in_addr
*addr
= NULL
;
267 if (router_id
!= NULL
)
268 addr
= (struct in_addr
*)&(router_id
->u
.prefix4
);
270 if (vrf_id
== VRF_DEFAULT
) {
271 /* Router-id change for default VRF has to also update all
273 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
274 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
278 bgp
->router_id_zebra
= *addr
;
280 addr
= &bgp
->router_id_zebra
;
282 if (!bgp
->router_id_static
.s_addr
) {
283 /* Router ID is updated if there are no active
286 if (bgp
->established_peers
== 0) {
287 if (BGP_DEBUG(zebra
, ZEBRA
))
289 "RID change : vrf %s(%u), RTR ID %s",
293 bgp_router_id_set(bgp
, addr
, false);
298 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
301 bgp
->router_id_zebra
= *addr
;
303 addr
= &bgp
->router_id_zebra
;
305 if (!bgp
->router_id_static
.s_addr
) {
306 /* Router ID is updated if there are no active
309 if (bgp
->established_peers
== 0) {
310 if (BGP_DEBUG(zebra
, ZEBRA
))
312 "RID change : vrf %s(%u), RTR ID %s",
316 bgp_router_id_set(bgp
, addr
, false);
324 void bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
326 bgp
->router_id_static
= id
;
327 bgp_router_id_set(bgp
,
328 id
.s_addr
!= INADDR_ANY
? &id
: &bgp
->router_id_zebra
,
329 true /* is config */);
332 /* BGP's cluster-id control. */
333 int bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
336 struct listnode
*node
, *nnode
;
338 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
339 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
342 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
343 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
345 /* Clear all IBGP peer. */
346 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
347 if (peer
->sort
!= BGP_PEER_IBGP
)
350 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
351 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
352 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
353 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
359 int bgp_cluster_id_unset(struct bgp
*bgp
)
362 struct listnode
*node
, *nnode
;
364 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
367 bgp
->cluster_id
.s_addr
= 0;
368 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
370 /* Clear all IBGP peer. */
371 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
372 if (peer
->sort
!= BGP_PEER_IBGP
)
375 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
376 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
377 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
378 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
384 /* time_t value that is monotonicly increasing
385 * and uneffected by adjustments to system clock
387 time_t bgp_clock(void)
395 /* BGP timer configuration. */
396 void bgp_timers_set(struct bgp
*bgp
, uint32_t keepalive
, uint32_t holdtime
,
397 uint32_t connect_retry
)
399 bgp
->default_keepalive
=
400 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
401 bgp
->default_holdtime
= holdtime
;
402 bgp
->default_connect_retry
= connect_retry
;
405 /* mostly for completeness - CLI uses its own defaults */
406 void bgp_timers_unset(struct bgp
*bgp
)
408 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
409 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
410 bgp
->default_connect_retry
= BGP_DEFAULT_CONNECT_RETRY
;
413 /* BGP confederation configuration. */
414 int bgp_confederation_id_set(struct bgp
*bgp
, as_t as
)
417 struct listnode
*node
, *nnode
;
421 return BGP_ERR_INVALID_AS
;
423 /* Remember - were we doing confederation before? */
424 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
426 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
428 /* If we were doing confederation already, this is just an external
429 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
430 were not doing confederation before, reset all EBGP sessions. */
431 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
432 bgp_peer_sort_t ptype
= peer_sort(peer
);
434 /* We're looking for peers who's AS is not local or part of our
436 if (already_confed
) {
437 if (ptype
== BGP_PEER_EBGP
) {
439 if (BGP_IS_VALID_STATE_FOR_NOTIF(
442 PEER_DOWN_CONFED_ID_CHANGE
;
444 peer
, BGP_NOTIFY_CEASE
,
445 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
447 bgp_session_reset_safe(peer
, &nnode
);
450 /* Not doign confederation before, so reset every
453 if (ptype
!= BGP_PEER_IBGP
) {
454 /* Reset the local_as to be our EBGP one */
455 if (ptype
== BGP_PEER_EBGP
)
457 if (BGP_IS_VALID_STATE_FOR_NOTIF(
460 PEER_DOWN_CONFED_ID_CHANGE
;
462 peer
, BGP_NOTIFY_CEASE
,
463 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
465 bgp_session_reset_safe(peer
, &nnode
);
472 int bgp_confederation_id_unset(struct bgp
*bgp
)
475 struct listnode
*node
, *nnode
;
478 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
480 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
481 /* We're looking for peers who's AS is not local */
482 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
483 peer
->local_as
= bgp
->as
;
484 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
485 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
486 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
487 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
491 bgp_session_reset_safe(peer
, &nnode
);
497 /* Is an AS part of the confed or not? */
498 bool bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
505 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
506 if (bgp
->confed_peers
[i
] == as
)
512 /* Add an AS to the confederation set. */
513 int bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
)
516 struct listnode
*node
, *nnode
;
519 return BGP_ERR_INVALID_BGP
;
522 return BGP_ERR_INVALID_AS
;
524 if (bgp_confederation_peers_check(bgp
, as
))
527 if (bgp
->confed_peers
)
529 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
530 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
533 XMALLOC(MTYPE_BGP_CONFED_LIST
,
534 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
536 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
537 bgp
->confed_peers_cnt
++;
539 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
540 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
541 if (peer
->as
== as
) {
542 peer
->local_as
= bgp
->as
;
543 if (BGP_IS_VALID_STATE_FOR_NOTIF(
546 PEER_DOWN_CONFED_PEER_CHANGE
;
548 peer
, BGP_NOTIFY_CEASE
,
549 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
551 bgp_session_reset_safe(peer
, &nnode
);
558 /* Delete an AS from the confederation set. */
559 int bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
564 struct listnode
*node
, *nnode
;
569 if (!bgp_confederation_peers_check(bgp
, as
))
572 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
573 if (bgp
->confed_peers
[i
] == as
)
574 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
575 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
577 bgp
->confed_peers_cnt
--;
579 if (bgp
->confed_peers_cnt
== 0) {
580 if (bgp
->confed_peers
)
581 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
582 bgp
->confed_peers
= NULL
;
585 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
586 bgp
->confed_peers_cnt
* sizeof(as_t
));
588 /* Now reset any peer who's remote AS has just been removed from the
590 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
591 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
592 if (peer
->as
== as
) {
593 peer
->local_as
= bgp
->confed_id
;
594 if (BGP_IS_VALID_STATE_FOR_NOTIF(
597 PEER_DOWN_CONFED_PEER_CHANGE
;
599 peer
, BGP_NOTIFY_CEASE
,
600 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
602 bgp_session_reset_safe(peer
, &nnode
);
610 /* Local preference configuration. */
611 int bgp_default_local_preference_set(struct bgp
*bgp
, uint32_t local_pref
)
616 bgp
->default_local_pref
= local_pref
;
621 int bgp_default_local_preference_unset(struct bgp
*bgp
)
626 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
631 /* Local preference configuration. */
632 int bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
, uint32_t queue_size
)
637 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
642 int bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
646 bgp
->default_subgroup_pkt_queue_max
=
647 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
652 /* Listen limit configuration. */
653 int bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
658 bgp
->dynamic_neighbors_limit
= listen_limit
;
663 int bgp_listen_limit_unset(struct bgp
*bgp
)
668 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
673 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
674 afi_t
*afi
, safi_t
*safi
)
676 /* Map from IANA values to internal values, return error if
677 * values are unrecognized.
679 *afi
= afi_iana2int(pkt_afi
);
680 *safi
= safi_iana2int(pkt_safi
);
681 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
687 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
688 iana_safi_t
*pkt_safi
)
690 /* Map from internal values to IANA values, return error if
691 * internal values are bad (unexpected).
693 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
695 *pkt_afi
= afi_int2iana(afi
);
696 *pkt_safi
= safi_int2iana(safi
);
700 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
709 afid
= afindex(afi
, safi
);
710 if (afid
>= BGP_AF_MAX
)
714 assert(peer
->peer_af_array
[afid
] == NULL
);
716 /* Allocate new peer af */
717 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
719 peer
->peer_af_array
[afid
] = af
;
724 bgp
->af_peer_count
[afi
][safi
]++;
729 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
736 afid
= afindex(afi
, safi
);
737 if (afid
>= BGP_AF_MAX
)
740 return peer
->peer_af_array
[afid
];
743 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
752 afid
= afindex(afi
, safi
);
753 if (afid
>= BGP_AF_MAX
)
756 af
= peer
->peer_af_array
[afid
];
761 bgp_stop_announce_route_timer(af
);
763 if (PAF_SUBGRP(af
)) {
764 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
765 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
766 af
->subgroup
->update_group
->id
,
767 af
->subgroup
->id
, peer
->host
);
771 update_subgroup_remove_peer(af
->subgroup
, af
);
773 if (bgp
->af_peer_count
[afi
][safi
])
774 bgp
->af_peer_count
[afi
][safi
]--;
776 peer
->peer_af_array
[afid
] = NULL
;
777 XFREE(MTYPE_BGP_PEER_AF
, af
);
781 /* Peer comparison function for sorting. */
782 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
784 if (p1
->group
&& !p2
->group
)
787 if (!p1
->group
&& p2
->group
)
790 if (p1
->group
== p2
->group
) {
791 if (p1
->conf_if
&& !p2
->conf_if
)
794 if (!p1
->conf_if
&& p2
->conf_if
)
797 if (p1
->conf_if
&& p2
->conf_if
)
798 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
800 return strcmp(p1
->group
->name
, p2
->group
->name
);
802 return sockunion_cmp(&p1
->su
, &p2
->su
);
805 static unsigned int peer_hash_key_make(const void *p
)
807 const struct peer
*peer
= p
;
808 return sockunion_hash(&peer
->su
);
811 static bool peer_hash_same(const void *p1
, const void *p2
)
813 const struct peer
*peer1
= p1
;
814 const struct peer
*peer2
= p2
;
815 return (sockunion_same(&peer1
->su
, &peer2
->su
)
816 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
817 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
820 void peer_flag_inherit(struct peer
*peer
, uint32_t flag
)
824 /* Skip if peer is not a peer-group member. */
825 if (!peer_group_active(peer
))
828 /* Unset override flag to signal inheritance from peer-group. */
829 UNSET_FLAG(peer
->flags_override
, flag
);
832 * Inherit flag state from peer-group. If the flag of the peer-group is
833 * not being inverted, the peer must inherit the inverse of the current
834 * peer-group flag state.
836 group_val
= CHECK_FLAG(peer
->group
->conf
->flags
, flag
);
837 if (!CHECK_FLAG(peer
->group
->conf
->flags_invert
, flag
)
838 && CHECK_FLAG(peer
->flags_invert
, flag
))
839 COND_FLAG(peer
->flags
, flag
, !group_val
);
841 COND_FLAG(peer
->flags
, flag
, group_val
);
844 int peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
846 return CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
849 void peer_af_flag_inherit(struct peer
*peer
, afi_t afi
, safi_t safi
,
854 /* Skip if peer is not a peer-group member. */
855 if (!peer_group_active(peer
))
858 /* Unset override flag to signal inheritance from peer-group. */
859 UNSET_FLAG(peer
->af_flags_override
[afi
][safi
], flag
);
862 * Inherit flag state from peer-group. If the flag of the peer-group is
863 * not being inverted, the peer must inherit the inverse of the current
864 * peer-group flag state.
866 group_val
= CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
], flag
);
867 if (!CHECK_FLAG(peer
->group
->conf
->af_flags_invert
[afi
][safi
], flag
)
868 && CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
))
869 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, !group_val
);
871 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, group_val
);
874 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
875 static inline bgp_peer_sort_t
peer_calc_sort(struct peer
*peer
)
882 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
883 if (peer
->as_type
== AS_INTERNAL
)
884 return BGP_PEER_IBGP
;
886 else if (peer
->as_type
== AS_EXTERNAL
)
887 return BGP_PEER_EBGP
;
889 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
) {
891 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
899 peer1
= listnode_head(peer
->group
->peer
);
904 return BGP_PEER_INTERNAL
;
908 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
909 if (peer
->local_as
== 0)
910 return BGP_PEER_INTERNAL
;
912 if (peer
->local_as
== peer
->as
) {
913 if (bgp
->as
== bgp
->confed_id
) {
914 if (peer
->local_as
== bgp
->as
)
915 return BGP_PEER_IBGP
;
917 return BGP_PEER_EBGP
;
919 if (peer
->local_as
== bgp
->confed_id
)
920 return BGP_PEER_EBGP
;
922 return BGP_PEER_IBGP
;
926 if (bgp_confederation_peers_check(bgp
, peer
->as
))
927 return BGP_PEER_CONFED
;
929 return BGP_PEER_EBGP
;
931 if (peer
->as_type
== AS_UNSPECIFIED
) {
932 /* check if in peer-group with AS information */
934 && (peer
->group
->conf
->as_type
!= AS_UNSPECIFIED
)) {
935 if (peer
->group
->conf
->as_type
938 == peer
->group
->conf
->as
)
939 return BGP_PEER_IBGP
;
941 return BGP_PEER_EBGP
;
942 } else if (peer
->group
->conf
->as_type
944 return BGP_PEER_IBGP
;
946 return BGP_PEER_EBGP
;
948 /* no AS information anywhere, let caller know */
949 return BGP_PEER_UNSPECIFIED
;
950 } else if (peer
->as_type
!= AS_SPECIFIED
)
951 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
954 return (peer
->local_as
== 0
956 : peer
->local_as
== peer
->as
? BGP_PEER_IBGP
961 /* Calculate and cache the peer "sort" */
962 bgp_peer_sort_t
peer_sort(struct peer
*peer
)
964 peer
->sort
= peer_calc_sort(peer
);
968 bgp_peer_sort_t
peer_sort_lookup(struct peer
*peer
)
973 static void peer_free(struct peer
*peer
)
978 assert(peer
->status
== Deleted
);
982 /* this /ought/ to have been done already through bgp_stop earlier,
983 * but just to be sure..
987 bgp_writes_off(peer
);
988 assert(!peer
->t_write
);
989 assert(!peer
->t_read
);
990 BGP_EVENT_FLUSH(peer
);
992 pthread_mutex_destroy(&peer
->io_mtx
);
994 /* Free connected nexthop, if present */
995 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
996 && !peer_dynamic_neighbor(peer
))
997 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
1000 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1002 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
1003 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1004 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1005 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1007 /* Update source configuration. */
1008 if (peer
->update_source
) {
1009 sockunion_free(peer
->update_source
);
1010 peer
->update_source
= NULL
;
1013 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1015 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1016 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1018 if (peer
->clear_node_queue
)
1019 work_queue_free_and_null(&peer
->clear_node_queue
);
1021 bgp_sync_delete(peer
);
1023 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1025 bfd_info_free(&(peer
->bfd_info
));
1027 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
1028 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
1029 bgp_addpath_set_peer_type(peer
, afi
, safi
,
1034 bgp_unlock(peer
->bgp
);
1036 memset(peer
, 0, sizeof(struct peer
));
1038 XFREE(MTYPE_BGP_PEER
, peer
);
1041 /* increase reference count on a struct peer */
1042 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1044 assert(peer
&& (peer
->lock
>= 0));
1047 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1055 /* decrease reference count on a struct peer
1056 * struct peer is freed and NULL returned if last reference
1058 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1060 assert(peer
&& (peer
->lock
> 0));
1063 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1068 if (peer
->lock
== 0) {
1075 /* BGP GR changes */
1077 int bgp_global_gr_init(struct bgp
*bgp
)
1079 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1080 zlog_debug("%s called ..", __func__
);
1082 int local_GLOBAL_GR_FSM
[BGP_GLOBAL_GR_MODE
][BGP_GLOBAL_GR_EVENT_CMD
] = {
1083 /* GLOBAL_HELPER Mode */
1086 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1087 GLOBAL_GR
, GLOBAL_INVALID
,
1088 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1089 GLOBAL_DISABLE
, GLOBAL_INVALID
1091 /* GLOBAL_GR Mode */
1094 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1095 GLOBAL_INVALID
, GLOBAL_HELPER
,
1096 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1097 GLOBAL_DISABLE
, GLOBAL_INVALID
1099 /* GLOBAL_DISABLE Mode */
1102 /*GLOBAL_GR_cmd */ /*no_Global_GR_cmd*/
1103 GLOBAL_GR
, GLOBAL_INVALID
,
1104 /*GLOBAL_DISABLE_cmd*//*no_Global_Disable_cmd*/
1105 GLOBAL_INVALID
, GLOBAL_HELPER
1107 /* GLOBAL_INVALID Mode */
1110 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1111 GLOBAL_INVALID
, GLOBAL_INVALID
,
1112 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1113 GLOBAL_INVALID
, GLOBAL_INVALID
1116 memcpy(bgp
->GLOBAL_GR_FSM
, local_GLOBAL_GR_FSM
,
1117 sizeof(local_GLOBAL_GR_FSM
));
1119 bgp
->global_gr_present_state
= GLOBAL_HELPER
;
1120 bgp
->present_zebra_gr_state
= ZEBRA_GR_DISABLE
;
1122 return BGP_GR_SUCCESS
;
1125 int bgp_peer_gr_init(struct peer
*peer
)
1127 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
1128 zlog_debug("%s called ..", __func__
);
1130 struct bgp_peer_gr local_Peer_GR_FSM
[BGP_PEER_GR_MODE
]
1131 [BGP_PEER_GR_EVENT_CMD
] = {
1133 /* PEER_HELPER Mode */
1134 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1135 { PEER_GR
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1136 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1137 {PEER_DISABLE
, bgp_peer_gr_action
}, {PEER_INVALID
, NULL
},
1138 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1139 { PEER_INVALID
, NULL
}, {PEER_GLOBAL_INHERIT
,
1140 bgp_peer_gr_action
}
1144 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1145 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1146 bgp_peer_gr_action
},
1147 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1148 {PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1149 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1150 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1153 /* PEER_DISABLE Mode */
1154 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1155 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1156 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1157 { PEER_INVALID
, NULL
}, { PEER_GLOBAL_INHERIT
,
1158 bgp_peer_gr_action
},
1159 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1160 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1163 /* PEER_INVALID Mode */
1164 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1165 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1166 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1167 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1168 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1169 { PEER_INVALID
, NULL
}, { PEER_INVALID
, NULL
},
1172 /* PEER_GLOBAL_INHERIT Mode */
1173 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1174 { PEER_GR
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1175 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1176 { PEER_DISABLE
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
},
1177 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1178 { PEER_HELPER
, bgp_peer_gr_action
}, { PEER_INVALID
, NULL
}
1181 memcpy(&peer
->PEER_GR_FSM
, local_Peer_GR_FSM
,
1182 sizeof(local_Peer_GR_FSM
));
1183 peer
->peer_gr_present_state
= PEER_GLOBAL_INHERIT
;
1184 bgp_peer_move_to_gr_mode(peer
, PEER_GLOBAL_INHERIT
);
1186 return BGP_GR_SUCCESS
;
1189 /* Allocate new peer object, implicitely locked. */
1190 struct peer
*peer_new(struct bgp
*bgp
)
1197 /* bgp argument is absolutely required */
1200 /* Allocate new peer. */
1201 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1203 /* Set default value. */
1205 peer
->v_start
= BGP_INIT_START_TIMER
;
1206 peer
->v_connect
= bgp
->default_connect_retry
;
1207 peer
->status
= Idle
;
1208 peer
->ostatus
= Idle
;
1209 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1210 peer
->bgp
= bgp_lock(bgp
);
1211 peer
= peer_lock(peer
); /* initial reference */
1212 peer
->password
= NULL
;
1214 /* Set default flags. */
1215 FOREACH_AFI_SAFI (afi
, safi
) {
1216 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1217 SET_FLAG(peer
->af_flags
[afi
][safi
],
1218 PEER_FLAG_SEND_EXT_COMMUNITY
);
1219 SET_FLAG(peer
->af_flags
[afi
][safi
],
1220 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1222 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1223 PEER_FLAG_SEND_COMMUNITY
);
1224 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1225 PEER_FLAG_SEND_EXT_COMMUNITY
);
1226 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1227 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1228 peer
->addpath_type
[afi
][safi
] = BGP_ADDPATH_NONE
;
1231 /* set nexthop-unchanged for l2vpn evpn by default */
1232 SET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1233 PEER_FLAG_NEXTHOP_UNCHANGED
);
1235 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1237 /* Initialize per peer bgp GR FSM */
1238 bgp_peer_gr_init(peer
);
1240 /* Create buffers. */
1241 peer
->ibuf
= stream_fifo_new();
1242 peer
->obuf
= stream_fifo_new();
1243 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1245 /* We use a larger buffer for peer->obuf_work in the event that:
1246 * - We RX a BGP_UPDATE where the attributes alone are just
1247 * under BGP_MAX_PACKET_SIZE
1248 * - The user configures an outbound route-map that does many as-path
1249 * prepends or adds many communities. At most they can have
1250 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1251 * large they can make the attributes.
1253 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1254 * bounds checking for every single attribute as we construct an
1258 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1260 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1262 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1264 bgp_sync_init(peer
);
1266 /* Get service port number. */
1267 sp
= getservbyname("bgp", "tcp");
1268 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1270 QOBJ_REG(peer
, peer
);
1275 * This function is invoked when a duplicate peer structure associated with
1276 * a neighbor is being deleted. If this about-to-be-deleted structure is
1277 * the one with all the config, then we have to copy over the info.
1279 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1281 struct peer_af
*paf
;
1289 /* The following function is used by both peer group config copy to
1290 * individual peer and when we transfer config
1292 if (peer_src
->change_local_as
)
1293 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1295 /* peer flags apply */
1296 peer_dst
->flags
= peer_src
->flags
;
1297 peer_dst
->cap
= peer_src
->cap
;
1299 peer_dst
->peer_gr_present_state
= peer_src
->peer_gr_present_state
;
1300 peer_dst
->peer_gr_new_status_flag
= peer_src
->peer_gr_new_status_flag
;
1302 peer_dst
->local_as
= peer_src
->local_as
;
1303 peer_dst
->port
= peer_src
->port
;
1304 (void)peer_sort(peer_dst
);
1305 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1308 peer_dst
->holdtime
= peer_src
->holdtime
;
1309 peer_dst
->keepalive
= peer_src
->keepalive
;
1310 peer_dst
->connect
= peer_src
->connect
;
1311 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1312 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1313 peer_dst
->routeadv
= peer_src
->routeadv
;
1314 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1316 /* password apply */
1317 if (peer_src
->password
&& !peer_dst
->password
)
1318 peer_dst
->password
=
1319 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1321 FOREACH_AFI_SAFI (afi
, safi
) {
1322 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1323 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1324 peer_dst
->allowas_in
[afi
][safi
] =
1325 peer_src
->allowas_in
[afi
][safi
];
1326 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1327 peer_dst
->addpath_type
[afi
][safi
] =
1328 peer_src
->addpath_type
[afi
][safi
];
1331 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1332 paf
= peer_src
->peer_af_array
[afidx
];
1334 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1337 /* update-source apply */
1338 if (peer_src
->update_source
) {
1339 if (peer_dst
->update_source
)
1340 sockunion_free(peer_dst
->update_source
);
1341 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1342 peer_dst
->update_source
=
1343 sockunion_dup(peer_src
->update_source
);
1344 } else if (peer_src
->update_if
) {
1345 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1346 if (peer_dst
->update_source
) {
1347 sockunion_free(peer_dst
->update_source
);
1348 peer_dst
->update_source
= NULL
;
1350 peer_dst
->update_if
=
1351 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1354 if (peer_src
->ifname
) {
1355 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1358 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1362 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1363 struct interface
*ifp
)
1365 struct connected
*ifc
;
1368 struct listnode
*node
;
1370 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1371 * IPv4 address of the other end.
1373 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1374 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1375 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1376 if (p
.prefixlen
== 30) {
1377 peer
->su
.sa
.sa_family
= AF_INET
;
1378 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1380 peer
->su
.sin
.sin_addr
.s_addr
=
1382 else if (addr
% 4 == 2)
1383 peer
->su
.sin
.sin_addr
.s_addr
=
1385 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1386 peer
->su
.sin
.sin_len
=
1387 sizeof(struct sockaddr_in
);
1388 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1390 } else if (p
.prefixlen
== 31) {
1391 peer
->su
.sa
.sa_family
= AF_INET
;
1392 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1394 peer
->su
.sin
.sin_addr
.s_addr
=
1397 peer
->su
.sin
.sin_addr
.s_addr
=
1399 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1400 peer
->su
.sin
.sin_len
=
1401 sizeof(struct sockaddr_in
);
1402 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1404 } else if (bgp_debug_neighbor_events(peer
))
1406 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1414 static bool bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1415 struct interface
*ifp
)
1417 struct nbr_connected
*ifc_nbr
;
1419 /* Have we learnt the peer's IPv6 link-local address? */
1420 if (ifp
->nbr_connected
1421 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1422 peer
->su
.sa
.sa_family
= AF_INET6
;
1423 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1424 sizeof(struct in6_addr
));
1426 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1428 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1436 * Set or reset the peer address socketunion structure based on the
1437 * learnt/derived peer address. If the address has changed, update the
1438 * password on the listen socket, if needed.
1440 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1442 struct interface
*ifp
;
1444 int peer_addr_updated
= 0;
1450 * Our peer structure is stored in the bgp->peerhash
1451 * release it before we modify anything.
1453 hash_release(peer
->bgp
->peerhash
, peer
);
1455 prev_family
= peer
->su
.sa
.sa_family
;
1456 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1458 /* If BGP unnumbered is not "v6only", we first see if we can
1460 * peer's IPv4 address.
1462 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1464 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1466 /* If "v6only" or we can't derive peer's IPv4 address, see if
1468 * learnt the peer's IPv6 link-local address. This is from the
1470 * IPv6 address in router advertisement.
1472 if (!peer_addr_updated
)
1474 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1476 /* If we could derive the peer address, we may need to install the
1478 * configured for the peer, if any, on the listen socket. Otherwise,
1480 * that peer's address is not available and uninstall the password, if
1483 if (peer_addr_updated
) {
1484 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1485 && prev_family
== AF_UNSPEC
)
1488 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)
1489 && prev_family
!= AF_UNSPEC
)
1490 bgp_md5_unset(peer
);
1491 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1492 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1496 * Since our su changed we need to del/add peer to the peerhash
1498 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1501 static void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
,
1504 struct bgp_dest
*dest
, *ndest
;
1505 struct bgp_table
*table
;
1507 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
1508 dest
= bgp_route_next(dest
)) {
1509 table
= bgp_dest_get_bgp_table_info(dest
);
1510 if (table
!= NULL
) {
1511 /* Special handling for 2-level routing
1513 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1514 || safi
== SAFI_EVPN
) {
1515 for (ndest
= bgp_table_top(table
); ndest
;
1516 ndest
= bgp_route_next(ndest
))
1517 bgp_process(bgp
, ndest
, afi
, safi
);
1519 bgp_process(bgp
, dest
, afi
, safi
);
1524 /* Force a bestpath recalculation for all prefixes. This is used
1525 * when 'bgp bestpath' commands are entered.
1527 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1532 FOREACH_AFI_SAFI (afi
, safi
) {
1533 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1538 * Create new BGP peer.
1540 * conf_if and su are mutually exclusive if configuring from the cli.
1541 * If we are handing a doppelganger, then we *must* pass in both
1542 * the original peer's su and conf_if, so that we can appropriately
1543 * track the bgp->peerhash( ie we don't want to remove the current
1544 * one from the config ).
1546 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1547 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1548 int as_type
, afi_t afi
, safi_t safi
,
1549 struct peer_group
*group
)
1553 char buf
[SU_ADDRSTRLEN
];
1555 peer
= peer_new(bgp
);
1557 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1561 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
);
1567 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1568 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1570 peer
->local_as
= local_as
;
1571 peer
->as
= remote_as
;
1572 peer
->as_type
= as_type
;
1573 peer
->local_id
= bgp
->router_id
;
1574 peer
->v_holdtime
= bgp
->default_holdtime
;
1575 peer
->v_keepalive
= bgp
->default_keepalive
;
1576 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
1577 ? BGP_DEFAULT_IBGP_ROUTEADV
1578 : BGP_DEFAULT_EBGP_ROUTEADV
;
1580 peer
= peer_lock(peer
); /* bgp peer list reference */
1581 peer
->group
= group
;
1582 listnode_add_sort(bgp
->peer
, peer
);
1583 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1585 /* Adjust update-group coalesce timer heuristics for # peers. */
1586 if (bgp
->heuristic_coalesce
) {
1587 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1589 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1590 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1593 active
= peer_active(peer
);
1595 if (peer
->su
.sa
.sa_family
== AF_UNSPEC
)
1596 peer
->last_reset
= PEER_DOWN_NBR_ADDR
;
1598 peer
->last_reset
= PEER_DOWN_NOAFI_ACTIVATED
;
1601 /* Last read and reset time set */
1602 peer
->readtime
= peer
->resettime
= bgp_clock();
1604 /* Default TTL set. */
1605 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: BGP_DEFAULT_TTL
;
1607 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1610 peer
->afc
[afi
][safi
] = 1;
1611 peer_af_create(peer
, afi
, safi
);
1614 /* auto shutdown if configured */
1615 if (bgp
->autoshutdown
)
1616 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1617 /* Set up peer's events and timers. */
1618 else if (!active
&& peer_active(peer
))
1619 bgp_timer_set(peer
);
1621 bgp_peer_gr_flags_update(peer
);
1622 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp
, bgp
->peer
);
1627 /* Make accept BGP peer. This function is only called from the test code */
1628 struct peer
*peer_create_accept(struct bgp
*bgp
)
1632 peer
= peer_new(bgp
);
1634 peer
= peer_lock(peer
); /* bgp peer list reference */
1635 listnode_add_sort(bgp
->peer
, peer
);
1641 * Return true if we have a peer configured to use this afi/safi
1643 int bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1645 struct listnode
*node
;
1648 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1649 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1652 if (peer
->afc
[afi
][safi
])
1659 /* Change peer's AS number. */
1660 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
)
1662 bgp_peer_sort_t origtype
, newtype
;
1665 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1666 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1667 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1668 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1669 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1671 bgp_session_reset(peer
);
1673 origtype
= peer_sort_lookup(peer
);
1675 peer
->as_type
= as_specified
;
1677 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1678 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1679 && peer
->bgp
->as
!= as
)
1680 peer
->local_as
= peer
->bgp
->confed_id
;
1682 peer
->local_as
= peer
->bgp
->as
;
1684 newtype
= peer_sort(peer
);
1685 /* Advertisement-interval reset */
1686 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_ROUTEADV
)) {
1687 peer
->v_routeadv
= (newtype
== BGP_PEER_IBGP
)
1688 ? BGP_DEFAULT_IBGP_ROUTEADV
1689 : BGP_DEFAULT_EBGP_ROUTEADV
;
1693 if (newtype
== BGP_PEER_IBGP
)
1695 else if (origtype
== BGP_PEER_IBGP
)
1696 peer
->ttl
= BGP_DEFAULT_TTL
;
1698 /* reflector-client reset */
1699 if (newtype
!= BGP_PEER_IBGP
) {
1700 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1701 PEER_FLAG_REFLECTOR_CLIENT
);
1702 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1703 PEER_FLAG_REFLECTOR_CLIENT
);
1704 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1705 PEER_FLAG_REFLECTOR_CLIENT
);
1706 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1707 PEER_FLAG_REFLECTOR_CLIENT
);
1708 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1709 PEER_FLAG_REFLECTOR_CLIENT
);
1710 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_FLOWSPEC
],
1711 PEER_FLAG_REFLECTOR_CLIENT
);
1712 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1713 PEER_FLAG_REFLECTOR_CLIENT
);
1714 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1715 PEER_FLAG_REFLECTOR_CLIENT
);
1716 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1717 PEER_FLAG_REFLECTOR_CLIENT
);
1718 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1719 PEER_FLAG_REFLECTOR_CLIENT
);
1720 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1721 PEER_FLAG_REFLECTOR_CLIENT
);
1722 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_FLOWSPEC
],
1723 PEER_FLAG_REFLECTOR_CLIENT
);
1724 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1725 PEER_FLAG_REFLECTOR_CLIENT
);
1728 /* local-as reset */
1729 if (newtype
!= BGP_PEER_EBGP
) {
1730 peer
->change_local_as
= 0;
1731 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
1732 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1733 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1737 /* If peer does not exist, create new one. If peer already exists,
1738 set AS number to the peer. */
1739 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1740 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1746 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1748 peer
= peer_lookup(bgp
, su
);
1751 /* Not allowed for a dynamic peer. */
1752 if (peer_dynamic_neighbor(peer
)) {
1754 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1757 /* When this peer is a member of peer-group. */
1759 /* peer-group already has AS number/internal/external */
1760 if (peer
->group
->conf
->as
1761 || peer
->group
->conf
->as_type
) {
1762 /* Return peer group's AS number. */
1763 *as
= peer
->group
->conf
->as
;
1764 return BGP_ERR_PEER_GROUP_MEMBER
;
1767 bgp_peer_sort_t peer_sort_type
=
1768 peer_sort(peer
->group
->conf
);
1770 /* Explicit AS numbers used, compare AS numbers */
1771 if (as_type
== AS_SPECIFIED
) {
1772 if (((peer_sort_type
== BGP_PEER_IBGP
)
1773 && (bgp
->as
!= *as
))
1774 || ((peer_sort_type
== BGP_PEER_EBGP
)
1775 && (bgp
->as
== *as
))) {
1777 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1780 /* internal/external used, compare as-types */
1781 if (((peer_sort_type
== BGP_PEER_IBGP
)
1782 && (as_type
!= AS_INTERNAL
))
1783 || ((peer_sort_type
== BGP_PEER_EBGP
)
1784 && (as_type
!= AS_EXTERNAL
))) {
1786 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1791 /* Existing peer's AS number change. */
1792 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
1793 || (peer
->as_type
!= as_type
))
1794 peer_as_change(peer
, *as
, as_type
);
1797 return BGP_ERR_NO_INTERFACE_CONFIG
;
1799 /* If the peer is not part of our confederation, and its not an
1800 iBGP peer then spoof the source AS */
1801 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)
1802 && !bgp_confederation_peers_check(bgp
, *as
)
1804 local_as
= bgp
->confed_id
;
1808 /* If this is IPv4 unicast configuration and "no bgp default
1809 ipv4-unicast" is specified. */
1811 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_DEFAULT_IPV4
)
1812 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1813 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0,
1816 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
,
1823 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
1824 struct peer
*peer
, afi_t afi
,
1828 int out
= FILTER_OUT
;
1830 uint32_t pflags_ovrd
;
1831 uint8_t *pfilter_ovrd
;
1835 pflags_ovrd
= peer
->af_flags_override
[afi
][safi
];
1836 pfilter_ovrd
= &peer
->filter_override
[afi
][safi
][in
];
1838 /* peer af_flags apply */
1839 flags_tmp
= conf
->af_flags
[afi
][safi
] & ~pflags_ovrd
;
1840 flags_tmp
^= conf
->af_flags_invert
[afi
][safi
]
1841 ^ peer
->af_flags_invert
[afi
][safi
];
1842 flags_tmp
&= ~pflags_ovrd
;
1844 UNSET_FLAG(peer
->af_flags
[afi
][safi
], ~pflags_ovrd
);
1845 SET_FLAG(peer
->af_flags
[afi
][safi
], flags_tmp
);
1846 SET_FLAG(peer
->af_flags_invert
[afi
][safi
],
1847 conf
->af_flags_invert
[afi
][safi
]);
1849 /* maximum-prefix */
1850 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_MAX_PREFIX
)) {
1851 PEER_ATTR_INHERIT(peer
, group
, pmax
[afi
][safi
]);
1852 PEER_ATTR_INHERIT(peer
, group
, pmax_threshold
[afi
][safi
]);
1853 PEER_ATTR_INHERIT(peer
, group
, pmax_restart
[afi
][safi
]);
1857 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_ALLOWAS_IN
))
1858 PEER_ATTR_INHERIT(peer
, group
, allowas_in
[afi
][safi
]);
1861 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_WEIGHT
))
1862 PEER_ATTR_INHERIT(peer
, group
, weight
[afi
][safi
]);
1864 /* default-originate route-map */
1865 if (!CHECK_FLAG(pflags_ovrd
, PEER_FLAG_DEFAULT_ORIGINATE
)) {
1866 PEER_STR_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].name
,
1867 MTYPE_ROUTE_MAP_NAME
);
1868 PEER_ATTR_INHERIT(peer
, group
, default_rmap
[afi
][safi
].map
);
1871 /* inbound filter apply */
1872 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_DISTRIBUTE_LIST
)) {
1873 PEER_STR_ATTR_INHERIT(peer
, group
,
1874 filter
[afi
][safi
].dlist
[in
].name
,
1875 MTYPE_BGP_FILTER_NAME
);
1876 PEER_ATTR_INHERIT(peer
, group
,
1877 filter
[afi
][safi
].dlist
[in
].alist
);
1880 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_PREFIX_LIST
)) {
1881 PEER_STR_ATTR_INHERIT(peer
, group
,
1882 filter
[afi
][safi
].plist
[in
].name
,
1883 MTYPE_BGP_FILTER_NAME
);
1884 PEER_ATTR_INHERIT(peer
, group
,
1885 filter
[afi
][safi
].plist
[in
].plist
);
1888 if (!CHECK_FLAG(pfilter_ovrd
[in
], PEER_FT_FILTER_LIST
)) {
1889 PEER_STR_ATTR_INHERIT(peer
, group
,
1890 filter
[afi
][safi
].aslist
[in
].name
,
1891 MTYPE_BGP_FILTER_NAME
);
1892 PEER_ATTR_INHERIT(peer
, group
,
1893 filter
[afi
][safi
].aslist
[in
].aslist
);
1896 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_IN
], PEER_FT_ROUTE_MAP
)) {
1897 PEER_STR_ATTR_INHERIT(peer
, group
,
1898 filter
[afi
][safi
].map
[in
].name
,
1899 MTYPE_BGP_FILTER_NAME
);
1900 PEER_ATTR_INHERIT(peer
, group
,
1901 filter
[afi
][safi
].map
[RMAP_IN
].map
);
1904 /* outbound filter apply */
1905 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_DISTRIBUTE_LIST
)) {
1906 PEER_STR_ATTR_INHERIT(peer
, group
,
1907 filter
[afi
][safi
].dlist
[out
].name
,
1908 MTYPE_BGP_FILTER_NAME
);
1909 PEER_ATTR_INHERIT(peer
, group
,
1910 filter
[afi
][safi
].dlist
[out
].alist
);
1913 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_PREFIX_LIST
)) {
1914 PEER_STR_ATTR_INHERIT(peer
, group
,
1915 filter
[afi
][safi
].plist
[out
].name
,
1916 MTYPE_BGP_FILTER_NAME
);
1917 PEER_ATTR_INHERIT(peer
, group
,
1918 filter
[afi
][safi
].plist
[out
].plist
);
1921 if (!CHECK_FLAG(pfilter_ovrd
[out
], PEER_FT_FILTER_LIST
)) {
1922 PEER_STR_ATTR_INHERIT(peer
, group
,
1923 filter
[afi
][safi
].aslist
[out
].name
,
1924 MTYPE_BGP_FILTER_NAME
);
1925 PEER_ATTR_INHERIT(peer
, group
,
1926 filter
[afi
][safi
].aslist
[out
].aslist
);
1929 if (!CHECK_FLAG(pfilter_ovrd
[RMAP_OUT
], PEER_FT_ROUTE_MAP
)) {
1930 PEER_STR_ATTR_INHERIT(peer
, group
,
1931 filter
[afi
][safi
].map
[RMAP_OUT
].name
,
1932 MTYPE_BGP_FILTER_NAME
);
1933 PEER_ATTR_INHERIT(peer
, group
,
1934 filter
[afi
][safi
].map
[RMAP_OUT
].map
);
1937 /* nondirectional filter apply */
1938 if (!CHECK_FLAG(pfilter_ovrd
[0], PEER_FT_UNSUPPRESS_MAP
)) {
1939 PEER_STR_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.name
,
1940 MTYPE_BGP_FILTER_NAME
);
1941 PEER_ATTR_INHERIT(peer
, group
, filter
[afi
][safi
].usmap
.map
);
1944 if (peer
->addpath_type
[afi
][safi
] == BGP_ADDPATH_NONE
) {
1945 peer
->addpath_type
[afi
][safi
] = conf
->addpath_type
[afi
][safi
];
1946 bgp_addpath_type_changed(conf
->bgp
);
1950 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
1955 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1956 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
1957 __func__
, peer
->host
);
1961 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
1963 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1964 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1965 return BGP_ERR_PEER_SAFI_CONFLICT
;
1967 /* Nothing to do if we've already activated this peer */
1968 if (peer
->afc
[afi
][safi
])
1971 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1974 active
= peer_active(peer
);
1975 peer
->afc
[afi
][safi
] = 1;
1978 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
1980 if (!active
&& peer_active(peer
)) {
1981 bgp_timer_set(peer
);
1983 if (peer
->status
== Established
) {
1984 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
1985 peer
->afc_adv
[afi
][safi
] = 1;
1986 bgp_capability_send(peer
, afi
, safi
,
1988 CAPABILITY_ACTION_SET
);
1989 if (peer
->afc_recv
[afi
][safi
]) {
1990 peer
->afc_nego
[afi
][safi
] = 1;
1991 bgp_announce_route(peer
, afi
, safi
);
1994 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1995 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1996 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1999 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
2000 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2001 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2002 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2005 * If we are turning on a AFI/SAFI locally and we've
2006 * started bringing a peer up, we need to tell
2007 * the other peer to restart because we might loose
2008 * configuration here because when the doppelganger
2009 * gets to a established state due to how
2010 * we resolve we could just overwrite the afi/safi
2013 other
= peer
->doppelganger
;
2015 && (other
->status
== OpenSent
2016 || other
->status
== OpenConfirm
)) {
2017 other
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
2018 bgp_notify_send(other
, BGP_NOTIFY_CEASE
,
2019 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2026 /* Activate the peer or peer group for specified AFI and SAFI. */
2027 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2030 struct peer_group
*group
;
2031 struct listnode
*node
, *nnode
;
2032 struct peer
*tmp_peer
;
2035 /* Nothing to do if we've already activated this peer */
2036 if (peer
->afc
[afi
][safi
])
2041 /* This is a peer-group so activate all of the members of the
2042 * peer-group as well */
2043 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2045 /* Do not activate a peer for both SAFI_UNICAST and
2046 * SAFI_LABELED_UNICAST */
2047 if ((safi
== SAFI_UNICAST
2048 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
2049 || (safi
== SAFI_LABELED_UNICAST
2050 && peer
->afc
[afi
][SAFI_UNICAST
]))
2051 return BGP_ERR_PEER_SAFI_CONFLICT
;
2053 peer
->afc
[afi
][safi
] = 1;
2054 group
= peer
->group
;
2056 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2057 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
2060 ret
|= peer_activate_af(peer
, afi
, safi
);
2063 /* If this is the first peer to be activated for this
2064 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2065 if (safi
== SAFI_LABELED_UNICAST
2066 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
2068 if (BGP_DEBUG(zebra
, ZEBRA
))
2070 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2072 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
2073 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2076 if (safi
== SAFI_FLOWSPEC
) {
2077 /* connect to table manager */
2078 bgp_zebra_init_tm_connect(bgp
);
2083 static bool non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
2086 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2087 flog_err(EC_BGP_PEER_GROUP
, "%s was called for peer-group %s",
2088 __func__
, peer
->host
);
2092 /* Nothing to do if we've already deactivated this peer */
2093 if (!peer
->afc
[afi
][safi
])
2096 /* De-activate the address family configuration. */
2097 peer
->afc
[afi
][safi
] = 0;
2099 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2100 flog_err(EC_BGP_PEER_DELETE
,
2101 "couldn't delete af structure for peer %s(%s, %s)",
2102 peer
->host
, afi2str(afi
), safi2str(safi
));
2106 if (peer
->status
== Established
) {
2107 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2108 peer
->afc_adv
[afi
][safi
] = 0;
2109 peer
->afc_nego
[afi
][safi
] = 0;
2111 if (peer_active_nego(peer
)) {
2112 bgp_capability_send(peer
, afi
, safi
,
2114 CAPABILITY_ACTION_UNSET
);
2115 bgp_clear_route(peer
, afi
, safi
);
2116 peer
->pcount
[afi
][safi
] = 0;
2118 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2119 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2120 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2123 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2124 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2125 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2132 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2135 struct peer_group
*group
;
2136 struct peer
*tmp_peer
;
2137 struct listnode
*node
, *nnode
;
2140 /* Nothing to do if we've already de-activated this peer */
2141 if (!peer
->afc
[afi
][safi
])
2144 /* This is a peer-group so de-activate all of the members of the
2145 * peer-group as well */
2146 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2147 peer
->afc
[afi
][safi
] = 0;
2148 group
= peer
->group
;
2150 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2153 "couldn't delete af structure for peer %s(%s, %s)",
2154 peer
->host
, afi2str(afi
), safi2str(safi
));
2157 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2158 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2161 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2166 /* If this is the last peer to be deactivated for this
2167 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2168 if (safi
== SAFI_LABELED_UNICAST
2169 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2170 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2172 if (BGP_DEBUG(zebra
, ZEBRA
))
2174 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2176 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2177 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2182 void peer_nsf_stop(struct peer
*peer
)
2187 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2188 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2190 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2191 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
2192 peer
->nsf
[afi
][safi
] = 0;
2194 if (peer
->t_gr_restart
) {
2195 BGP_TIMER_OFF(peer
->t_gr_restart
);
2196 if (bgp_debug_neighbor_events(peer
))
2197 zlog_debug("%s graceful restart timer stopped",
2200 if (peer
->t_gr_stale
) {
2201 BGP_TIMER_OFF(peer
->t_gr_stale
);
2202 if (bgp_debug_neighbor_events(peer
))
2204 "%s graceful restart stalepath timer stopped",
2207 bgp_clear_route_all(peer
);
2210 /* Delete peer from confguration.
2212 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2213 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2215 * This function /should/ take care to be idempotent, to guard against
2216 * it being called multiple times through stray events that come in
2217 * that happen to result in this function being called again. That
2218 * said, getting here for a "Deleted" peer is a bug in the neighbour
2221 int peer_delete(struct peer
*peer
)
2227 struct bgp_filter
*filter
;
2228 struct listnode
*pn
;
2231 assert(peer
->status
!= Deleted
);
2234 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2236 bgp_keepalives_off(peer
);
2237 bgp_reads_off(peer
);
2238 bgp_writes_off(peer
);
2239 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2240 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2241 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_KEEPALIVES_ON
));
2243 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2244 peer_nsf_stop(peer
);
2246 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2248 bgp_bfd_deregister_peer(peer
);
2250 /* If this peer belongs to peer group, clear up the
2253 if (peer_dynamic_neighbor(peer
))
2254 peer_drop_dynamic_neighbor(peer
);
2256 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2258 peer
); /* group->peer list reference */
2259 list_delete_node(peer
->group
->peer
, pn
);
2264 /* Withdraw all information from routing table. We can not use
2265 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2266 * executed after peer structure is deleted.
2268 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2270 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2272 if (peer
->doppelganger
) {
2273 peer
->doppelganger
->doppelganger
= NULL
;
2274 peer
->doppelganger
= NULL
;
2277 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2278 bgp_fsm_change_status(peer
, Deleted
);
2280 /* Remove from NHT */
2281 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2282 bgp_unlink_nexthop_by_peer(peer
);
2284 /* Password configuration */
2285 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
)) {
2286 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2288 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2289 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
2290 bgp_md5_unset(peer
);
2293 bgp_timer_set(peer
); /* stops all timers for Deleted */
2295 /* Delete from all peer list. */
2296 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2297 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2298 peer_unlock(peer
); /* bgp peer list reference */
2299 list_delete_node(bgp
->peer
, pn
);
2300 hash_release(bgp
->peerhash
, peer
);
2305 stream_fifo_free(peer
->ibuf
);
2310 stream_fifo_free(peer
->obuf
);
2314 if (peer
->ibuf_work
) {
2315 ringbuf_del(peer
->ibuf_work
);
2316 peer
->ibuf_work
= NULL
;
2319 if (peer
->obuf_work
) {
2320 stream_free(peer
->obuf_work
);
2321 peer
->obuf_work
= NULL
;
2324 if (peer
->scratch
) {
2325 stream_free(peer
->scratch
);
2326 peer
->scratch
= NULL
;
2329 /* Local and remote addresses. */
2330 if (peer
->su_local
) {
2331 sockunion_free(peer
->su_local
);
2332 peer
->su_local
= NULL
;
2335 if (peer
->su_remote
) {
2336 sockunion_free(peer
->su_remote
);
2337 peer
->su_remote
= NULL
;
2340 /* Free filter related memory. */
2341 FOREACH_AFI_SAFI (afi
, safi
) {
2342 filter
= &peer
->filter
[afi
][safi
];
2344 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2345 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2346 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2347 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2350 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2351 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2354 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2355 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2358 FOREACH_AFI_SAFI (afi
, safi
)
2359 peer_af_delete(peer
, afi
, safi
);
2361 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2362 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2364 peer_unlock(peer
); /* initial reference */
2369 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2371 return strcmp(g1
->name
, g2
->name
);
2374 /* Peer group cofiguration. */
2375 static struct peer_group
*peer_group_new(void)
2377 return XCALLOC(MTYPE_PEER_GROUP
, sizeof(struct peer_group
));
2380 static void peer_group_free(struct peer_group
*group
)
2382 XFREE(MTYPE_PEER_GROUP
, group
);
2385 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2387 struct peer_group
*group
;
2388 struct listnode
*node
, *nnode
;
2390 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2391 if (strcmp(group
->name
, name
) == 0)
2397 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2399 struct peer_group
*group
;
2402 group
= peer_group_lookup(bgp
, name
);
2406 group
= peer_group_new();
2408 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2409 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2410 group
->peer
= list_new();
2411 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2412 group
->listen_range
[afi
] = list_new();
2413 group
->conf
= peer_new(bgp
);
2414 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_DEFAULT_IPV4
))
2415 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2416 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2417 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2418 group
->conf
->group
= group
;
2419 group
->conf
->as
= 0;
2420 group
->conf
->ttl
= BGP_DEFAULT_TTL
;
2421 group
->conf
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
2422 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2423 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2424 listnode_add_sort(bgp
->group
, group
);
2429 static void peer_group2peer_config_copy(struct peer_group
*group
,
2439 peer
->as
= conf
->as
;
2442 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_LOCAL_AS
))
2443 peer
->change_local_as
= conf
->change_local_as
;
2445 /* If peer-group has configured TTL then override it */
2446 if (conf
->ttl
!= BGP_DEFAULT_TTL
)
2447 peer
->ttl
= conf
->ttl
;
2450 peer
->gtsm_hops
= conf
->gtsm_hops
;
2452 /* peer flags apply */
2453 flags_tmp
= conf
->flags
& ~peer
->flags_override
;
2454 flags_tmp
^= conf
->flags_invert
^ peer
->flags_invert
;
2455 flags_tmp
&= ~peer
->flags_override
;
2457 UNSET_FLAG(peer
->flags
, ~peer
->flags_override
);
2458 SET_FLAG(peer
->flags
, flags_tmp
);
2459 SET_FLAG(peer
->flags_invert
, conf
->flags_invert
);
2461 /* peer timers apply */
2462 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER
)) {
2463 PEER_ATTR_INHERIT(peer
, group
, holdtime
);
2464 PEER_ATTR_INHERIT(peer
, group
, keepalive
);
2467 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_TIMER_CONNECT
)) {
2468 PEER_ATTR_INHERIT(peer
, group
, connect
);
2469 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_TIMER_CONNECT
))
2470 peer
->v_connect
= conf
->connect
;
2472 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
2475 /* advertisement-interval apply */
2476 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_ROUTEADV
)) {
2477 PEER_ATTR_INHERIT(peer
, group
, routeadv
);
2478 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_ROUTEADV
))
2479 peer
->v_routeadv
= conf
->routeadv
;
2481 peer
->v_routeadv
= (peer_sort(peer
) == BGP_PEER_IBGP
)
2482 ? BGP_DEFAULT_IBGP_ROUTEADV
2483 : BGP_DEFAULT_EBGP_ROUTEADV
;
2486 /* capability extended-nexthop apply */
2487 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_CAPABILITY_ENHE
))
2488 if (CHECK_FLAG(conf
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2489 SET_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
);
2491 /* password apply */
2492 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_PASSWORD
))
2493 PEER_STR_ATTR_INHERIT(peer
, group
, password
,
2494 MTYPE_PEER_PASSWORD
);
2496 if (!BGP_PEER_SU_UNSPEC(peer
))
2499 /* update-source apply */
2500 if (!CHECK_FLAG(peer
->flags_override
, PEER_FLAG_UPDATE_SOURCE
)) {
2501 if (conf
->update_source
) {
2502 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2503 PEER_SU_ATTR_INHERIT(peer
, group
, update_source
);
2504 } else if (conf
->update_if
) {
2505 sockunion_free(peer
->update_source
);
2506 PEER_STR_ATTR_INHERIT(peer
, group
, update_if
,
2507 MTYPE_PEER_UPDATE_SOURCE
);
2511 /* Update GR flags for the peer. */
2512 bgp_peer_gr_flags_update(peer
);
2514 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2517 /* Peer group's remote AS configuration. */
2518 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2521 struct peer_group
*group
;
2523 struct listnode
*node
, *nnode
;
2525 group
= peer_group_lookup(bgp
, group_name
);
2529 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2533 /* When we setup peer-group AS number all peer group member's AS
2534 number must be updated to same number. */
2535 peer_as_change(group
->conf
, *as
, as_type
);
2537 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2538 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2539 || (peer
->as_type
!= as_type
))
2540 peer_as_change(peer
, *as
, as_type
);
2546 void peer_notify_unconfig(struct peer
*peer
)
2548 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2549 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2550 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
2553 void peer_group_notify_unconfig(struct peer_group
*group
)
2555 struct peer
*peer
, *other
;
2556 struct listnode
*node
, *nnode
;
2558 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2559 other
= peer
->doppelganger
;
2560 if (other
&& other
->status
!= Deleted
) {
2561 other
->group
= NULL
;
2562 peer_notify_unconfig(other
);
2564 peer_notify_unconfig(peer
);
2568 int peer_group_delete(struct peer_group
*group
)
2572 struct prefix
*prefix
;
2574 struct listnode
*node
, *nnode
;
2579 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2580 other
= peer
->doppelganger
;
2582 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2583 bgp_zebra_terminate_radv(bgp
, peer
);
2586 if (other
&& other
->status
!= Deleted
) {
2587 other
->group
= NULL
;
2591 list_delete(&group
->peer
);
2593 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2594 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2596 prefix_free(&prefix
);
2598 list_delete(&group
->listen_range
[afi
]);
2601 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2604 bfd_info_free(&(group
->conf
->bfd_info
));
2606 group
->conf
->group
= NULL
;
2607 peer_delete(group
->conf
);
2609 /* Delete from all peer_group list. */
2610 listnode_delete(bgp
->group
, group
);
2612 peer_group_free(group
);
2617 int peer_group_remote_as_delete(struct peer_group
*group
)
2619 struct peer
*peer
, *other
;
2620 struct listnode
*node
, *nnode
;
2622 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2623 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2626 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2627 other
= peer
->doppelganger
;
2629 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2630 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
2634 if (other
&& other
->status
!= Deleted
) {
2635 other
->group
= NULL
;
2639 list_delete_all_node(group
->peer
);
2641 group
->conf
->as
= 0;
2642 group
->conf
->as_type
= AS_UNSPECIFIED
;
2647 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2649 struct prefix
*prefix
;
2650 struct listnode
*node
, *nnode
;
2653 afi
= family2afi(range
->family
);
2655 /* Group needs remote AS configured. */
2656 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2657 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2659 /* Ensure no duplicates. Currently we don't care about overlaps. */
2660 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2661 if (prefix_same(range
, prefix
))
2665 prefix
= prefix_new();
2666 prefix_copy(prefix
, range
);
2667 listnode_add(group
->listen_range
[afi
], prefix
);
2669 /* Update passwords for new ranges */
2670 if (group
->conf
->password
)
2671 bgp_md5_set_prefix(prefix
, group
->conf
->password
);
2676 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
2678 struct prefix
*prefix
, prefix2
;
2679 struct listnode
*node
, *nnode
;
2682 char buf
[PREFIX2STR_BUFFER
];
2684 afi
= family2afi(range
->family
);
2686 /* Identify the listen range. */
2687 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2688 if (prefix_same(range
, prefix
))
2693 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2695 prefix2str(prefix
, buf
, sizeof(buf
));
2697 /* Dispose off any dynamic neighbors that exist due to this listen range
2699 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2700 if (!peer_dynamic_neighbor(peer
))
2703 sockunion2hostprefix(&peer
->su
, &prefix2
);
2704 if (prefix_match(prefix
, &prefix2
)) {
2705 if (bgp_debug_neighbor_events(peer
))
2707 "Deleting dynamic neighbor %s group %s upon delete of listen range %s",
2708 peer
->host
, group
->name
, buf
);
2713 /* Get rid of the listen range */
2714 listnode_delete(group
->listen_range
[afi
], prefix
);
2716 /* Remove passwords for deleted ranges */
2717 if (group
->conf
->password
)
2718 bgp_md5_unset_prefix(prefix
);
2723 /* Bind specified peer to peer group. */
2724 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2725 struct peer_group
*group
, as_t
*as
)
2727 int first_member
= 0;
2730 bgp_peer_sort_t ptype
, gtype
;
2732 /* Lookup the peer. */
2734 peer
= peer_lookup(bgp
, su
);
2736 /* The peer exist, bind it to the peer-group */
2738 /* When the peer already belongs to a peer-group, check the
2740 if (peer_group_active(peer
)) {
2742 /* The peer is already bound to the peer-group,
2745 if (strcmp(peer
->group
->name
, group
->name
) == 0)
2748 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2751 /* The peer has not specified a remote-as, inherit it from the
2753 if (peer
->as_type
== AS_UNSPECIFIED
) {
2754 peer
->as_type
= group
->conf
->as_type
;
2755 peer
->as
= group
->conf
->as
;
2756 peer
->sort
= group
->conf
->sort
;
2759 ptype
= peer_sort(peer
);
2760 if (!group
->conf
->as
&& ptype
!= BGP_PEER_UNSPECIFIED
) {
2761 gtype
= peer_sort(group
->conf
);
2762 if ((gtype
!= BGP_PEER_INTERNAL
) && (gtype
!= ptype
)) {
2765 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2768 if (gtype
== BGP_PEER_INTERNAL
)
2772 peer_group2peer_config_copy(group
, peer
);
2774 FOREACH_AFI_SAFI (afi
, safi
) {
2775 if (group
->conf
->afc
[afi
][safi
]) {
2776 peer
->afc
[afi
][safi
] = 1;
2778 if (peer_af_find(peer
, afi
, safi
)
2779 || peer_af_create(peer
, afi
, safi
)) {
2780 peer_group2peer_config_copy_af(
2781 group
, peer
, afi
, safi
);
2783 } else if (peer
->afc
[afi
][safi
])
2784 peer_deactivate(peer
, afi
, safi
);
2788 assert(group
&& peer
->group
== group
);
2790 listnode_delete(bgp
->peer
, peer
);
2792 peer
->group
= group
;
2793 listnode_add_sort(bgp
->peer
, peer
);
2795 peer
= peer_lock(peer
); /* group->peer list reference */
2796 listnode_add(group
->peer
, peer
);
2800 gtype
= peer_sort(group
->conf
);
2801 /* Advertisement-interval reset */
2802 if (!CHECK_FLAG(group
->conf
->flags
,
2803 PEER_FLAG_ROUTEADV
)) {
2804 group
->conf
->v_routeadv
=
2805 (gtype
== BGP_PEER_IBGP
)
2806 ? BGP_DEFAULT_IBGP_ROUTEADV
2807 : BGP_DEFAULT_EBGP_ROUTEADV
;
2810 /* ebgp-multihop reset */
2811 if (gtype
== BGP_PEER_IBGP
)
2812 group
->conf
->ttl
= MAXTTL
;
2814 /* local-as reset */
2815 if (gtype
!= BGP_PEER_EBGP
) {
2816 group
->conf
->change_local_as
= 0;
2817 peer_flag_unset(group
->conf
,
2818 PEER_FLAG_LOCAL_AS
);
2819 peer_flag_unset(group
->conf
,
2820 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2821 peer_flag_unset(group
->conf
,
2822 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2826 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2828 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2829 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2830 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2831 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2833 bgp_session_reset(peer
);
2837 /* Create a new peer. */
2839 if ((group
->conf
->as_type
== AS_SPECIFIED
)
2840 && (!group
->conf
->as
)) {
2841 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2844 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
2845 group
->conf
->as_type
, 0, 0, group
);
2847 peer
= peer_lock(peer
); /* group->peer list reference */
2848 listnode_add(group
->peer
, peer
);
2850 peer_group2peer_config_copy(group
, peer
);
2852 /* If the peer-group is active for this afi/safi then activate
2854 FOREACH_AFI_SAFI (afi
, safi
) {
2855 if (group
->conf
->afc
[afi
][safi
]) {
2856 peer
->afc
[afi
][safi
] = 1;
2857 peer_af_create(peer
, afi
, safi
);
2858 peer_group2peer_config_copy_af(group
, peer
, afi
,
2860 } else if (peer
->afc
[afi
][safi
])
2861 peer_deactivate(peer
, afi
, safi
);
2864 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2866 /* Set up peer's events and timers. */
2867 if (peer_active(peer
))
2868 bgp_timer_set(peer
);
2874 static int bgp_startup_timer_expire(struct thread
*thread
)
2878 bgp
= THREAD_ARG(thread
);
2879 bgp
->t_startup
= NULL
;
2885 * On shutdown we call the cleanup function which
2886 * does a free of the link list nodes, free up
2887 * the data we are pointing at too.
2889 static void bgp_vrf_string_name_delete(void *data
)
2893 XFREE(MTYPE_TMP
, vname
);
2896 /* BGP instance creation by `router bgp' commands. */
2897 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
2898 enum bgp_instance_type inst_type
)
2904 if ((bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
))) == NULL
)
2907 if (BGP_DEBUG(zebra
, ZEBRA
)) {
2908 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2909 zlog_debug("Creating Default VRF, AS %u", *as
);
2911 zlog_debug("Creating %s %s, AS %u",
2912 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
2918 /* Default the EVPN VRF to the default one */
2919 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
&& !bgp_master
.bgp_evpn
) {
2925 bgp
->heuristic_coalesce
= true;
2926 bgp
->inst_type
= inst_type
;
2927 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
2929 bgp
->peer_self
= peer_new(bgp
);
2930 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2931 bgp
->peer_self
->host
=
2932 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2933 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
2934 if (cmd_hostname_get())
2935 bgp
->peer_self
->hostname
=
2936 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
2938 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
2939 if (cmd_domainname_get())
2940 bgp
->peer_self
->domainname
=
2941 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
2942 bgp
->peer
= list_new();
2943 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
2944 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
2946 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
2948 bgp
->group
= list_new();
2949 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
2951 FOREACH_AFI_SAFI (afi
, safi
) {
2952 bgp
->route
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2953 bgp
->aggregate
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2954 bgp
->rib
[afi
][safi
] = bgp_table_init(bgp
, afi
, safi
);
2956 /* Enable maximum-paths */
2957 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
2959 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
2961 /* Initialize graceful restart info */
2962 bgp
->gr_info
[afi
][safi
].eor_required
= 0;
2963 bgp
->gr_info
[afi
][safi
].eor_received
= 0;
2964 bgp
->gr_info
[afi
][safi
].t_select_deferral
= NULL
;
2965 bgp
->gr_info
[afi
][safi
].t_route_select
= NULL
;
2966 bgp
->gr_info
[afi
][safi
].route_list
= list_new();
2969 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2970 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2971 bgp
->default_subgroup_pkt_queue_max
=
2972 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2973 bgp_timers_unset(bgp
);
2974 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2975 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2976 bgp
->select_defer_time
= BGP_DEFAULT_SELECT_DEFERRAL_TIME
;
2977 bgp
->rib_stale_time
= BGP_DEFAULT_RIB_STALE_TIME
;
2978 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2979 bgp
->dynamic_neighbors_count
= 0;
2980 bgp
->lb_ref_bw
= BGP_LINK_BW_REF_BW
;
2981 bgp
->lb_handling
= BGP_LINK_BW_ECMP
;
2982 bgp
->reject_as_sets
= false;
2983 bgp_addpath_init_bgp_data(&bgp
->tx_addpath
);
2987 #ifdef ENABLE_BGP_VNC
2988 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
2989 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2991 assert(bgp
->rfapi_cfg
);
2993 #endif /* ENABLE_BGP_VNC */
2995 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2996 bgp
->vpn_policy
[afi
].bgp
= bgp
;
2997 bgp
->vpn_policy
[afi
].afi
= afi
;
2998 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
2999 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
3002 bgp
->vpn_policy
[afi
].import_vrf
= list_new();
3003 bgp
->vpn_policy
[afi
].import_vrf
->del
=
3004 bgp_vrf_string_name_delete
;
3005 bgp
->vpn_policy
[afi
].export_vrf
= list_new();
3006 bgp
->vpn_policy
[afi
].export_vrf
->del
=
3007 bgp_vrf_string_name_delete
;
3010 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
3012 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
3013 bgp
->restart_time
, &bgp
->t_startup
);
3015 /* printable name we can use in debug messages */
3016 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) {
3017 bgp
->name_pretty
= XSTRDUP(MTYPE_BGP
, "VRF default");
3027 len
= 4 + 1 + strlen(n
) + 1; /* "view foo\0" */
3029 bgp
->name_pretty
= XCALLOC(MTYPE_BGP
, len
);
3030 snprintf(bgp
->name_pretty
, len
, "%s %s",
3031 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3037 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
3038 memory_order_relaxed
);
3039 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
3040 memory_order_relaxed
);
3041 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3045 update_bgp_group_init(bgp
);
3047 /* assign a unique rd id for auto derivation of vrf's RD */
3048 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3050 bgp
->evpn_info
= XCALLOC(MTYPE_BGP_EVPN_INFO
,
3051 sizeof(struct bgp_evpn_info
));
3056 /*initilize global GR FSM */
3057 bgp_global_gr_init(bgp
);
3061 /* Return the "default VRF" instance of BGP. */
3062 struct bgp
*bgp_get_default(void)
3065 struct listnode
*node
, *nnode
;
3067 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3068 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3073 /* Lookup BGP entry. */
3074 struct bgp
*bgp_lookup(as_t as
, const char *name
)
3077 struct listnode
*node
, *nnode
;
3079 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3081 && ((bgp
->name
== NULL
&& name
== NULL
)
3082 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
3087 /* Lookup BGP structure by view name. */
3088 struct bgp
*bgp_lookup_by_name(const char *name
)
3091 struct listnode
*node
, *nnode
;
3093 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3094 if ((bgp
->name
== NULL
&& name
== NULL
)
3095 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3100 /* Lookup BGP instance based on VRF id. */
3101 /* Note: Only to be used for incoming messages from Zebra. */
3102 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3106 /* Lookup VRF (in tree) and follow link. */
3107 vrf
= vrf_lookup_by_id(vrf_id
);
3110 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3113 /* Sets the BGP instance where EVPN is enabled */
3114 void bgp_set_evpn(struct bgp
*bgp
)
3116 if (bm
->bgp_evpn
== bgp
)
3119 /* First, release the reference count we hold on the instance */
3121 bgp_unlock(bm
->bgp_evpn
);
3125 /* Increase the reference count on this new VRF */
3127 bgp_lock(bm
->bgp_evpn
);
3130 /* Returns the BGP instance where EVPN is enabled, if any */
3131 struct bgp
*bgp_get_evpn(void)
3133 return bm
->bgp_evpn
;
3136 /* handle socket creation or deletion, if necessary
3137 * this is called for all new BGP instances
3139 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3144 /* Create BGP server socket, if listen mode not disabled */
3145 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3147 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3149 * suppress vrf socket
3152 bgp_close_vrf_socket(bgp
);
3156 return BGP_ERR_INVALID_VALUE
;
3158 * if vrf_id did not change
3160 if (vrf
->vrf_id
== old_vrf_id
)
3162 if (old_vrf_id
!= VRF_UNKNOWN
) {
3163 /* look for old socket. close it. */
3164 bgp_close_vrf_socket(bgp
);
3166 /* if backend is not yet identified ( VRF_UNKNOWN) then
3167 * creation will be done later
3169 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3171 ret
= bgp_socket(bgp
, bm
->port
, bm
->address
);
3173 return BGP_ERR_INVALID_VALUE
;
3176 return bgp_check_main_socket(create
, bgp
);
3179 /* Called from VTY commands. */
3180 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3181 enum bgp_instance_type inst_type
)
3184 struct vrf
*vrf
= NULL
;
3186 /* Multiple instance check. */
3188 bgp
= bgp_lookup_by_name(name
);
3190 bgp
= bgp_get_default();
3192 /* Already exists. */
3194 if (bgp
->as
!= *as
) {
3196 return BGP_ERR_INSTANCE_MISMATCH
;
3198 if (bgp
->inst_type
!= inst_type
)
3199 return BGP_ERR_INSTANCE_MISMATCH
;
3204 bgp
= bgp_create(as
, name
, inst_type
);
3205 if (bgp_option_check(BGP_OPT_NO_ZEBRA
) && name
)
3206 bgp
->vrf_id
= vrf_generate_id();
3207 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
, true);
3208 bgp_address_init(bgp
);
3209 bgp_tip_hash_init(bgp
);
3213 bgp
->t_rmap_def_originate_eval
= NULL
;
3215 /* If Default instance or VRF, link to the VRF structure, if present. */
3216 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3217 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3218 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3220 bgp_vrf_link(bgp
, vrf
);
3222 /* BGP server socket already processed if BGP instance
3223 * already part of the list
3225 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3226 listnode_add(bm
->bgp
, bgp
);
3228 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3229 if (BGP_DEBUG(zebra
, ZEBRA
))
3230 zlog_debug("%s: Registering BGP instance %s to zebra",
3232 bgp_zebra_instance_register(bgp
);
3239 * Make BGP instance "up". Applies only to VRFs (non-default) and
3240 * implies the VRF has been learnt from Zebra.
3242 void bgp_instance_up(struct bgp
*bgp
)
3245 struct listnode
*node
, *next
;
3247 /* Register with zebra. */
3248 bgp_zebra_instance_register(bgp
);
3250 /* Kick off any peers that may have been configured. */
3251 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3252 if (!BGP_PEER_START_SUPPRESSED(peer
))
3253 BGP_EVENT_ADD(peer
, BGP_Start
);
3256 /* Process any networks that have been configured. */
3257 bgp_static_add(bgp
);
3261 * Make BGP instance "down". Applies only to VRFs (non-default) and
3262 * implies the VRF has been deleted by Zebra.
3264 void bgp_instance_down(struct bgp
*bgp
)
3267 struct listnode
*node
;
3268 struct listnode
*next
;
3271 if (bgp
->t_rmap_def_originate_eval
) {
3272 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3273 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3277 /* Bring down peers, so corresponding routes are purged. */
3278 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3279 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3280 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3281 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3283 bgp_session_reset(peer
);
3286 /* Purge network and redistributed routes. */
3287 bgp_purge_static_redist_routes(bgp
);
3289 /* Cleanup registered nexthops (flags) */
3290 bgp_cleanup_nexthops(bgp
);
3293 /* Delete BGP instance. */
3294 int bgp_delete(struct bgp
*bgp
)
3297 struct peer_group
*group
;
3298 struct listnode
*node
, *next
;
3303 struct graceful_restart_info
*gr_info
;
3307 hook_call(bgp_inst_delete
, bgp
);
3309 THREAD_OFF(bgp
->t_startup
);
3310 THREAD_OFF(bgp
->t_maxmed_onstartup
);
3311 THREAD_OFF(bgp
->t_update_delay
);
3312 THREAD_OFF(bgp
->t_establish_wait
);
3314 /* Set flag indicating bgp instance delete in progress */
3315 SET_FLAG(bgp
->flags
, BGP_FLAG_DELETE_IN_PROGRESS
);
3317 /* Delete the graceful restart info */
3318 FOREACH_AFI_SAFI (afi
, safi
) {
3319 gr_info
= &bgp
->gr_info
[afi
][safi
];
3323 BGP_TIMER_OFF(gr_info
->t_select_deferral
);
3324 BGP_TIMER_OFF(gr_info
->t_route_select
);
3325 if (gr_info
->route_list
)
3326 list_delete(&gr_info
->route_list
);
3329 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3330 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3331 zlog_debug("Deleting Default VRF");
3333 zlog_debug("Deleting %s %s",
3334 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3340 /* unmap from RT list */
3341 bgp_evpn_vrf_delete(bgp
);
3343 /* unmap bgp vrf label */
3344 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP
);
3345 vpn_leak_zebra_vrf_label_withdraw(bgp
, AFI_IP6
);
3348 if (bgp
->t_rmap_def_originate_eval
) {
3349 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3350 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3354 /* Inform peers we're going down. */
3355 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3356 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3357 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3358 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3361 /* Delete static routes (networks). */
3362 bgp_static_delete(bgp
);
3364 /* Unset redistribution. */
3365 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3366 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3367 if (i
!= ZEBRA_ROUTE_BGP
)
3368 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3370 /* Free peers and peer-groups. */
3371 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3372 peer_group_delete(group
);
3374 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3377 if (bgp
->peer_self
) {
3378 peer_delete(bgp
->peer_self
);
3379 bgp
->peer_self
= NULL
;
3382 update_bgp_group_free(bgp
);
3384 /* TODO - Other memory may need to be freed - e.g., NHT */
3386 #ifdef ENABLE_BGP_VNC
3389 bgp_cleanup_routes(bgp
);
3391 for (afi
= 0; afi
< AFI_MAX
; ++afi
) {
3392 if (!bgp
->vpn_policy
[afi
].import_redirect_rtlist
)
3395 &bgp
->vpn_policy
[afi
]
3396 .import_redirect_rtlist
);
3397 bgp
->vpn_policy
[afi
].import_redirect_rtlist
= NULL
;
3400 /* Deregister from Zebra, if needed */
3401 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
3402 if (BGP_DEBUG(zebra
, ZEBRA
))
3404 "%s: deregistering this bgp %s instance from zebra",
3405 __func__
, bgp
->name
);
3406 bgp_zebra_instance_deregister(bgp
);
3409 /* Remove visibility via the master list - there may however still be
3410 * routes to be processed still referencing the struct bgp.
3412 listnode_delete(bm
->bgp
, bgp
);
3414 /* Free interfaces in this instance. */
3417 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3418 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3420 bgp_vrf_unlink(bgp
, vrf
);
3422 /* Update EVPN VRF pointer */
3423 if (bm
->bgp_evpn
== bgp
) {
3424 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3427 bgp_set_evpn(bgp_get_default());
3430 thread_master_free_unused(bm
->master
);
3431 bgp_unlock(bgp
); /* initial reference */
3436 void bgp_free(struct bgp
*bgp
)
3440 struct bgp_table
*table
;
3441 struct bgp_dest
*dest
;
3442 struct bgp_rmap
*rmap
;
3446 list_delete(&bgp
->group
);
3447 list_delete(&bgp
->peer
);
3449 if (bgp
->peerhash
) {
3450 hash_free(bgp
->peerhash
);
3451 bgp
->peerhash
= NULL
;
3454 FOREACH_AFI_SAFI (afi
, safi
) {
3455 /* Special handling for 2-level routing tables. */
3456 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3457 || safi
== SAFI_EVPN
) {
3458 for (dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); dest
;
3459 dest
= bgp_route_next(dest
)) {
3460 table
= bgp_dest_get_bgp_table_info(dest
);
3461 bgp_table_finish(&table
);
3464 if (bgp
->route
[afi
][safi
])
3465 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3466 if (bgp
->aggregate
[afi
][safi
])
3467 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3468 if (bgp
->rib
[afi
][safi
])
3469 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3470 rmap
= &bgp
->table_map
[afi
][safi
];
3471 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3474 bgp_scan_finish(bgp
);
3475 bgp_address_destroy(bgp
);
3476 bgp_tip_hash_destroy(bgp
);
3478 /* release the auto RD id */
3479 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
3481 bgp_evpn_cleanup(bgp
);
3482 bgp_pbr_cleanup(bgp
);
3483 XFREE(MTYPE_BGP_EVPN_INFO
, bgp
->evpn_info
);
3485 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3486 vpn_policy_direction_t dir
;
3488 if (bgp
->vpn_policy
[afi
].import_vrf
)
3489 list_delete(&bgp
->vpn_policy
[afi
].import_vrf
);
3490 if (bgp
->vpn_policy
[afi
].export_vrf
)
3491 list_delete(&bgp
->vpn_policy
[afi
].export_vrf
);
3493 dir
= BGP_VPN_POLICY_DIR_FROMVPN
;
3494 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3495 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3496 dir
= BGP_VPN_POLICY_DIR_TOVPN
;
3497 if (bgp
->vpn_policy
[afi
].rtlist
[dir
])
3498 ecommunity_free(&bgp
->vpn_policy
[afi
].rtlist
[dir
]);
3501 XFREE(MTYPE_BGP
, bgp
->name
);
3502 XFREE(MTYPE_BGP
, bgp
->name_pretty
);
3504 XFREE(MTYPE_BGP
, bgp
);
3507 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3510 struct listnode
*node
, *nnode
;
3516 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3517 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3518 && !CHECK_FLAG(peer
->sflags
,
3519 PEER_STATUS_ACCEPT_PEER
))
3521 } else if (bm
->bgp
!= NULL
) {
3522 struct listnode
*bgpnode
, *nbgpnode
;
3524 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3525 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3527 && !strcmp(peer
->conf_if
, conf_if
)
3528 && !CHECK_FLAG(peer
->sflags
,
3529 PEER_STATUS_ACCEPT_PEER
))
3535 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
3538 struct listnode
*node
, *nnode
;
3544 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3545 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3546 && !CHECK_FLAG(peer
->sflags
,
3547 PEER_STATUS_ACCEPT_PEER
))
3549 } else if (bm
->bgp
!= NULL
) {
3550 struct listnode
*bgpnode
, *nbgpnode
;
3552 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3553 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3555 && !strcmp(peer
->hostname
, hostname
)
3556 && !CHECK_FLAG(peer
->sflags
,
3557 PEER_STATUS_ACCEPT_PEER
))
3563 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
3565 struct peer
*peer
= NULL
;
3566 struct peer tmp_peer
;
3568 memset(&tmp_peer
, 0, sizeof(struct peer
));
3571 * We do not want to find the doppelganger peer so search for the peer
3573 * the hash that has PEER_FLAG_CONFIG_NODE
3575 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3580 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3581 } else if (bm
->bgp
!= NULL
) {
3582 struct listnode
*bgpnode
, *nbgpnode
;
3584 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
3585 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3594 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
3595 union sockunion
*su
,
3596 struct peer_group
*group
)
3602 /* Create peer first; we've already checked group config is valid. */
3603 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3604 group
->conf
->as_type
, 0, 0, group
);
3609 peer
= peer_lock(peer
);
3610 listnode_add(group
->peer
, peer
);
3612 peer_group2peer_config_copy(group
, peer
);
3615 * Bind peer for all AFs configured for the group. We don't call
3616 * peer_group_bind as that is sub-optimal and does some stuff we don't
3619 FOREACH_AFI_SAFI (afi
, safi
) {
3620 if (!group
->conf
->afc
[afi
][safi
])
3622 peer
->afc
[afi
][safi
] = 1;
3624 if (!peer_af_find(peer
, afi
, safi
))
3625 peer_af_create(peer
, afi
, safi
);
3627 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
3630 /* Mark as dynamic, but also as a "config node" for other things to
3632 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3633 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3639 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
3640 struct prefix
*prefix
)
3642 struct listnode
*node
, *nnode
;
3643 struct prefix
*range
;
3646 afi
= family2afi(prefix
->family
);
3648 if (group
->listen_range
[afi
])
3649 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
3651 if (prefix_match(range
, prefix
))
3658 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
3659 struct prefix
**listen_range
)
3661 struct prefix
*range
= NULL
;
3662 struct peer_group
*group
= NULL
;
3663 struct listnode
*node
, *nnode
;
3665 *listen_range
= NULL
;
3667 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3668 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3671 } else if (bm
->bgp
!= NULL
) {
3672 struct listnode
*bgpnode
, *nbgpnode
;
3674 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3675 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3676 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3682 *listen_range
= range
;
3683 return (group
&& range
) ? group
: NULL
;
3686 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
3688 struct peer_group
*group
;
3691 struct prefix prefix
;
3692 struct prefix
*listen_range
;
3694 char buf
[PREFIX2STR_BUFFER
];
3695 char buf1
[PREFIX2STR_BUFFER
];
3697 sockunion2hostprefix(su
, &prefix
);
3699 /* See if incoming connection matches a configured listen range. */
3700 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
3711 prefix2str(&prefix
, buf
, sizeof(buf
));
3712 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3714 if (bgp_debug_neighbor_events(NULL
))
3716 "Dynamic Neighbor %s matches group %s listen range %s",
3717 buf
, group
->name
, buf1
);
3719 /* Are we within the listen limit? */
3720 dncount
= gbgp
->dynamic_neighbors_count
;
3722 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
3723 if (bgp_debug_neighbor_events(NULL
))
3724 zlog_debug("Dynamic Neighbor %s rejected - at limit %d",
3725 inet_sutop(su
, buf
),
3726 gbgp
->dynamic_neighbors_limit
);
3730 /* Ensure group is not disabled. */
3731 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
3732 if (bgp_debug_neighbor_events(NULL
))
3734 "Dynamic Neighbor %s rejected - group %s disabled",
3739 /* Check that at least one AF is activated for the group. */
3740 if (!peer_group_af_configured(group
)) {
3741 if (bgp_debug_neighbor_events(NULL
))
3743 "Dynamic Neighbor %s rejected - no AF activated for group %s",
3748 /* Create dynamic peer and bind to associated group. */
3749 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
3752 gbgp
->dynamic_neighbors_count
= ++dncount
;
3754 if (bgp_debug_neighbor_events(peer
))
3755 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
3756 peer
->host
, group
->name
, dncount
);
3761 static void peer_drop_dynamic_neighbor(struct peer
*peer
)
3764 if (peer
->group
->bgp
) {
3765 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3767 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3769 if (bgp_debug_neighbor_events(peer
))
3770 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
3771 peer
->group
->name
, dncount
);
3774 /* If peer is configured at least one address family return 1. */
3775 bool peer_active(struct peer
*peer
)
3777 if (BGP_PEER_SU_UNSPEC(peer
))
3779 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3780 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3781 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3782 || peer
->afc
[AFI_IP
][SAFI_FLOWSPEC
]
3783 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3784 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3785 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3786 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3787 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
3788 || peer
->afc
[AFI_IP6
][SAFI_FLOWSPEC
]
3789 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
3794 /* If peer is negotiated at least one address family return 1. */
3795 bool peer_active_nego(struct peer
*peer
)
3797 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3798 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3799 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3800 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3801 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3802 || peer
->afc_nego
[AFI_IP
][SAFI_FLOWSPEC
]
3803 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3804 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3805 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3806 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3807 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
3808 || peer
->afc_nego
[AFI_IP6
][SAFI_FLOWSPEC
]
3809 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
3814 void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
3815 enum peer_change_type type
)
3817 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
3820 if (peer
->status
!= Established
)
3823 if (type
== peer_change_reset
) {
3824 /* If we're resetting session, we've to delete both peer struct
3826 if ((peer
->doppelganger
)
3827 && (peer
->doppelganger
->status
!= Deleted
)
3828 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3829 PEER_FLAG_CONFIG_NODE
)))
3830 peer_delete(peer
->doppelganger
);
3832 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3833 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3834 } else if (type
== peer_change_reset_in
) {
3835 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3836 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3837 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
3839 if ((peer
->doppelganger
)
3840 && (peer
->doppelganger
->status
!= Deleted
)
3841 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3842 PEER_FLAG_CONFIG_NODE
)))
3843 peer_delete(peer
->doppelganger
);
3845 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3846 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3848 } else if (type
== peer_change_reset_out
) {
3849 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3850 bgp_announce_route(peer
, afi
, safi
);
3854 struct peer_flag_action
{
3858 /* This flag can be set for peer-group member. */
3859 uint8_t not_for_member
;
3861 /* Action when the flag is changed. */
3862 enum peer_change_type type
;
3865 static const struct peer_flag_action peer_flag_action_list
[] = {
3866 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3867 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3868 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3869 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3870 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3871 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3872 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3873 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3874 {PEER_FLAG_ENFORCE_FIRST_AS
, 0, peer_change_reset_in
},
3875 {PEER_FLAG_IFPEER_V6ONLY
, 0, peer_change_reset
},
3876 {PEER_FLAG_ROUTEADV
, 0, peer_change_none
},
3877 {PEER_FLAG_TIMER
, 0, peer_change_none
},
3878 {PEER_FLAG_TIMER_CONNECT
, 0, peer_change_none
},
3879 {PEER_FLAG_PASSWORD
, 0, peer_change_none
},
3880 {PEER_FLAG_LOCAL_AS
, 0, peer_change_none
},
3881 {PEER_FLAG_LOCAL_AS_NO_PREPEND
, 0, peer_change_none
},
3882 {PEER_FLAG_LOCAL_AS_REPLACE_AS
, 0, peer_change_none
},
3883 {PEER_FLAG_UPDATE_SOURCE
, 0, peer_change_none
},
3886 static const struct peer_flag_action peer_af_flag_action_list
[] = {
3887 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3888 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3889 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3890 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3891 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3892 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3893 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3894 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3895 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3896 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3897 {PEER_FLAG_DEFAULT_ORIGINATE
, 0, peer_change_none
},
3898 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3899 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3900 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3901 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3902 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3903 {PEER_FLAG_MAX_PREFIX
, 0, peer_change_none
},
3904 {PEER_FLAG_MAX_PREFIX_WARNING
, 0, peer_change_none
},
3905 {PEER_FLAG_MAX_PREFIX_FORCE
, 0, peer_change_none
},
3906 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3907 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3908 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3909 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
3910 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3911 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
3912 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3915 /* Proper action set. */
3916 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
3917 int size
, struct peer_flag_action
*action
,
3924 const struct peer_flag_action
*match
= NULL
;
3926 /* Check peer's frag action. */
3927 for (i
= 0; i
< size
; i
++) {
3928 match
= &action_list
[i
];
3930 if (match
->flag
== 0)
3933 if (match
->flag
& flag
) {
3936 if (match
->type
== peer_change_reset_in
)
3938 if (match
->type
== peer_change_reset_out
)
3940 if (match
->type
== peer_change_reset
) {
3944 if (match
->not_for_member
)
3945 action
->not_for_member
= 1;
3949 /* Set peer clear type. */
3950 if (reset_in
&& reset_out
)
3951 action
->type
= peer_change_reset
;
3953 action
->type
= peer_change_reset_in
;
3955 action
->type
= peer_change_reset_out
;
3957 action
->type
= peer_change_none
;
3962 static void peer_flag_modify_action(struct peer
*peer
, uint32_t flag
)
3964 if (flag
== PEER_FLAG_SHUTDOWN
) {
3965 if (CHECK_FLAG(peer
->flags
, flag
)) {
3966 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3967 peer_nsf_stop(peer
);
3969 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3970 if (peer
->t_pmax_restart
) {
3971 BGP_TIMER_OFF(peer
->t_pmax_restart
);
3972 if (bgp_debug_neighbor_events(peer
))
3974 "%s Maximum-prefix restart timer canceled",
3978 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3979 char *msg
= peer
->tx_shutdown_message
;
3982 if (!msg
&& peer_group_active(peer
))
3983 msg
= peer
->group
->conf
3984 ->tx_shutdown_message
;
3985 msglen
= msg
? strlen(msg
) : 0;
3990 uint8_t msgbuf
[129];
3993 memcpy(msgbuf
+ 1, msg
, msglen
);
3995 bgp_notify_send_with_data(
3996 peer
, BGP_NOTIFY_CEASE
,
3997 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3998 msgbuf
, msglen
+ 1);
4001 peer
, BGP_NOTIFY_CEASE
,
4002 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4004 bgp_session_reset(peer
);
4006 peer
->v_start
= BGP_INIT_START_TIMER
;
4007 BGP_EVENT_ADD(peer
, BGP_Stop
);
4009 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4010 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
4011 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4012 else if (flag
== PEER_FLAG_PASSIVE
)
4013 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
4014 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
4015 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
4017 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4018 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4020 bgp_session_reset(peer
);
4023 /* Enable global administrative shutdown of all peers of BGP instance */
4024 void bgp_shutdown_enable(struct bgp
*bgp
, const char *msg
)
4027 struct listnode
*node
;
4029 /* do nothing if already shut down */
4030 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4033 /* informational log message */
4034 zlog_info("Enabled administrative shutdown on BGP instance AS %u",
4037 /* iterate through peers of BGP instance */
4038 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
4039 /* continue, if peer is already in administrative shutdown. */
4040 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
))
4043 /* send a RFC 4486 notification message if necessary */
4044 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4046 bgp_notify_send_with_data(
4047 peer
, BGP_NOTIFY_CEASE
,
4048 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
4049 (uint8_t *)(msg
), strlen(msg
));
4052 peer
, BGP_NOTIFY_CEASE
,
4053 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
4056 /* reset start timer to initial value */
4057 peer
->v_start
= BGP_INIT_START_TIMER
;
4059 /* trigger a RFC 4271 ManualStop event */
4060 BGP_EVENT_ADD(peer
, BGP_Stop
);
4063 /* set the BGP instances shutdown flag */
4064 SET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4067 /* Disable global administrative shutdown of all peers of BGP instance */
4068 void bgp_shutdown_disable(struct bgp
*bgp
)
4070 /* do nothing if not shut down. */
4071 if (!CHECK_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
))
4074 /* informational log message */
4075 zlog_info("Disabled administrative shutdown on BGP instance AS %u",
4078 /* clear the BGP instances shutdown flag */
4079 UNSET_FLAG(bgp
->flags
, BGP_FLAG_SHUTDOWN
);
4082 /* Change specified peer flag. */
4083 static int peer_flag_modify(struct peer
*peer
, uint32_t flag
, int set
)
4087 bool invert
, member_invert
;
4088 struct peer
*member
;
4089 struct listnode
*node
, *nnode
;
4090 struct peer_flag_action action
;
4092 memset(&action
, 0, sizeof(struct peer_flag_action
));
4093 size
= sizeof(peer_flag_action_list
) / sizeof(struct peer_flag_action
);
4095 invert
= CHECK_FLAG(peer
->flags_invert
, flag
);
4096 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
4099 /* Abort if no flag action exists. */
4101 return BGP_ERR_INVALID_FLAG
;
4103 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4104 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
4105 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
4106 return BGP_ERR_PEER_FLAG_CONFLICT
;
4108 /* Handle flag updates where desired state matches current state. */
4109 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4110 if (set
&& CHECK_FLAG(peer
->flags
, flag
)) {
4111 COND_FLAG(peer
->flags_override
, flag
, !invert
);
4115 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
)) {
4116 COND_FLAG(peer
->flags_override
, flag
, invert
);
4121 /* Inherit from peer-group or set/unset flags accordingly. */
4122 if (peer_group_active(peer
) && set
== invert
)
4123 peer_flag_inherit(peer
, flag
);
4125 COND_FLAG(peer
->flags
, flag
, set
);
4127 /* Check if handling a regular peer. */
4128 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4129 /* Update flag override state accordingly. */
4130 COND_FLAG(peer
->flags_override
, flag
, set
!= invert
);
4133 * For the extended next-hop encoding flag we need to turn RAs
4134 * on if flag is being set, but only turn RAs off if the flag
4135 * is being unset on this peer and if this peer is a member of a
4136 * peer-group, the peer-group also doesn't have the flag set.
4138 if (flag
== PEER_FLAG_CAPABILITY_ENHE
) {
4140 bgp_zebra_initiate_radv(peer
->bgp
, peer
);
4141 } else if (peer_group_active(peer
)) {
4142 if (!CHECK_FLAG(peer
->group
->conf
->flags
, flag
))
4143 bgp_zebra_terminate_radv(peer
->bgp
,
4146 bgp_zebra_terminate_radv(peer
->bgp
, peer
);
4149 /* Execute flag action on peer. */
4150 if (action
.type
== peer_change_reset
)
4151 peer_flag_modify_action(peer
, flag
);
4153 /* Skip peer-group mechanics for regular peers. */
4158 * Update peer-group members, unless they are explicitely overriding
4159 * peer-group configuration.
4161 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4162 /* Skip peers with overridden configuration. */
4163 if (CHECK_FLAG(member
->flags_override
, flag
))
4166 /* Check if only member without group is inverted. */
4168 CHECK_FLAG(member
->flags_invert
, flag
) && !invert
;
4170 /* Skip peers with equivalent configuration. */
4171 if (set
!= member_invert
&& CHECK_FLAG(member
->flags
, flag
))
4174 if (set
== member_invert
&& !CHECK_FLAG(member
->flags
, flag
))
4177 /* Update flag on peer-group member. */
4178 COND_FLAG(member
->flags
, flag
, set
!= member_invert
);
4180 if (flag
== PEER_FLAG_CAPABILITY_ENHE
)
4181 set
? bgp_zebra_initiate_radv(member
->bgp
, member
)
4182 : bgp_zebra_terminate_radv(member
->bgp
, member
);
4184 /* Execute flag action on peer-group member. */
4185 if (action
.type
== peer_change_reset
)
4186 peer_flag_modify_action(member
, flag
);
4192 int peer_flag_set(struct peer
*peer
, uint32_t flag
)
4194 return peer_flag_modify(peer
, flag
, 1);
4197 int peer_flag_unset(struct peer
*peer
, uint32_t flag
)
4199 return peer_flag_modify(peer
, flag
, 0);
4202 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
4203 uint32_t flag
, bool set
)
4207 bool invert
, member_invert
;
4208 struct peer
*member
;
4209 struct listnode
*node
, *nnode
;
4210 struct peer_flag_action action
;
4211 bgp_peer_sort_t ptype
;
4213 memset(&action
, 0, sizeof(struct peer_flag_action
));
4214 size
= sizeof(peer_af_flag_action_list
)
4215 / sizeof(struct peer_flag_action
);
4217 invert
= CHECK_FLAG(peer
->af_flags_invert
[afi
][safi
], flag
);
4218 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
4221 /* Abort if flag action exists. */
4223 return BGP_ERR_INVALID_FLAG
;
4225 ptype
= peer_sort(peer
);
4226 /* Special check for reflector client. */
4227 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
&& ptype
!= BGP_PEER_IBGP
)
4228 return BGP_ERR_NOT_INTERNAL_PEER
;
4230 /* Special check for remove-private-AS. */
4231 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
&& ptype
== BGP_PEER_IBGP
)
4232 return BGP_ERR_REMOVE_PRIVATE_AS
;
4234 /* as-override is not allowed for IBGP peers */
4235 if (flag
& PEER_FLAG_AS_OVERRIDE
&& ptype
== BGP_PEER_IBGP
)
4236 return BGP_ERR_AS_OVERRIDE
;
4238 /* Handle flag updates where desired state matches current state. */
4239 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4240 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4241 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4246 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
)) {
4247 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4254 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4255 * if we are setting/unsetting flags which conflict with this flag
4256 * handle accordingly
4258 if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
4262 * if we are setting NEXTHOP_SELF, we need to unset the
4263 * NEXTHOP_UNCHANGED flag
4265 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4266 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4267 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4268 PEER_FLAG_NEXTHOP_UNCHANGED
);
4272 * if we are unsetting NEXTHOP_SELF, we need to set the
4273 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4275 if (CHECK_FLAG(flag
, PEER_FLAG_NEXTHOP_SELF
) ||
4276 CHECK_FLAG(flag
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
4277 SET_FLAG(peer
->af_flags
[afi
][safi
],
4278 PEER_FLAG_NEXTHOP_UNCHANGED
);
4283 * If the peer is a route server client let's not
4284 * muck with the nexthop on the way out the door
4286 if (flag
& PEER_FLAG_RSERVER_CLIENT
) {
4288 SET_FLAG(peer
->af_flags
[afi
][safi
],
4289 PEER_FLAG_NEXTHOP_UNCHANGED
);
4291 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4292 PEER_FLAG_NEXTHOP_UNCHANGED
);
4295 /* Inherit from peer-group or set/unset flags accordingly. */
4296 if (peer_group_active(peer
) && set
== invert
)
4297 peer_af_flag_inherit(peer
, afi
, safi
, flag
);
4299 COND_FLAG(peer
->af_flags
[afi
][safi
], flag
, set
);
4301 /* Execute action when peer is established. */
4302 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4303 && peer
->status
== Established
) {
4304 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4305 bgp_clear_adj_in(peer
, afi
, safi
);
4307 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4308 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4309 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4310 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4311 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4312 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4313 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4314 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4316 peer_change_action(peer
, afi
, safi
, action
.type
);
4320 /* Check if handling a regular peer. */
4321 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4322 COND_FLAG(peer
->af_flags_override
[afi
][safi
], flag
,
4326 * Update peer-group members, unless they are explicitely
4327 * overriding peer-group configuration.
4329 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
,
4331 /* Skip peers with overridden configuration. */
4332 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4336 /* Check if only member without group is inverted. */
4338 CHECK_FLAG(member
->af_flags_invert
[afi
][safi
],
4342 /* Skip peers with equivalent configuration. */
4343 if (set
!= member_invert
4344 && CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4347 if (set
== member_invert
4348 && !CHECK_FLAG(member
->af_flags
[afi
][safi
], flag
))
4351 /* Update flag on peer-group member. */
4352 COND_FLAG(member
->af_flags
[afi
][safi
], flag
,
4353 set
!= member_invert
);
4355 /* Execute flag action on peer-group member. */
4356 if (member
->status
== Established
) {
4357 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4358 bgp_clear_adj_in(member
, afi
, safi
);
4360 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4361 member
->last_reset
=
4362 PEER_DOWN_RR_CLIENT_CHANGE
;
4364 == PEER_FLAG_RSERVER_CLIENT
)
4365 member
->last_reset
=
4366 PEER_DOWN_RS_CLIENT_CHANGE
;
4368 == PEER_FLAG_ORF_PREFIX_SM
)
4369 member
->last_reset
=
4370 PEER_DOWN_CAPABILITY_CHANGE
;
4372 == PEER_FLAG_ORF_PREFIX_RM
)
4373 member
->last_reset
=
4374 PEER_DOWN_CAPABILITY_CHANGE
;
4376 peer_change_action(member
, afi
, safi
,
4386 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4388 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4391 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, uint32_t flag
)
4393 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4397 void peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4399 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4400 peer
->tx_shutdown_message
=
4401 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4404 void peer_tx_shutdown_message_unset(struct peer
*peer
)
4406 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4410 /* EBGP multihop configuration. */
4411 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4413 struct peer_group
*group
;
4414 struct listnode
*node
, *nnode
;
4417 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4420 /* see comment in peer_ttl_security_hops_set() */
4421 if (ttl
!= MAXTTL
) {
4422 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4423 group
= peer
->group
;
4424 if (group
->conf
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4425 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4427 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4429 if (peer1
->sort
== BGP_PEER_IBGP
)
4432 if (peer1
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4433 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4436 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
)
4437 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4443 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4444 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
) {
4445 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4446 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4447 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4449 bgp_session_reset(peer
);
4452 group
= peer
->group
;
4453 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4454 if (peer
->sort
== BGP_PEER_IBGP
)
4457 peer
->ttl
= group
->conf
->ttl
;
4459 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4460 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4461 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4463 bgp_session_reset(peer
);
4469 int peer_ebgp_multihop_unset(struct peer
*peer
)
4471 struct peer_group
*group
;
4472 struct listnode
*node
, *nnode
;
4474 if (peer
->sort
== BGP_PEER_IBGP
)
4477 if (peer
->gtsm_hops
!= BGP_GTSM_HOPS_DISABLED
&& peer
->ttl
!= MAXTTL
)
4478 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4480 if (peer_group_active(peer
))
4481 peer
->ttl
= peer
->group
->conf
->ttl
;
4483 peer
->ttl
= BGP_DEFAULT_TTL
;
4485 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4486 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4487 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4488 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4490 bgp_session_reset(peer
);
4492 group
= peer
->group
;
4493 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4494 if (peer
->sort
== BGP_PEER_IBGP
)
4497 peer
->ttl
= BGP_DEFAULT_TTL
;
4499 if (peer
->fd
>= 0) {
4500 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4502 peer
, BGP_NOTIFY_CEASE
,
4503 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4505 bgp_session_reset(peer
);
4512 /* Neighbor description. */
4513 void peer_description_set(struct peer
*peer
, const char *desc
)
4515 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4517 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
4520 void peer_description_unset(struct peer
*peer
)
4522 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4525 /* Neighbor update-source. */
4526 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
4528 struct peer
*member
;
4529 struct listnode
*node
, *nnode
;
4531 /* Set flag and configuration on peer. */
4532 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
4533 if (peer
->update_if
) {
4534 if (strcmp(peer
->update_if
, ifname
) == 0)
4536 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4538 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4539 sockunion_free(peer
->update_source
);
4540 peer
->update_source
= NULL
;
4542 /* Check if handling a regular peer. */
4543 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4544 /* Send notification or reset peer depending on state. */
4545 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4546 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4547 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4548 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4550 bgp_session_reset(peer
);
4552 /* Skip peer-group mechanics for regular peers. */
4557 * Set flag and configuration on all peer-group members, unless they are
4558 * explicitely overriding peer-group configuration.
4560 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4561 /* Skip peers with overridden configuration. */
4562 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4565 /* Skip peers with the same configuration. */
4566 if (member
->update_if
) {
4567 if (strcmp(member
->update_if
, ifname
) == 0)
4569 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4572 /* Set flag and configuration on peer-group member. */
4573 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4574 member
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4575 sockunion_free(member
->update_source
);
4576 member
->update_source
= NULL
;
4578 /* Send notification or reset peer depending on state. */
4579 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4580 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4581 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4582 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4584 bgp_session_reset(member
);
4590 int peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
4592 struct peer
*member
;
4593 struct listnode
*node
, *nnode
;
4595 /* Set flag and configuration on peer. */
4596 peer_flag_set(peer
, PEER_FLAG_UPDATE_SOURCE
);
4597 if (peer
->update_source
) {
4598 if (sockunion_cmp(peer
->update_source
, su
) == 0)
4600 sockunion_free(peer
->update_source
);
4602 peer
->update_source
= sockunion_dup(su
);
4603 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4605 /* Check if handling a regular peer. */
4606 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4607 /* Send notification or reset peer depending on state. */
4608 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4609 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4610 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4611 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4613 bgp_session_reset(peer
);
4615 /* Skip peer-group mechanics for regular peers. */
4620 * Set flag and configuration on all peer-group members, unless they are
4621 * explicitely overriding peer-group configuration.
4623 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4624 /* Skip peers with overridden configuration. */
4625 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4628 /* Skip peers with the same configuration. */
4629 if (member
->update_source
) {
4630 if (sockunion_cmp(member
->update_source
, su
) == 0)
4632 sockunion_free(member
->update_source
);
4635 /* Set flag and configuration on peer-group member. */
4636 SET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4637 member
->update_source
= sockunion_dup(su
);
4638 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4640 /* Send notification or reset peer depending on state. */
4641 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4642 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4643 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4644 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4646 bgp_session_reset(member
);
4652 int peer_update_source_unset(struct peer
*peer
)
4654 struct peer
*member
;
4655 struct listnode
*node
, *nnode
;
4657 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_UPDATE_SOURCE
))
4660 /* Inherit configuration from peer-group if peer is member. */
4661 if (peer_group_active(peer
)) {
4662 peer_flag_inherit(peer
, PEER_FLAG_UPDATE_SOURCE
);
4663 PEER_SU_ATTR_INHERIT(peer
, peer
->group
, update_source
);
4664 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, update_if
,
4665 MTYPE_PEER_UPDATE_SOURCE
);
4667 /* Otherwise remove flag and configuration from peer. */
4668 peer_flag_unset(peer
, PEER_FLAG_UPDATE_SOURCE
);
4669 sockunion_free(peer
->update_source
);
4670 peer
->update_source
= NULL
;
4671 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4674 /* Check if handling a regular peer. */
4675 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4676 /* Send notification or reset peer depending on state. */
4677 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4678 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4679 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4680 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4682 bgp_session_reset(peer
);
4684 /* Skip peer-group mechanics for regular peers. */
4689 * Set flag and configuration on all peer-group members, unless they are
4690 * explicitely overriding peer-group configuration.
4692 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4693 /* Skip peers with overridden configuration. */
4694 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_UPDATE_SOURCE
))
4697 /* Skip peers with the same configuration. */
4698 if (!CHECK_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
)
4699 && !member
->update_source
&& !member
->update_if
)
4702 /* Remove flag and configuration on peer-group member. */
4703 UNSET_FLAG(member
->flags
, PEER_FLAG_UPDATE_SOURCE
);
4704 sockunion_free(member
->update_source
);
4705 member
->update_source
= NULL
;
4706 XFREE(MTYPE_PEER_UPDATE_SOURCE
, member
->update_if
);
4708 /* Send notification or reset peer depending on state. */
4709 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
4710 member
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4711 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
4712 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4714 bgp_session_reset(member
);
4720 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
4721 const char *rmap
, struct route_map
*route_map
)
4723 struct peer
*member
;
4724 struct listnode
*node
, *nnode
;
4726 /* Set flag and configuration on peer. */
4727 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
);
4729 if (!peer
->default_rmap
[afi
][safi
].name
4730 || strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0) {
4731 if (peer
->default_rmap
[afi
][safi
].name
)
4732 XFREE(MTYPE_ROUTE_MAP_NAME
,
4733 peer
->default_rmap
[afi
][safi
].name
);
4735 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4736 peer
->default_rmap
[afi
][safi
].name
=
4737 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4738 peer
->default_rmap
[afi
][safi
].map
= route_map
;
4739 route_map_counter_increment(route_map
);
4742 if (peer
->default_rmap
[afi
][safi
].name
)
4743 XFREE(MTYPE_ROUTE_MAP_NAME
,
4744 peer
->default_rmap
[afi
][safi
].name
);
4746 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4747 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4748 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4751 /* Check if handling a regular peer. */
4752 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4753 /* Update peer route announcements. */
4754 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4755 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4756 bgp_default_originate(peer
, afi
, safi
, 0);
4757 bgp_announce_route(peer
, afi
, safi
);
4760 /* Skip peer-group mechanics for regular peers. */
4765 * Set flag and configuration on all peer-group members, unless they are
4766 * explicitely overriding peer-group configuration.
4768 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4769 /* Skip peers with overridden configuration. */
4770 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4771 PEER_FLAG_DEFAULT_ORIGINATE
))
4774 /* Set flag and configuration on peer-group member. */
4775 SET_FLAG(member
->af_flags
[afi
][safi
],
4776 PEER_FLAG_DEFAULT_ORIGINATE
);
4778 if (member
->default_rmap
[afi
][safi
].name
)
4779 XFREE(MTYPE_ROUTE_MAP_NAME
,
4780 member
->default_rmap
[afi
][safi
].name
);
4781 route_map_counter_decrement(
4782 member
->default_rmap
[afi
][safi
].map
);
4783 member
->default_rmap
[afi
][safi
].name
=
4784 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4785 member
->default_rmap
[afi
][safi
].map
= route_map
;
4786 route_map_counter_increment(route_map
);
4789 /* Update peer route announcements. */
4790 if (member
->status
== Established
4791 && member
->afc_nego
[afi
][safi
]) {
4792 update_group_adjust_peer(
4793 peer_af_find(member
, afi
, safi
));
4794 bgp_default_originate(member
, afi
, safi
, 0);
4795 bgp_announce_route(member
, afi
, safi
);
4802 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4804 struct peer
*member
;
4805 struct listnode
*node
, *nnode
;
4807 /* Inherit configuration from peer-group if peer is member. */
4808 if (peer_group_active(peer
)) {
4809 peer_af_flag_inherit(peer
, afi
, safi
,
4810 PEER_FLAG_DEFAULT_ORIGINATE
);
4811 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
4812 default_rmap
[afi
][safi
].name
,
4813 MTYPE_ROUTE_MAP_NAME
);
4814 PEER_ATTR_INHERIT(peer
, peer
->group
,
4815 default_rmap
[afi
][safi
].map
);
4817 /* Otherwise remove flag and configuration from peer. */
4818 peer_af_flag_unset(peer
, afi
, safi
,
4819 PEER_FLAG_DEFAULT_ORIGINATE
);
4820 if (peer
->default_rmap
[afi
][safi
].name
)
4821 XFREE(MTYPE_ROUTE_MAP_NAME
,
4822 peer
->default_rmap
[afi
][safi
].name
);
4823 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4824 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4825 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4828 /* Check if handling a regular peer. */
4829 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4830 /* Update peer route announcements. */
4831 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4832 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4833 bgp_default_originate(peer
, afi
, safi
, 1);
4834 bgp_announce_route(peer
, afi
, safi
);
4837 /* Skip peer-group mechanics for regular peers. */
4842 * Remove flag and configuration from all peer-group members, unless
4843 * they are explicitely overriding peer-group configuration.
4845 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4846 /* Skip peers with overridden configuration. */
4847 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4848 PEER_FLAG_DEFAULT_ORIGINATE
))
4851 /* Remove flag and configuration on peer-group member. */
4852 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4853 PEER_FLAG_DEFAULT_ORIGINATE
);
4854 if (peer
->default_rmap
[afi
][safi
].name
)
4855 XFREE(MTYPE_ROUTE_MAP_NAME
,
4856 peer
->default_rmap
[afi
][safi
].name
);
4857 route_map_counter_decrement(peer
->default_rmap
[afi
][safi
].map
);
4858 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4859 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4861 /* Update peer route announcements. */
4862 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4863 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4864 bgp_default_originate(peer
, afi
, safi
, 1);
4865 bgp_announce_route(peer
, afi
, safi
);
4872 void peer_port_set(struct peer
*peer
, uint16_t port
)
4877 void peer_port_unset(struct peer
*peer
)
4879 peer
->port
= BGP_PORT_DEFAULT
;
4883 * Helper function that is called after the name of the policy
4884 * being used by a peer has changed (AF specific). Automatically
4885 * initiates inbound or outbound processing as needed.
4887 static void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
4891 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4892 if (peer
->status
== Established
)
4893 bgp_announce_route(peer
, afi
, safi
);
4895 if (peer
->status
!= Established
)
4898 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4899 PEER_FLAG_SOFT_RECONFIG
))
4900 bgp_soft_reconfig_in(peer
, afi
, safi
);
4901 else if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4902 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4903 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
4908 /* neighbor weight. */
4909 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, uint16_t weight
)
4911 struct peer
*member
;
4912 struct listnode
*node
, *nnode
;
4914 /* Set flag and configuration on peer. */
4915 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4916 if (peer
->weight
[afi
][safi
] != weight
) {
4917 peer
->weight
[afi
][safi
] = weight
;
4918 peer_on_policy_change(peer
, afi
, safi
, 0);
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
->af_flags_override
[afi
][safi
],
4935 /* Set flag and configuration on peer-group member. */
4936 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4937 if (member
->weight
[afi
][safi
] != weight
) {
4938 member
->weight
[afi
][safi
] = weight
;
4939 peer_on_policy_change(member
, afi
, safi
, 0);
4946 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4948 struct peer
*member
;
4949 struct listnode
*node
, *nnode
;
4951 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4954 /* Inherit configuration from peer-group if peer is member. */
4955 if (peer_group_active(peer
)) {
4956 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4957 PEER_ATTR_INHERIT(peer
, peer
->group
, weight
[afi
][safi
]);
4959 peer_on_policy_change(peer
, afi
, safi
, 0);
4963 /* Remove flag and configuration from peer. */
4964 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4965 peer
->weight
[afi
][safi
] = 0;
4966 peer_on_policy_change(peer
, afi
, safi
, 0);
4968 /* Skip peer-group mechanics for regular peers. */
4969 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4973 * Remove flag and configuration from all peer-group members, unless
4974 * they are explicitely overriding peer-group configuration.
4976 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
4977 /* Skip peers with overridden configuration. */
4978 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
4982 /* Skip peers where flag is already disabled. */
4983 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4986 /* Remove flag and configuration on peer-group member. */
4987 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4988 member
->weight
[afi
][safi
] = 0;
4989 peer_on_policy_change(member
, afi
, safi
, 0);
4995 int peer_timers_set(struct peer
*peer
, uint32_t keepalive
, uint32_t holdtime
)
4997 struct peer
*member
;
4998 struct listnode
*node
, *nnode
;
5000 if (keepalive
> 65535)
5001 return BGP_ERR_INVALID_VALUE
;
5003 if (holdtime
> 65535)
5004 return BGP_ERR_INVALID_VALUE
;
5006 if (holdtime
< 3 && holdtime
!= 0)
5007 return BGP_ERR_INVALID_VALUE
;
5009 /* Set flag and configuration on peer. */
5010 peer_flag_set(peer
, PEER_FLAG_TIMER
);
5011 peer
->holdtime
= holdtime
;
5012 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
5014 /* Skip peer-group mechanics for regular peers. */
5015 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5019 * Set flag and configuration on all peer-group members, unless they are
5020 * explicitely overriding peer-group configuration.
5022 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5023 /* Skip peers with overridden configuration. */
5024 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5027 /* Set flag and configuration on peer-group member. */
5028 SET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5029 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
5030 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
5036 int peer_timers_unset(struct peer
*peer
)
5038 struct peer
*member
;
5039 struct listnode
*node
, *nnode
;
5041 /* Inherit configuration from peer-group if peer is member. */
5042 if (peer_group_active(peer
)) {
5043 peer_flag_inherit(peer
, PEER_FLAG_TIMER
);
5044 PEER_ATTR_INHERIT(peer
, peer
->group
, holdtime
);
5045 PEER_ATTR_INHERIT(peer
, peer
->group
, keepalive
);
5047 /* Otherwise remove flag and configuration from peer. */
5048 peer_flag_unset(peer
, PEER_FLAG_TIMER
);
5050 peer
->keepalive
= 0;
5053 /* Skip peer-group mechanics for regular peers. */
5054 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5058 * Remove flag and configuration from all peer-group members, unless
5059 * they are explicitely overriding peer-group configuration.
5061 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5062 /* Skip peers with overridden configuration. */
5063 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER
))
5066 /* Remove flag and configuration on peer-group member. */
5067 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER
);
5068 member
->holdtime
= 0;
5069 member
->keepalive
= 0;
5075 int peer_timers_connect_set(struct peer
*peer
, uint32_t connect
)
5077 struct peer
*member
;
5078 struct listnode
*node
, *nnode
;
5080 if (connect
> 65535)
5081 return BGP_ERR_INVALID_VALUE
;
5083 /* Set flag and configuration on peer. */
5084 peer_flag_set(peer
, PEER_FLAG_TIMER_CONNECT
);
5085 peer
->connect
= connect
;
5086 peer
->v_connect
= connect
;
5088 /* Skip peer-group mechanics for regular peers. */
5089 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5093 * Set flag and configuration on all peer-group members, unless they are
5094 * explicitely overriding peer-group configuration.
5096 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5097 /* Skip peers with overridden configuration. */
5098 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5101 /* Set flag and configuration on peer-group member. */
5102 SET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5103 member
->connect
= connect
;
5104 member
->v_connect
= connect
;
5110 int peer_timers_connect_unset(struct peer
*peer
)
5112 struct peer
*member
;
5113 struct listnode
*node
, *nnode
;
5115 /* Inherit configuration from peer-group if peer is member. */
5116 if (peer_group_active(peer
)) {
5117 peer_flag_inherit(peer
, PEER_FLAG_TIMER_CONNECT
);
5118 PEER_ATTR_INHERIT(peer
, peer
->group
, connect
);
5120 /* Otherwise remove flag and configuration from peer. */
5121 peer_flag_unset(peer
, PEER_FLAG_TIMER_CONNECT
);
5125 /* Set timer with fallback to default value. */
5127 peer
->v_connect
= peer
->connect
;
5129 peer
->v_connect
= peer
->bgp
->default_connect_retry
;
5131 /* Skip peer-group mechanics for regular peers. */
5132 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5136 * Remove flag and configuration from all peer-group members, unless
5137 * they are explicitely overriding peer-group configuration.
5139 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5140 /* Skip peers with overridden configuration. */
5141 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_TIMER_CONNECT
))
5144 /* Remove flag and configuration on peer-group member. */
5145 UNSET_FLAG(member
->flags
, PEER_FLAG_TIMER_CONNECT
);
5146 member
->connect
= 0;
5147 member
->v_connect
= peer
->bgp
->default_connect_retry
;
5153 int peer_advertise_interval_set(struct peer
*peer
, uint32_t routeadv
)
5155 struct peer
*member
;
5156 struct listnode
*node
, *nnode
;
5159 return BGP_ERR_INVALID_VALUE
;
5161 /* Set flag and configuration on peer. */
5162 peer_flag_set(peer
, PEER_FLAG_ROUTEADV
);
5163 peer
->routeadv
= routeadv
;
5164 peer
->v_routeadv
= routeadv
;
5166 /* Check if handling a regular peer. */
5167 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5168 /* Update peer route announcements. */
5169 update_group_adjust_peer_afs(peer
);
5170 if (peer
->status
== Established
)
5171 bgp_announce_route_all(peer
);
5173 /* Skip peer-group mechanics for regular peers. */
5178 * Set flag and configuration on all peer-group members, unless they are
5179 * explicitely overriding peer-group configuration.
5181 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5182 /* Skip peers with overridden configuration. */
5183 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5186 /* Set flag and configuration on peer-group member. */
5187 SET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5188 member
->routeadv
= routeadv
;
5189 member
->v_routeadv
= routeadv
;
5191 /* Update peer route announcements. */
5192 update_group_adjust_peer_afs(member
);
5193 if (member
->status
== Established
)
5194 bgp_announce_route_all(member
);
5200 int peer_advertise_interval_unset(struct peer
*peer
)
5202 struct peer
*member
;
5203 struct listnode
*node
, *nnode
;
5205 /* Inherit configuration from peer-group if peer is member. */
5206 if (peer_group_active(peer
)) {
5207 peer_flag_inherit(peer
, PEER_FLAG_ROUTEADV
);
5208 PEER_ATTR_INHERIT(peer
, peer
->group
, routeadv
);
5210 /* Otherwise remove flag and configuration from peer. */
5211 peer_flag_unset(peer
, PEER_FLAG_ROUTEADV
);
5215 /* Set timer with fallback to default value. */
5217 peer
->v_routeadv
= peer
->routeadv
;
5219 peer
->v_routeadv
= (peer
->sort
== BGP_PEER_IBGP
)
5220 ? BGP_DEFAULT_IBGP_ROUTEADV
5221 : BGP_DEFAULT_EBGP_ROUTEADV
;
5223 /* Check if handling a regular peer. */
5224 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5225 /* Update peer route announcements. */
5226 update_group_adjust_peer_afs(peer
);
5227 if (peer
->status
== Established
)
5228 bgp_announce_route_all(peer
);
5230 /* Skip peer-group mechanics for regular peers. */
5235 * Remove flag and configuration from all peer-group members, unless
5236 * they are explicitely overriding peer-group configuration.
5238 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5239 /* Skip peers with overridden configuration. */
5240 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_ROUTEADV
))
5243 /* Remove flag and configuration on peer-group member. */
5244 UNSET_FLAG(member
->flags
, PEER_FLAG_ROUTEADV
);
5245 member
->routeadv
= 0;
5246 member
->v_routeadv
= (member
->sort
== BGP_PEER_IBGP
)
5247 ? BGP_DEFAULT_IBGP_ROUTEADV
5248 : BGP_DEFAULT_EBGP_ROUTEADV
;
5250 /* Update peer route announcements. */
5251 update_group_adjust_peer_afs(member
);
5252 if (member
->status
== Established
)
5253 bgp_announce_route_all(member
);
5259 /* neighbor interface */
5260 void peer_interface_set(struct peer
*peer
, const char *str
)
5262 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5263 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
5266 void peer_interface_unset(struct peer
*peer
)
5268 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
5272 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5273 int allow_num
, int origin
)
5275 struct peer
*member
;
5276 struct listnode
*node
, *nnode
;
5278 if (!origin
&& (allow_num
< 1 || allow_num
> 10))
5279 return BGP_ERR_INVALID_VALUE
;
5281 /* Set flag and configuration on peer. */
5282 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5284 if (peer
->allowas_in
[afi
][safi
] != 0
5285 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5286 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5287 peer_af_flag_set(peer
, afi
, safi
,
5288 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5289 peer
->allowas_in
[afi
][safi
] = 0;
5290 peer_on_policy_change(peer
, afi
, safi
, 0);
5293 if (peer
->allowas_in
[afi
][safi
] != allow_num
5294 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
5295 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5297 peer_af_flag_unset(peer
, afi
, safi
,
5298 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5299 peer
->allowas_in
[afi
][safi
] = allow_num
;
5300 peer_on_policy_change(peer
, afi
, safi
, 0);
5304 /* Skip peer-group mechanics for regular peers. */
5305 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5309 * Set flag and configuration on all peer-group members, unless
5310 * they are explicitely overriding peer-group configuration.
5312 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5313 /* Skip peers with overridden configuration. */
5314 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5315 PEER_FLAG_ALLOWAS_IN
))
5318 /* Set flag and configuration on peer-group member. */
5319 SET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5321 if (member
->allowas_in
[afi
][safi
] != 0
5322 || !CHECK_FLAG(member
->af_flags
[afi
][safi
],
5323 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5324 SET_FLAG(member
->af_flags
[afi
][safi
],
5325 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5326 member
->allowas_in
[afi
][safi
] = 0;
5327 peer_on_policy_change(peer
, afi
, safi
, 0);
5330 if (member
->allowas_in
[afi
][safi
] != allow_num
5331 || CHECK_FLAG(member
->af_flags
[afi
][safi
],
5332 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
5333 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5334 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5335 member
->allowas_in
[afi
][safi
] = allow_num
;
5336 peer_on_policy_change(peer
, afi
, safi
, 0);
5344 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5346 struct peer
*member
;
5347 struct listnode
*node
, *nnode
;
5349 /* Skip peer if flag is already disabled. */
5350 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
5353 /* Inherit configuration from peer-group if peer is member. */
5354 if (peer_group_active(peer
)) {
5355 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5356 peer_af_flag_inherit(peer
, afi
, safi
,
5357 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5358 PEER_ATTR_INHERIT(peer
, peer
->group
, allowas_in
[afi
][safi
]);
5359 peer_on_policy_change(peer
, afi
, safi
, 0);
5364 /* Remove flag and configuration from peer. */
5365 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5366 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5367 peer
->allowas_in
[afi
][safi
] = 0;
5368 peer_on_policy_change(peer
, afi
, safi
, 0);
5370 /* Skip peer-group mechanics if handling a regular peer. */
5371 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5375 * Remove flags and configuration from all peer-group members, unless
5376 * they are explicitely overriding peer-group configuration.
5378 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5379 /* Skip peers with overridden configuration. */
5380 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
5381 PEER_FLAG_ALLOWAS_IN
))
5384 /* Skip peers where flag is already disabled. */
5385 if (!CHECK_FLAG(member
->af_flags
[afi
][safi
],
5386 PEER_FLAG_ALLOWAS_IN
))
5389 /* Remove flags and configuration on peer-group member. */
5390 UNSET_FLAG(member
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
5391 UNSET_FLAG(member
->af_flags
[afi
][safi
],
5392 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5393 member
->allowas_in
[afi
][safi
] = 0;
5394 peer_on_policy_change(member
, afi
, safi
, 0);
5400 int peer_local_as_set(struct peer
*peer
, as_t as
, int no_prepend
,
5403 bool old_no_prepend
, old_replace_as
;
5404 struct bgp
*bgp
= peer
->bgp
;
5405 struct peer
*member
;
5406 struct listnode
*node
, *nnode
;
5407 bgp_peer_sort_t ptype
= peer_sort(peer
);
5409 if (ptype
!= BGP_PEER_EBGP
&& ptype
!= BGP_PEER_INTERNAL
)
5410 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5413 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5416 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5418 /* Save previous flag states. */
5420 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5422 !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5424 /* Set flag and configuration on peer. */
5425 peer_flag_set(peer
, PEER_FLAG_LOCAL_AS
);
5426 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
, no_prepend
);
5427 peer_flag_modify(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
, replace_as
);
5429 if (peer
->change_local_as
== as
&& old_no_prepend
== no_prepend
5430 && old_replace_as
== replace_as
)
5432 peer
->change_local_as
= as
;
5434 /* Check if handling a regular peer. */
5435 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5436 /* Send notification or reset peer depending on state. */
5437 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5438 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5439 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5440 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5442 bgp_session_reset(peer
);
5444 /* Skip peer-group mechanics for regular peers. */
5449 * Set flag and configuration on all peer-group members, unless they are
5450 * explicitely overriding peer-group configuration.
5452 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5453 /* Skip peers with overridden configuration. */
5454 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
5457 /* Skip peers with the same configuration. */
5458 old_no_prepend
= CHECK_FLAG(member
->flags
,
5459 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5460 old_replace_as
= CHECK_FLAG(member
->flags
,
5461 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5462 if (member
->change_local_as
== as
5463 && CHECK_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
)
5464 && old_no_prepend
== no_prepend
5465 && old_replace_as
== replace_as
)
5468 /* Set flag and configuration on peer-group member. */
5469 SET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
5470 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
,
5472 COND_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
,
5474 member
->change_local_as
= as
;
5476 /* Send notification or stop peer depending on state. */
5477 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5478 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5479 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5480 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5482 BGP_EVENT_ADD(member
, BGP_Stop
);
5488 int peer_local_as_unset(struct peer
*peer
)
5490 struct peer
*member
;
5491 struct listnode
*node
, *nnode
;
5493 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS
))
5496 /* Inherit configuration from peer-group if peer is member. */
5497 if (peer_group_active(peer
)) {
5498 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS
);
5499 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5500 peer_flag_inherit(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5501 PEER_ATTR_INHERIT(peer
, peer
->group
, change_local_as
);
5503 /* Otherwise remove flag and configuration from peer. */
5504 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS
);
5505 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5506 peer_flag_unset(peer
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5507 peer
->change_local_as
= 0;
5510 /* Check if handling a regular peer. */
5511 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5512 /* Send notification or stop peer depending on state. */
5513 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5514 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5515 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5516 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5518 BGP_EVENT_ADD(peer
, BGP_Stop
);
5520 /* Skip peer-group mechanics for regular peers. */
5525 * Remove flag and configuration from all peer-group members, unless
5526 * they are explicitely overriding peer-group configuration.
5528 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5529 /* Skip peers with overridden configuration. */
5530 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_LOCAL_AS
))
5533 /* Remove flag and configuration on peer-group member. */
5534 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS
);
5535 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5536 UNSET_FLAG(member
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5537 member
->change_local_as
= 0;
5539 /* Send notification or stop peer depending on state. */
5540 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
)) {
5541 member
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5542 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5543 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5545 bgp_session_reset(member
);
5551 /* Set password for authenticating with the peer. */
5552 int peer_password_set(struct peer
*peer
, const char *password
)
5554 struct peer
*member
;
5555 struct listnode
*node
, *nnode
;
5556 int len
= password
? strlen(password
) : 0;
5557 int ret
= BGP_SUCCESS
;
5559 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5560 return BGP_ERR_INVALID_VALUE
;
5562 /* Set flag and configuration on peer. */
5563 peer_flag_set(peer
, PEER_FLAG_PASSWORD
);
5564 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
5566 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5567 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5569 /* Check if handling a regular peer. */
5570 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5571 /* Send notification or reset peer depending on state. */
5572 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5573 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5574 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5576 bgp_session_reset(peer
);
5579 * Attempt to install password on socket and skip peer-group
5582 if (BGP_PEER_SU_UNSPEC(peer
))
5584 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
5585 : BGP_ERR_TCPSIG_FAILED
;
5589 * Set flag and configuration on all peer-group members, unless they are
5590 * explicitely overriding peer-group configuration.
5592 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5593 /* Skip peers with overridden configuration. */
5594 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
5597 /* Skip peers with the same password. */
5598 if (member
->password
&& strcmp(member
->password
, password
) == 0)
5601 /* Set flag and configuration on peer-group member. */
5602 SET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
5603 if (member
->password
)
5604 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
5605 member
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5607 /* Send notification or reset peer depending on state. */
5608 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
5609 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5610 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5612 bgp_session_reset(member
);
5614 /* Attempt to install password on socket. */
5615 if (!BGP_PEER_SU_UNSPEC(member
) && bgp_md5_set(member
) < 0)
5616 ret
= BGP_ERR_TCPSIG_FAILED
;
5619 /* Set flag and configuration on all peer-group listen ranges */
5620 struct listnode
*ln
;
5623 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
5624 bgp_md5_set_prefix(lr
, password
);
5625 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
5626 bgp_md5_set_prefix(lr
, password
);
5631 int peer_password_unset(struct peer
*peer
)
5633 struct peer
*member
;
5634 struct listnode
*node
, *nnode
;
5636 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSWORD
))
5639 /* Inherit configuration from peer-group if peer is member. */
5640 if (peer_group_active(peer
)) {
5641 peer_flag_inherit(peer
, PEER_FLAG_PASSWORD
);
5642 PEER_STR_ATTR_INHERIT(peer
, peer
->group
, password
,
5643 MTYPE_PEER_PASSWORD
);
5645 /* Otherwise remove flag and configuration from peer. */
5646 peer_flag_unset(peer
, PEER_FLAG_PASSWORD
);
5647 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5650 /* Check if handling a regular peer. */
5651 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5652 /* Send notification or reset peer depending on state. */
5653 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5654 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5655 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5657 bgp_session_reset(peer
);
5659 /* Attempt to uninstall password on socket. */
5660 if (!BGP_PEER_SU_UNSPEC(peer
))
5661 bgp_md5_unset(peer
);
5663 /* Skip peer-group mechanics for regular peers. */
5668 * Remove flag and configuration from all peer-group members, unless
5669 * they are explicitely overriding peer-group configuration.
5671 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5672 /* Skip peers with overridden configuration. */
5673 if (CHECK_FLAG(member
->flags_override
, PEER_FLAG_PASSWORD
))
5676 /* Remove flag and configuration on peer-group member. */
5677 UNSET_FLAG(member
->flags
, PEER_FLAG_PASSWORD
);
5678 XFREE(MTYPE_PEER_PASSWORD
, member
->password
);
5680 /* Send notification or reset peer depending on state. */
5681 if (BGP_IS_VALID_STATE_FOR_NOTIF(member
->status
))
5682 bgp_notify_send(member
, BGP_NOTIFY_CEASE
,
5683 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5685 bgp_session_reset(member
);
5687 /* Attempt to uninstall password on socket. */
5688 if (!BGP_PEER_SU_UNSPEC(member
))
5689 bgp_md5_unset(member
);
5692 /* Set flag and configuration on all peer-group listen ranges */
5693 struct listnode
*ln
;
5696 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP
], ln
, lr
))
5697 bgp_md5_unset_prefix(lr
);
5698 for (ALL_LIST_ELEMENTS_RO(peer
->group
->listen_range
[AFI_IP6
], ln
, lr
))
5699 bgp_md5_unset_prefix(lr
);
5705 /* Set distribute list to the peer. */
5706 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5709 struct peer
*member
;
5710 struct bgp_filter
*filter
;
5711 struct listnode
*node
, *nnode
;
5713 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5714 return BGP_ERR_INVALID_VALUE
;
5716 /* Set configuration on peer. */
5717 filter
= &peer
->filter
[afi
][safi
];
5718 if (filter
->plist
[direct
].name
)
5719 return BGP_ERR_PEER_FILTER_CONFLICT
;
5720 if (filter
->dlist
[direct
].name
)
5721 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5722 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5723 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5725 /* Check if handling a regular peer. */
5726 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5727 /* Set override-flag and process peer route updates. */
5728 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5729 PEER_FT_DISTRIBUTE_LIST
);
5730 peer_on_policy_change(peer
, afi
, safi
,
5731 (direct
== FILTER_OUT
) ? 1 : 0);
5733 /* Skip peer-group mechanics for regular peers. */
5738 * Set configuration on all peer-group members, un less they are
5739 * explicitely overriding peer-group configuration.
5741 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5742 /* Skip peers with overridden configuration. */
5743 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5744 PEER_FT_DISTRIBUTE_LIST
))
5747 /* Set configuration on peer-group member. */
5748 filter
= &member
->filter
[afi
][safi
];
5749 if (filter
->dlist
[direct
].name
)
5750 XFREE(MTYPE_BGP_FILTER_NAME
,
5751 filter
->dlist
[direct
].name
);
5752 filter
->dlist
[direct
].name
=
5753 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5754 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5756 /* Process peer route updates. */
5757 peer_on_policy_change(member
, afi
, safi
,
5758 (direct
== FILTER_OUT
) ? 1 : 0);
5764 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5766 struct peer
*member
;
5767 struct bgp_filter
*filter
;
5768 struct listnode
*node
, *nnode
;
5770 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5771 return BGP_ERR_INVALID_VALUE
;
5773 /* Unset override-flag unconditionally. */
5774 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5775 PEER_FT_DISTRIBUTE_LIST
);
5777 /* Inherit configuration from peer-group if peer is member. */
5778 if (peer_group_active(peer
)) {
5779 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5780 filter
[afi
][safi
].dlist
[direct
].name
,
5781 MTYPE_BGP_FILTER_NAME
);
5782 PEER_ATTR_INHERIT(peer
, peer
->group
,
5783 filter
[afi
][safi
].dlist
[direct
].alist
);
5785 /* Otherwise remove configuration from peer. */
5786 filter
= &peer
->filter
[afi
][safi
];
5787 if (filter
->dlist
[direct
].name
)
5788 XFREE(MTYPE_BGP_FILTER_NAME
,
5789 filter
->dlist
[direct
].name
);
5790 filter
->dlist
[direct
].name
= NULL
;
5791 filter
->dlist
[direct
].alist
= NULL
;
5794 /* Check if handling a regular peer. */
5795 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5796 /* Process peer route updates. */
5797 peer_on_policy_change(peer
, afi
, safi
,
5798 (direct
== FILTER_OUT
) ? 1 : 0);
5800 /* Skip peer-group mechanics for regular peers. */
5805 * Remove configuration on all peer-group members, unless they are
5806 * explicitely overriding peer-group configuration.
5808 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5809 /* Skip peers with overridden configuration. */
5810 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5811 PEER_FT_DISTRIBUTE_LIST
))
5814 /* Remove configuration on peer-group member. */
5815 filter
= &member
->filter
[afi
][safi
];
5816 if (filter
->dlist
[direct
].name
)
5817 XFREE(MTYPE_BGP_FILTER_NAME
,
5818 filter
->dlist
[direct
].name
);
5819 filter
->dlist
[direct
].name
= NULL
;
5820 filter
->dlist
[direct
].alist
= NULL
;
5822 /* Process peer route updates. */
5823 peer_on_policy_change(member
, afi
, safi
,
5824 (direct
== FILTER_OUT
) ? 1 : 0);
5830 /* Update distribute list. */
5831 static void peer_distribute_update(struct access_list
*access
)
5836 struct listnode
*mnode
, *mnnode
;
5837 struct listnode
*node
, *nnode
;
5840 struct peer_group
*group
;
5841 struct bgp_filter
*filter
;
5843 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5845 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
5846 access
->name
, 0, 0);
5847 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5848 FOREACH_AFI_SAFI (afi
, safi
) {
5849 filter
= &peer
->filter
[afi
][safi
];
5851 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5853 if (filter
->dlist
[direct
].name
)
5854 filter
->dlist
[direct
]
5855 .alist
= access_list_lookup(
5857 filter
->dlist
[direct
]
5860 filter
->dlist
[direct
].alist
=
5865 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5866 FOREACH_AFI_SAFI (afi
, safi
) {
5867 filter
= &group
->conf
->filter
[afi
][safi
];
5869 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5871 if (filter
->dlist
[direct
].name
)
5872 filter
->dlist
[direct
]
5873 .alist
= access_list_lookup(
5875 filter
->dlist
[direct
]
5878 filter
->dlist
[direct
].alist
=
5883 #ifdef ENABLE_BGP_VNC
5884 vnc_prefix_list_update(bgp
);
5889 /* Set prefix list to the peer. */
5890 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5893 struct peer
*member
;
5894 struct bgp_filter
*filter
;
5895 struct listnode
*node
, *nnode
;
5897 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5898 return BGP_ERR_INVALID_VALUE
;
5900 /* Set configuration on peer. */
5901 filter
= &peer
->filter
[afi
][safi
];
5902 if (filter
->dlist
[direct
].name
)
5903 return BGP_ERR_PEER_FILTER_CONFLICT
;
5904 if (filter
->plist
[direct
].name
)
5905 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5906 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5907 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5909 /* Check if handling a regular peer. */
5910 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5911 /* Set override-flag and process peer route updates. */
5912 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5913 PEER_FT_PREFIX_LIST
);
5914 peer_on_policy_change(peer
, afi
, safi
,
5915 (direct
== FILTER_OUT
) ? 1 : 0);
5917 /* Skip peer-group mechanics for regular peers. */
5922 * Set configuration on all peer-group members, unless they are
5923 * explicitely overriding peer-group configuration.
5925 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5926 /* Skip peers with overridden configuration. */
5927 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5928 PEER_FT_PREFIX_LIST
))
5931 /* Set configuration on peer-group member. */
5932 filter
= &member
->filter
[afi
][safi
];
5933 if (filter
->plist
[direct
].name
)
5934 XFREE(MTYPE_BGP_FILTER_NAME
,
5935 filter
->plist
[direct
].name
);
5936 filter
->plist
[direct
].name
=
5937 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5938 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5940 /* Process peer route updates. */
5941 peer_on_policy_change(member
, afi
, safi
,
5942 (direct
== FILTER_OUT
) ? 1 : 0);
5948 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
5951 struct peer
*member
;
5952 struct bgp_filter
*filter
;
5953 struct listnode
*node
, *nnode
;
5955 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5956 return BGP_ERR_INVALID_VALUE
;
5958 /* Unset override-flag unconditionally. */
5959 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
5960 PEER_FT_PREFIX_LIST
);
5962 /* Inherit configuration from peer-group if peer is member. */
5963 if (peer_group_active(peer
)) {
5964 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
5965 filter
[afi
][safi
].plist
[direct
].name
,
5966 MTYPE_BGP_FILTER_NAME
);
5967 PEER_ATTR_INHERIT(peer
, peer
->group
,
5968 filter
[afi
][safi
].plist
[direct
].plist
);
5970 /* Otherwise remove configuration from peer. */
5971 filter
= &peer
->filter
[afi
][safi
];
5972 if (filter
->plist
[direct
].name
)
5973 XFREE(MTYPE_BGP_FILTER_NAME
,
5974 filter
->plist
[direct
].name
);
5975 filter
->plist
[direct
].name
= NULL
;
5976 filter
->plist
[direct
].plist
= NULL
;
5979 /* Check if handling a regular peer. */
5980 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5981 /* Process peer route updates. */
5982 peer_on_policy_change(peer
, afi
, safi
,
5983 (direct
== FILTER_OUT
) ? 1 : 0);
5985 /* Skip peer-group mechanics for regular peers. */
5990 * Remove configuration on all peer-group members, unless they are
5991 * explicitely overriding peer-group configuration.
5993 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
5994 /* Skip peers with overridden configuration. */
5995 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
5996 PEER_FT_PREFIX_LIST
))
5999 /* Remove configuration on peer-group member. */
6000 filter
= &member
->filter
[afi
][safi
];
6001 if (filter
->plist
[direct
].name
)
6002 XFREE(MTYPE_BGP_FILTER_NAME
,
6003 filter
->plist
[direct
].name
);
6004 filter
->plist
[direct
].name
= NULL
;
6005 filter
->plist
[direct
].plist
= NULL
;
6007 /* Process peer route updates. */
6008 peer_on_policy_change(member
, afi
, safi
,
6009 (direct
== FILTER_OUT
) ? 1 : 0);
6015 /* Update prefix-list list. */
6016 static void peer_prefix_list_update(struct prefix_list
*plist
)
6018 struct listnode
*mnode
, *mnnode
;
6019 struct listnode
*node
, *nnode
;
6022 struct peer_group
*group
;
6023 struct bgp_filter
*filter
;
6028 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6031 * Update the prefix-list on update groups.
6033 update_group_policy_update(
6034 bgp
, BGP_POLICY_PREFIX_LIST
,
6035 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
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
->plist
[direct
].name
)
6044 filter
->plist
[direct
]
6045 .plist
= prefix_list_lookup(
6047 filter
->plist
[direct
]
6050 filter
->plist
[direct
].plist
=
6055 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6056 FOREACH_AFI_SAFI (afi
, safi
) {
6057 filter
= &group
->conf
->filter
[afi
][safi
];
6059 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6061 if (filter
->plist
[direct
].name
)
6062 filter
->plist
[direct
]
6063 .plist
= prefix_list_lookup(
6065 filter
->plist
[direct
]
6068 filter
->plist
[direct
].plist
=
6076 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6079 struct peer
*member
;
6080 struct bgp_filter
*filter
;
6081 struct listnode
*node
, *nnode
;
6083 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6084 return BGP_ERR_INVALID_VALUE
;
6086 /* Set configuration on peer. */
6087 filter
= &peer
->filter
[afi
][safi
];
6088 if (filter
->aslist
[direct
].name
)
6089 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
6090 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6091 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6093 /* Check if handling a regular peer. */
6094 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6095 /* Set override-flag and process peer route updates. */
6096 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6097 PEER_FT_FILTER_LIST
);
6098 peer_on_policy_change(peer
, afi
, safi
,
6099 (direct
== FILTER_OUT
) ? 1 : 0);
6101 /* Skip peer-group mechanics for regular peers. */
6106 * Set configuration on all peer-group members, unless they are
6107 * explicitely overriding peer-group configuration.
6109 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6110 /* Skip peers with overridden configuration. */
6111 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6112 PEER_FT_FILTER_LIST
))
6115 /* Set configuration on peer-group member. */
6116 filter
= &member
->filter
[afi
][safi
];
6117 if (filter
->aslist
[direct
].name
)
6118 XFREE(MTYPE_BGP_FILTER_NAME
,
6119 filter
->aslist
[direct
].name
);
6120 filter
->aslist
[direct
].name
=
6121 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6122 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
6124 /* Process peer route updates. */
6125 peer_on_policy_change(member
, afi
, safi
,
6126 (direct
== FILTER_OUT
) ? 1 : 0);
6132 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6134 struct peer
*member
;
6135 struct bgp_filter
*filter
;
6136 struct listnode
*node
, *nnode
;
6138 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
6139 return BGP_ERR_INVALID_VALUE
;
6141 /* Unset override-flag unconditionally. */
6142 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6143 PEER_FT_FILTER_LIST
);
6145 /* Inherit configuration from peer-group if peer is member. */
6146 if (peer_group_active(peer
)) {
6147 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6148 filter
[afi
][safi
].aslist
[direct
].name
,
6149 MTYPE_BGP_FILTER_NAME
);
6150 PEER_ATTR_INHERIT(peer
, peer
->group
,
6151 filter
[afi
][safi
].aslist
[direct
].aslist
);
6153 /* Otherwise remove configuration from peer. */
6154 filter
= &peer
->filter
[afi
][safi
];
6155 if (filter
->aslist
[direct
].name
)
6156 XFREE(MTYPE_BGP_FILTER_NAME
,
6157 filter
->aslist
[direct
].name
);
6158 filter
->aslist
[direct
].name
= NULL
;
6159 filter
->aslist
[direct
].aslist
= NULL
;
6162 /* Check if handling a regular peer. */
6163 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6164 /* Process peer route updates. */
6165 peer_on_policy_change(peer
, afi
, safi
,
6166 (direct
== FILTER_OUT
) ? 1 : 0);
6168 /* Skip peer-group mechanics for regular peers. */
6173 * Remove configuration on all peer-group members, unless they are
6174 * explicitely overriding peer-group configuration.
6176 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6177 /* Skip peers with overridden configuration. */
6178 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6179 PEER_FT_FILTER_LIST
))
6182 /* Remove configuration on peer-group member. */
6183 filter
= &member
->filter
[afi
][safi
];
6184 if (filter
->aslist
[direct
].name
)
6185 XFREE(MTYPE_BGP_FILTER_NAME
,
6186 filter
->aslist
[direct
].name
);
6187 filter
->aslist
[direct
].name
= NULL
;
6188 filter
->aslist
[direct
].aslist
= NULL
;
6190 /* Process peer route updates. */
6191 peer_on_policy_change(member
, afi
, safi
,
6192 (direct
== FILTER_OUT
) ? 1 : 0);
6198 static void peer_aslist_update(const char *aslist_name
)
6203 struct listnode
*mnode
, *mnnode
;
6204 struct listnode
*node
, *nnode
;
6207 struct peer_group
*group
;
6208 struct bgp_filter
*filter
;
6210 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
6211 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
6214 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
6215 FOREACH_AFI_SAFI (afi
, safi
) {
6216 filter
= &peer
->filter
[afi
][safi
];
6218 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6220 if (filter
->aslist
[direct
].name
)
6221 filter
->aslist
[direct
]
6222 .aslist
= as_list_lookup(
6223 filter
->aslist
[direct
]
6226 filter
->aslist
[direct
].aslist
=
6231 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
6232 FOREACH_AFI_SAFI (afi
, safi
) {
6233 filter
= &group
->conf
->filter
[afi
][safi
];
6235 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
6237 if (filter
->aslist
[direct
].name
)
6238 filter
->aslist
[direct
]
6239 .aslist
= as_list_lookup(
6240 filter
->aslist
[direct
]
6243 filter
->aslist
[direct
].aslist
=
6251 static void peer_aslist_add(char *aslist_name
)
6253 peer_aslist_update(aslist_name
);
6254 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
6257 static void peer_aslist_del(const char *aslist_name
)
6259 peer_aslist_update(aslist_name
);
6260 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
6264 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
6265 const char *name
, struct route_map
*route_map
)
6267 struct peer
*member
;
6268 struct bgp_filter
*filter
;
6269 struct listnode
*node
, *nnode
;
6271 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6272 return BGP_ERR_INVALID_VALUE
;
6274 /* Set configuration on peer. */
6275 filter
= &peer
->filter
[afi
][safi
];
6276 if (filter
->map
[direct
].name
) {
6277 /* If the neighbor is configured with the same route-map
6278 * again then, ignore the duplicate configuration.
6280 if (strcmp(filter
->map
[direct
].name
, name
) == 0)
6283 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6285 route_map_counter_decrement(filter
->map
[direct
].map
);
6286 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6287 filter
->map
[direct
].map
= route_map
;
6288 route_map_counter_increment(route_map
);
6290 /* Check if handling a regular peer. */
6291 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6292 /* Set override-flag and process peer route updates. */
6293 SET_FLAG(peer
->filter_override
[afi
][safi
][direct
],
6295 peer_on_policy_change(peer
, afi
, safi
,
6296 (direct
== RMAP_OUT
) ? 1 : 0);
6298 /* Skip peer-group mechanics for regular peers. */
6303 * Set configuration on all peer-group members, unless they are
6304 * explicitely overriding peer-group configuration.
6306 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6307 /* Skip peers with overridden configuration. */
6308 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6312 /* Set configuration on peer-group member. */
6313 filter
= &member
->filter
[afi
][safi
];
6314 if (filter
->map
[direct
].name
)
6315 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6316 route_map_counter_decrement(filter
->map
[direct
].map
);
6317 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6318 filter
->map
[direct
].map
= route_map
;
6319 route_map_counter_increment(route_map
);
6321 /* Process peer route updates. */
6322 peer_on_policy_change(member
, afi
, safi
,
6323 (direct
== RMAP_OUT
) ? 1 : 0);
6328 /* Unset route-map from the peer. */
6329 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
6331 struct peer
*member
;
6332 struct bgp_filter
*filter
;
6333 struct listnode
*node
, *nnode
;
6335 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
6336 return BGP_ERR_INVALID_VALUE
;
6338 /* Unset override-flag unconditionally. */
6339 UNSET_FLAG(peer
->filter_override
[afi
][safi
][direct
], PEER_FT_ROUTE_MAP
);
6341 /* Inherit configuration from peer-group if peer is member. */
6342 if (peer_group_active(peer
)) {
6343 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6344 filter
[afi
][safi
].map
[direct
].name
,
6345 MTYPE_BGP_FILTER_NAME
);
6346 PEER_ATTR_INHERIT(peer
, peer
->group
,
6347 filter
[afi
][safi
].map
[direct
].map
);
6349 /* Otherwise remove configuration from peer. */
6350 filter
= &peer
->filter
[afi
][safi
];
6351 if (filter
->map
[direct
].name
)
6352 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6353 route_map_counter_decrement(filter
->map
[direct
].map
);
6354 filter
->map
[direct
].name
= NULL
;
6355 filter
->map
[direct
].map
= NULL
;
6358 /* Check if handling a regular peer. */
6359 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6360 /* Process peer route updates. */
6361 peer_on_policy_change(peer
, afi
, safi
,
6362 (direct
== RMAP_OUT
) ? 1 : 0);
6364 /* Skip peer-group mechanics for regular peers. */
6369 * Remove configuration on all peer-group members, unless they are
6370 * explicitely overriding peer-group configuration.
6372 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6373 /* Skip peers with overridden configuration. */
6374 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][direct
],
6378 /* Remove configuration on peer-group member. */
6379 filter
= &member
->filter
[afi
][safi
];
6380 if (filter
->map
[direct
].name
)
6381 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
6382 route_map_counter_decrement(filter
->map
[direct
].map
);
6383 filter
->map
[direct
].name
= NULL
;
6384 filter
->map
[direct
].map
= NULL
;
6386 /* Process peer route updates. */
6387 peer_on_policy_change(member
, afi
, safi
,
6388 (direct
== RMAP_OUT
) ? 1 : 0);
6394 /* Set unsuppress-map to the peer. */
6395 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6396 const char *name
, struct route_map
*route_map
)
6398 struct peer
*member
;
6399 struct bgp_filter
*filter
;
6400 struct listnode
*node
, *nnode
;
6402 /* Set configuration on peer. */
6403 filter
= &peer
->filter
[afi
][safi
];
6404 if (filter
->usmap
.name
)
6405 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6406 route_map_counter_decrement(filter
->usmap
.map
);
6407 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6408 filter
->usmap
.map
= route_map
;
6409 route_map_counter_increment(route_map
);
6411 /* Check if handling a regular peer. */
6412 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6413 /* Set override-flag and process peer route updates. */
6414 SET_FLAG(peer
->filter_override
[afi
][safi
][0],
6415 PEER_FT_UNSUPPRESS_MAP
);
6416 peer_on_policy_change(peer
, afi
, safi
, 1);
6418 /* Skip peer-group mechanics for regular peers. */
6423 * Set configuration on all peer-group members, unless they are
6424 * explicitely overriding peer-group configuration.
6426 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6427 /* Skip peers with overridden configuration. */
6428 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6429 PEER_FT_UNSUPPRESS_MAP
))
6432 /* Set configuration on peer-group member. */
6433 filter
= &member
->filter
[afi
][safi
];
6434 if (filter
->usmap
.name
)
6435 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6436 route_map_counter_decrement(filter
->usmap
.map
);
6437 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
6438 filter
->usmap
.map
= route_map
;
6439 route_map_counter_increment(route_map
);
6441 /* Process peer route updates. */
6442 peer_on_policy_change(member
, afi
, safi
, 1);
6448 /* Unset route-map from the peer. */
6449 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6451 struct peer
*member
;
6452 struct bgp_filter
*filter
;
6453 struct listnode
*node
, *nnode
;
6455 /* Unset override-flag unconditionally. */
6456 UNSET_FLAG(peer
->filter_override
[afi
][safi
][0], PEER_FT_UNSUPPRESS_MAP
);
6458 /* Inherit configuration from peer-group if peer is member. */
6459 if (peer_group_active(peer
)) {
6460 PEER_STR_ATTR_INHERIT(peer
, peer
->group
,
6461 filter
[afi
][safi
].usmap
.name
,
6462 MTYPE_BGP_FILTER_NAME
);
6463 PEER_ATTR_INHERIT(peer
, peer
->group
,
6464 filter
[afi
][safi
].usmap
.map
);
6466 /* Otherwise remove configuration from peer. */
6467 filter
= &peer
->filter
[afi
][safi
];
6468 if (filter
->usmap
.name
)
6469 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6470 route_map_counter_decrement(filter
->usmap
.map
);
6471 filter
->usmap
.name
= NULL
;
6472 filter
->usmap
.map
= NULL
;
6475 /* Check if handling a regular peer. */
6476 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6477 /* Process peer route updates. */
6478 peer_on_policy_change(peer
, afi
, safi
, 1);
6480 /* Skip peer-group mechanics for regular peers. */
6485 * Remove configuration on all peer-group members, unless they are
6486 * explicitely overriding peer-group configuration.
6488 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6489 /* Skip peers with overridden configuration. */
6490 if (CHECK_FLAG(member
->filter_override
[afi
][safi
][0],
6491 PEER_FT_UNSUPPRESS_MAP
))
6494 /* Remove configuration on peer-group member. */
6495 filter
= &member
->filter
[afi
][safi
];
6496 if (filter
->usmap
.name
)
6497 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
6498 route_map_counter_decrement(filter
->usmap
.map
);
6499 filter
->usmap
.name
= NULL
;
6500 filter
->usmap
.map
= NULL
;
6502 /* Process peer route updates. */
6503 peer_on_policy_change(member
, afi
, safi
, 1);
6509 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
6510 uint32_t max
, uint8_t threshold
, int warning
,
6511 uint16_t restart
, bool force
)
6513 struct peer
*member
;
6514 struct listnode
*node
, *nnode
;
6516 /* Set flags and configuration on peer. */
6517 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6520 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
6522 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
6525 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6527 peer_af_flag_unset(peer
, afi
, safi
,
6528 PEER_FLAG_MAX_PREFIX_WARNING
);
6530 peer
->pmax
[afi
][safi
] = max
;
6531 peer
->pmax_threshold
[afi
][safi
] = threshold
;
6532 peer
->pmax_restart
[afi
][safi
] = restart
;
6534 /* Check if handling a regular peer. */
6535 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6536 /* Re-check if peer violates maximum-prefix. */
6537 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6538 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
6540 /* Skip peer-group mechanics for regular peers. */
6545 * Set flags and configuration on all peer-group members, unless they
6546 * are explicitely overriding peer-group configuration.
6548 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, node
, nnode
, member
)) {
6549 /* Skip peers with overridden configuration. */
6550 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6551 PEER_FLAG_MAX_PREFIX
))
6554 /* Set flag and configuration on peer-group member. */
6555 member
->pmax
[afi
][safi
] = max
;
6556 member
->pmax_threshold
[afi
][safi
] = threshold
;
6557 member
->pmax_restart
[afi
][safi
] = restart
;
6560 SET_FLAG(member
->af_flags
[afi
][safi
],
6561 PEER_FLAG_MAX_PREFIX_FORCE
);
6563 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6564 PEER_FLAG_MAX_PREFIX_FORCE
);
6567 SET_FLAG(member
->af_flags
[afi
][safi
],
6568 PEER_FLAG_MAX_PREFIX_WARNING
);
6570 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6571 PEER_FLAG_MAX_PREFIX_WARNING
);
6573 /* Re-check if peer violates maximum-prefix. */
6574 if ((member
->status
== Established
) && (member
->afc
[afi
][safi
]))
6575 bgp_maximum_prefix_overflow(member
, afi
, safi
, 1);
6581 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
6583 /* Inherit configuration from peer-group if peer is member. */
6584 if (peer_group_active(peer
)) {
6585 peer_af_flag_inherit(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6586 peer_af_flag_inherit(peer
, afi
, safi
,
6587 PEER_FLAG_MAX_PREFIX_FORCE
);
6588 peer_af_flag_inherit(peer
, afi
, safi
,
6589 PEER_FLAG_MAX_PREFIX_WARNING
);
6590 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax
[afi
][safi
]);
6591 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_threshold
[afi
][safi
]);
6592 PEER_ATTR_INHERIT(peer
, peer
->group
, pmax_restart
[afi
][safi
]);
6597 /* Remove flags and configuration from peer. */
6598 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX
);
6599 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_FORCE
);
6600 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_MAX_PREFIX_WARNING
);
6601 peer
->pmax
[afi
][safi
] = 0;
6602 peer
->pmax_threshold
[afi
][safi
] = 0;
6603 peer
->pmax_restart
[afi
][safi
] = 0;
6606 * Remove flags and configuration from all peer-group members, unless
6607 * they are explicitely overriding peer-group configuration.
6609 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6610 struct peer
*member
;
6611 struct listnode
*node
;
6613 for (ALL_LIST_ELEMENTS_RO(peer
->group
->peer
, node
, member
)) {
6614 /* Skip peers with overridden configuration. */
6615 if (CHECK_FLAG(member
->af_flags_override
[afi
][safi
],
6616 PEER_FLAG_MAX_PREFIX
))
6619 /* Remove flag and configuration on peer-group member.
6621 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6622 PEER_FLAG_MAX_PREFIX
);
6623 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6624 PEER_FLAG_MAX_PREFIX_FORCE
);
6625 UNSET_FLAG(member
->af_flags
[afi
][safi
],
6626 PEER_FLAG_MAX_PREFIX_WARNING
);
6627 member
->pmax
[afi
][safi
] = 0;
6628 member
->pmax_threshold
[afi
][safi
] = 0;
6629 member
->pmax_restart
[afi
][safi
] = 0;
6636 int is_ebgp_multihop_configured(struct peer
*peer
)
6638 struct peer_group
*group
;
6639 struct listnode
*node
, *nnode
;
6642 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6643 group
= peer
->group
;
6644 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
6645 && (group
->conf
->ttl
!= BGP_DEFAULT_TTL
))
6648 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
6649 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
6650 && (peer1
->ttl
!= BGP_DEFAULT_TTL
))
6654 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
6655 && (peer
->ttl
!= BGP_DEFAULT_TTL
))
6661 /* Set # of hops between us and BGP peer. */
6662 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
6664 struct peer_group
*group
;
6665 struct listnode
*node
, *nnode
;
6668 zlog_debug("peer_ttl_security_hops_set: set gtsm_hops to %d for %s",
6669 gtsm_hops
, peer
->host
);
6671 /* We cannot configure ttl-security hops when ebgp-multihop is already
6672 set. For non peer-groups, the check is simple. For peer-groups,
6674 slightly messy, because we need to check both the peer-group
6676 and all peer-group members for any trace of ebgp-multihop
6678 before actually applying the ttl-security rules. Cisco really made a
6679 mess of this configuration parameter, and OpenBGPD got it right.
6682 if ((peer
->gtsm_hops
== BGP_GTSM_HOPS_DISABLED
)
6683 && (peer
->sort
!= BGP_PEER_IBGP
)) {
6684 if (is_ebgp_multihop_configured(peer
))
6685 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6687 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6688 peer
->gtsm_hops
= gtsm_hops
;
6690 /* Calling ebgp multihop also resets the session.
6691 * On restart, NHT will get setup correctly as will the
6692 * min & max ttls on the socket. The return value is
6695 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
6700 group
= peer
->group
;
6701 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6703 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6705 /* Calling ebgp multihop also resets the
6707 * On restart, NHT will get setup correctly as
6709 * min & max ttls on the socket. The return
6713 peer_ebgp_multihop_set(peer
, MAXTTL
);
6717 /* Post the first gtsm setup or if its ibgp, maxttl setting
6719 * necessary, just set the minttl.
6721 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6722 peer
->gtsm_hops
= gtsm_hops
;
6725 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6726 MAXTTL
+ 1 - gtsm_hops
);
6727 if ((peer
->status
< Established
) && peer
->doppelganger
6728 && (peer
->doppelganger
->fd
>= 0))
6729 sockopt_minttl(peer
->su
.sa
.sa_family
,
6730 peer
->doppelganger
->fd
,
6731 MAXTTL
+ 1 - gtsm_hops
);
6733 group
= peer
->group
;
6734 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6736 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6738 /* Change setting of existing peer
6739 * established then change value (may break
6741 * not established yet (teardown session and
6743 * no session then do nothing (will get
6744 * handled by next connection)
6748 != BGP_GTSM_HOPS_DISABLED
)
6750 peer
->su
.sa
.sa_family
, peer
->fd
,
6751 MAXTTL
+ 1 - peer
->gtsm_hops
);
6752 if ((peer
->status
< Established
)
6753 && peer
->doppelganger
6754 && (peer
->doppelganger
->fd
>= 0))
6755 sockopt_minttl(peer
->su
.sa
.sa_family
,
6756 peer
->doppelganger
->fd
,
6757 MAXTTL
+ 1 - gtsm_hops
);
6765 int peer_ttl_security_hops_unset(struct peer
*peer
)
6767 struct peer_group
*group
;
6768 struct listnode
*node
, *nnode
;
6771 zlog_debug("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s",
6774 /* if a peer-group member, then reset to peer-group default rather than
6776 if (peer_group_active(peer
))
6777 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6779 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
6781 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6782 /* Invoking ebgp_multihop_set will set the TTL back to the
6784 * value as well as restting the NHT and such. The session is
6787 if (peer
->sort
== BGP_PEER_EBGP
)
6788 ret
= peer_ebgp_multihop_unset(peer
);
6791 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6794 if ((peer
->status
< Established
) && peer
->doppelganger
6795 && (peer
->doppelganger
->fd
>= 0))
6796 sockopt_minttl(peer
->su
.sa
.sa_family
,
6797 peer
->doppelganger
->fd
, 0);
6800 group
= peer
->group
;
6801 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
6802 peer
->gtsm_hops
= BGP_GTSM_HOPS_DISABLED
;
6803 if (peer
->sort
== BGP_PEER_EBGP
)
6804 ret
= peer_ebgp_multihop_unset(peer
);
6807 sockopt_minttl(peer
->su
.sa
.sa_family
,
6810 if ((peer
->status
< Established
)
6811 && peer
->doppelganger
6812 && (peer
->doppelganger
->fd
>= 0))
6813 sockopt_minttl(peer
->su
.sa
.sa_family
,
6814 peer
->doppelganger
->fd
,
6824 * If peer clear is invoked in a loop for all peers on the BGP instance,
6825 * it may end up freeing the doppelganger, and if this was the next node
6826 * to the current node, we would end up accessing the freed next node.
6827 * Pass along additional parameter which can be updated if next node
6828 * is freed; only required when walking the peer list on BGP instance.
6830 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
6832 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)
6833 || !CHECK_FLAG(peer
->bgp
->flags
, BGP_FLAG_SHUTDOWN
)) {
6834 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
)) {
6835 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6836 if (peer
->t_pmax_restart
) {
6837 BGP_TIMER_OFF(peer
->t_pmax_restart
);
6838 if (bgp_debug_neighbor_events(peer
))
6840 "%s Maximum-prefix restart timer canceled",
6843 BGP_EVENT_ADD(peer
, BGP_Start
);
6847 peer
->v_start
= BGP_INIT_START_TIMER
;
6848 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6849 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6850 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6852 bgp_session_reset_safe(peer
, nnode
);
6857 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
6858 enum bgp_clear_type stype
)
6860 struct peer_af
*paf
;
6862 if (peer
->status
!= Established
)
6865 if (!peer
->afc
[afi
][safi
])
6866 return BGP_ERR_AF_UNCONFIGURED
;
6868 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
6870 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
6871 /* Clear the "neighbor x.x.x.x default-originate" flag */
6872 paf
= peer_af_find(peer
, afi
, safi
);
6873 if (paf
&& paf
->subgroup
6874 && CHECK_FLAG(paf
->subgroup
->sflags
,
6875 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6876 UNSET_FLAG(paf
->subgroup
->sflags
,
6877 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6879 bgp_announce_route(peer
, afi
, safi
);
6882 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6883 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6884 PEER_CAP_ORF_PREFIX_SM_ADV
)
6885 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6886 PEER_CAP_ORF_PREFIX_RM_RCV
)
6887 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6888 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
6889 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6890 uint8_t prefix_type
;
6892 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6893 PEER_CAP_ORF_PREFIX_RM_RCV
))
6894 prefix_type
= ORF_TYPE_PREFIX
;
6896 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6898 if (filter
->plist
[FILTER_IN
].plist
) {
6899 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6900 PEER_STATUS_ORF_PREFIX_SEND
))
6901 bgp_route_refresh_send(
6902 peer
, afi
, safi
, prefix_type
,
6904 bgp_route_refresh_send(peer
, afi
, safi
,
6906 REFRESH_IMMEDIATE
, 0);
6908 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6909 PEER_STATUS_ORF_PREFIX_SEND
))
6910 bgp_route_refresh_send(
6911 peer
, afi
, safi
, prefix_type
,
6912 REFRESH_IMMEDIATE
, 1);
6914 bgp_route_refresh_send(peer
, afi
, safi
,
6921 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6922 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6923 /* If neighbor has soft reconfiguration inbound flag.
6924 Use Adj-RIB-In database. */
6925 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6926 PEER_FLAG_SOFT_RECONFIG
))
6927 bgp_soft_reconfig_in(peer
, afi
, safi
);
6929 /* If neighbor has route refresh capability, send route
6931 message to the peer. */
6932 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6933 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6934 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0,
6937 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6943 /* Display peer uptime.*/
6944 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, bool use_json
,
6947 time_t uptime1
, epoch_tbuf
;
6950 /* If there is no connection has been done before print `never'. */
6953 json_object_string_add(json
, "peerUptime", "never");
6954 json_object_int_add(json
, "peerUptimeMsec", 0);
6956 snprintf(buf
, len
, "never");
6960 /* Get current time. */
6961 uptime1
= bgp_clock();
6963 gmtime_r(&uptime1
, &tm
);
6965 if (uptime1
< ONE_DAY_SECOND
)
6966 snprintf(buf
, len
, "%02d:%02d:%02d", tm
.tm_hour
, tm
.tm_min
,
6968 else if (uptime1
< ONE_WEEK_SECOND
)
6969 snprintf(buf
, len
, "%dd%02dh%02dm", tm
.tm_yday
, tm
.tm_hour
,
6971 else if (uptime1
< ONE_YEAR_SECOND
)
6972 snprintf(buf
, len
, "%02dw%dd%02dh", tm
.tm_yday
/ 7,
6973 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7), tm
.tm_hour
);
6975 snprintf(buf
, len
, "%02dy%02dw%dd", tm
.tm_year
- 70,
6977 tm
.tm_yday
- ((tm
.tm_yday
/ 7) * 7));
6980 epoch_tbuf
= time(NULL
) - uptime1
;
6981 json_object_string_add(json
, "peerUptime", buf
);
6982 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
6983 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
6990 void bgp_master_init(struct thread_master
*master
, const int buffer_size
)
6994 memset(&bgp_master
, 0, sizeof(struct bgp_master
));
6997 bm
->bgp
= list_new();
6998 bm
->listen_sockets
= list_new();
6999 bm
->port
= BGP_PORT_DEFAULT
;
7000 bm
->master
= master
;
7001 bm
->start_time
= bgp_clock();
7002 bm
->t_rmap_update
= NULL
;
7003 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7004 bm
->terminating
= false;
7005 bm
->socket_buffer
= buffer_size
;
7007 bgp_process_queue_init();
7010 /* init the rd id space.
7011 assign 0th index in the bitfield,
7012 so that we start with id 1
7014 bf_init(bm
->rd_idspace
, UINT16_MAX
);
7015 bf_assign_zero_index(bm
->rd_idspace
);
7017 /* mpls label dynamic allocation pool */
7018 bgp_lp_init(bm
->master
, &bm
->labelpool
);
7021 QOBJ_REG(bm
, bgp_master
);
7025 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7026 * instance delete (non-default only) or BGP exit.
7028 static void bgp_if_finish(struct bgp
*bgp
)
7031 struct interface
*ifp
;
7033 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
7035 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
7038 FOR_ALL_INTERFACES (vrf
, ifp
) {
7039 struct listnode
*c_node
, *c_nnode
;
7040 struct connected
*c
;
7042 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
7043 bgp_connected_delete(bgp
, c
);
7047 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
7049 struct vrf
*vrf
= NULL
;
7050 struct listnode
*next
;
7053 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
7054 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
7056 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
7057 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
7060 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
7064 static void bgp_instasn_autocomplete(vector comps
, struct cmd_token
*token
)
7066 struct listnode
*next
, *next2
;
7067 struct bgp
*bgp
, *bgp2
;
7070 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
7072 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next2
, bgp2
)) {
7073 if (bgp2
->as
== bgp
->as
)
7081 snprintf(buf
, sizeof(buf
), "%u", bgp
->as
);
7082 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, buf
));
7086 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
7087 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
7088 {.varname
= "instasn", .completions
= bgp_instasn_autocomplete
},
7089 {.completions
= NULL
},
7092 struct frr_pthread
*bgp_pth_io
;
7093 struct frr_pthread
*bgp_pth_ka
;
7095 static void bgp_pthreads_init(void)
7097 assert(!bgp_pth_io
);
7098 assert(!bgp_pth_ka
);
7100 struct frr_pthread_attr io
= {
7101 .start
= frr_pthread_attr_default
.start
,
7102 .stop
= frr_pthread_attr_default
.stop
,
7104 struct frr_pthread_attr ka
= {
7105 .start
= bgp_keepalives_start
,
7106 .stop
= bgp_keepalives_stop
,
7108 bgp_pth_io
= frr_pthread_new(&io
, "BGP I/O thread", "bgpd_io");
7109 bgp_pth_ka
= frr_pthread_new(&ka
, "BGP Keepalives thread", "bgpd_ka");
7112 void bgp_pthreads_run(void)
7114 frr_pthread_run(bgp_pth_io
, NULL
);
7115 frr_pthread_run(bgp_pth_ka
, NULL
);
7117 /* Wait until threads are ready. */
7118 frr_pthread_wait_running(bgp_pth_io
);
7119 frr_pthread_wait_running(bgp_pth_ka
);
7122 void bgp_pthreads_finish(void)
7124 frr_pthread_stop_all();
7127 void bgp_init(unsigned short instance
)
7130 /* allocates some vital data structures used by peer commands in
7133 /* pre-init pthreads */
7134 bgp_pthreads_init();
7137 bgp_zebra_init(bm
->master
, instance
);
7139 #ifdef ENABLE_BGP_VNC
7140 vnc_zebra_init(bm
->master
);
7143 /* BGP VTY commands installation. */
7151 bgp_route_map_init();
7152 bgp_scan_vty_init();
7154 #ifdef ENABLE_BGP_VNC
7157 bgp_ethernetvpn_init();
7158 bgp_flowspec_vty_init();
7160 /* Access list initialize. */
7162 access_list_add_hook(peer_distribute_update
);
7163 access_list_delete_hook(peer_distribute_update
);
7165 /* Filter list initialize. */
7167 as_list_add_hook(peer_aslist_add
);
7168 as_list_delete_hook(peer_aslist_del
);
7170 /* Prefix list initialize.*/
7172 prefix_list_add_hook(peer_prefix_list_update
);
7173 prefix_list_delete_hook(peer_prefix_list_update
);
7175 /* Community list initialize. */
7176 bgp_clist
= community_list_init();
7181 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
7184 void bgp_terminate(void)
7188 struct listnode
*node
, *nnode
;
7189 struct listnode
*mnode
, *mnnode
;
7193 /* Close the listener sockets first as this prevents peers from
7195 * to reconnect on receiving the peer unconfig message. In the presence
7196 * of a large number of peers this will ensure that no peer is left with
7197 * a dangling connection
7199 /* reverse bgp_master_init */
7202 if (bm
->listen_sockets
)
7203 list_delete(&bm
->listen_sockets
);
7205 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
))
7206 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
7207 if (peer
->status
== Established
7208 || peer
->status
== OpenSent
7209 || peer
->status
== OpenConfirm
)
7210 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7211 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7213 if (bm
->process_main_queue
)
7214 work_queue_free_and_null(&bm
->process_main_queue
);
7216 if (bm
->t_rmap_update
)
7217 BGP_TIMER_OFF(bm
->t_rmap_update
);
7220 bgp_evpn_mh_finish();
7223 struct peer
*peer_lookup_in_view(struct vty
*vty
, struct bgp
*bgp
,
7224 const char *ip_str
, bool use_json
)
7230 /* Get peer sockunion. */
7231 ret
= str2sockunion(ip_str
, &su
);
7233 peer
= peer_lookup_by_conf_if(bgp
, ip_str
);
7235 peer
= peer_lookup_by_hostname(bgp
, ip_str
);
7239 json_object
*json_no
= NULL
;
7240 json_no
= json_object_new_object();
7241 json_object_string_add(
7243 "malformedAddressOrName",
7245 vty_out(vty
, "%s\n",
7246 json_object_to_json_string_ext(
7248 JSON_C_TO_STRING_PRETTY
));
7249 json_object_free(json_no
);
7252 "%% Malformed address or name: %s\n",
7260 /* Peer structure lookup. */
7261 peer
= peer_lookup(bgp
, &su
);
7264 json_object
*json_no
= NULL
;
7265 json_no
= json_object_new_object();
7266 json_object_string_add(json_no
, "warning",
7267 "No such neighbor in this view/vrf");
7268 vty_out(vty
, "%s\n",
7269 json_object_to_json_string_ext(
7270 json_no
, JSON_C_TO_STRING_PRETTY
));
7271 json_object_free(json_no
);
7273 vty_out(vty
, "No such neighbor in this view/vrf\n");
7280 void bgp_gr_apply_running_config(void)
7282 struct peer
*peer
= NULL
;
7283 struct bgp
*bgp
= NULL
;
7284 struct listnode
*node
, *nnode
;
7285 bool gr_router_detected
= false;
7287 if (BGP_DEBUG(graceful_restart
, GRACEFUL_RESTART
))
7288 zlog_debug("[BGP_GR] %s called !", __func__
);
7290 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
7291 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7292 bgp_peer_gr_flags_update(peer
);
7293 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_GRACEFUL_RESTART
))
7294 gr_router_detected
= true;
7297 if (gr_router_detected
7298 && bgp
->present_zebra_gr_state
== ZEBRA_GR_DISABLE
) {
7299 bgp_zebra_send_capabilities(bgp
, true);
7300 } else if (!gr_router_detected
7301 && bgp
->present_zebra_gr_state
== ZEBRA_GR_ENABLE
) {
7302 bgp_zebra_send_capabilities(bgp
, false);
7305 gr_router_detected
= false;