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"
48 #include "bgpd/bgpd.h"
49 #include "bgpd/bgp_table.h"
50 #include "bgpd/bgp_aspath.h"
51 #include "bgpd/bgp_route.h"
52 #include "bgpd/bgp_dump.h"
53 #include "bgpd/bgp_debug.h"
54 #include "bgpd/bgp_community.h"
55 #include "bgpd/bgp_attr.h"
56 #include "bgpd/bgp_regex.h"
57 #include "bgpd/bgp_clist.h"
58 #include "bgpd/bgp_fsm.h"
59 #include "bgpd/bgp_packet.h"
60 #include "bgpd/bgp_zebra.h"
61 #include "bgpd/bgp_open.h"
62 #include "bgpd/bgp_filter.h"
63 #include "bgpd/bgp_nexthop.h"
64 #include "bgpd/bgp_damp.h"
65 #include "bgpd/bgp_mplsvpn.h"
67 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
68 #include "bgpd/rfapi/rfapi_backend.h"
70 #include "bgpd/bgp_evpn.h"
71 #include "bgpd/bgp_advertise.h"
72 #include "bgpd/bgp_network.h"
73 #include "bgpd/bgp_vty.h"
74 #include "bgpd/bgp_mpath.h"
75 #include "bgpd/bgp_nht.h"
76 #include "bgpd/bgp_updgrp.h"
77 #include "bgpd/bgp_bfd.h"
78 #include "bgpd/bgp_memory.h"
79 #include "bgpd/bgp_evpn_vty.h"
80 #include "bgpd/bgp_keepalives.h"
81 #include "bgpd/bgp_io.h"
82 #include "bgpd/bgp_ecommunity.h"
84 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
85 DEFINE_QOBJ_TYPE(bgp_master
)
87 DEFINE_QOBJ_TYPE(peer
)
89 /* BGP process wide configuration. */
90 static struct bgp_master bgp_master
;
92 /* BGP process wide configuration pointer to export. */
93 struct bgp_master
*bm
;
95 /* BGP community-list. */
96 struct community_list_handler
*bgp_clist
;
98 unsigned int multipath_num
= MULTIPATH_NUM
;
100 static void bgp_if_finish(struct bgp
*bgp
);
102 extern struct zclient
*zclient
;
104 /* handle main socket creation or deletion */
105 static int bgp_check_main_socket(bool create
, struct bgp
*bgp
)
107 static int bgp_server_main_created
;
108 struct listnode
*bgpnode
, *nbgpnode
;
109 struct bgp
*bgp_temp
;
111 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
&&
112 vrf_is_mapped_on_netns(bgp
->vrf_id
))
114 if (create
== true) {
115 if (bgp_server_main_created
)
117 if (bgp_socket(bgp
, bm
->port
, bm
->address
) < 0)
118 return BGP_ERR_INVALID_VALUE
;
119 bgp_server_main_created
= 1;
122 if (!bgp_server_main_created
)
124 /* only delete socket on some cases */
125 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp_temp
)) {
126 /* do not count with current bgp */
129 /* if other instance non VRF, do not delete socket */
130 if (bgp_temp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
132 /* vrf lite, do not delete socket */
133 if (!vrf_is_mapped_on_netns(bgp_temp
->vrf_id
))
137 bgp_server_main_created
= 0;
141 void bgp_session_reset(struct peer
*peer
)
143 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
144 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
145 peer_delete(peer
->doppelganger
);
147 BGP_EVENT_ADD(peer
, BGP_Stop
);
151 * During session reset, we may delete the doppelganger peer, which would
152 * be the next node to the current node. If the session reset was invoked
153 * during walk of peer list, we would end up accessing the freed next
154 * node. This function moves the next node along.
156 static void bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
161 n
= (nnode
) ? *nnode
: NULL
;
162 npeer
= (n
) ? listgetdata(n
) : NULL
;
164 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
165 && !(CHECK_FLAG(peer
->doppelganger
->flags
,
166 PEER_FLAG_CONFIG_NODE
))) {
167 if (peer
->doppelganger
== npeer
)
168 /* nnode and *nnode are confirmed to be non-NULL here */
169 *nnode
= (*nnode
)->next
;
170 peer_delete(peer
->doppelganger
);
173 BGP_EVENT_ADD(peer
, BGP_Stop
);
176 /* BGP global flag manipulation. */
177 int bgp_option_set(int flag
)
181 case BGP_OPT_MULTIPLE_INSTANCE
:
182 case BGP_OPT_CONFIG_CISCO
:
183 case BGP_OPT_NO_LISTEN
:
184 SET_FLAG(bm
->options
, flag
);
187 return BGP_ERR_INVALID_FLAG
;
192 int bgp_option_unset(int flag
)
195 case BGP_OPT_MULTIPLE_INSTANCE
:
196 if (listcount(bm
->bgp
) > 1)
197 return BGP_ERR_MULTIPLE_INSTANCE_USED
;
200 case BGP_OPT_CONFIG_CISCO
:
201 UNSET_FLAG(bm
->options
, flag
);
204 return BGP_ERR_INVALID_FLAG
;
209 int bgp_option_check(int flag
)
211 return CHECK_FLAG(bm
->options
, flag
);
214 /* BGP flag manipulation. */
215 int bgp_flag_set(struct bgp
*bgp
, int flag
)
217 SET_FLAG(bgp
->flags
, flag
);
221 int bgp_flag_unset(struct bgp
*bgp
, int flag
)
223 UNSET_FLAG(bgp
->flags
, flag
);
227 int bgp_flag_check(struct bgp
*bgp
, int flag
)
229 return CHECK_FLAG(bgp
->flags
, flag
);
232 /* Internal function to set BGP structure configureation flag. */
233 static void bgp_config_set(struct bgp
*bgp
, int config
)
235 SET_FLAG(bgp
->config
, config
);
238 static void bgp_config_unset(struct bgp
*bgp
, int config
)
240 UNSET_FLAG(bgp
->config
, config
);
243 static int bgp_config_check(struct bgp
*bgp
, int config
)
245 return CHECK_FLAG(bgp
->config
, config
);
248 /* Set BGP router identifier. */
249 static int bgp_router_id_set(struct bgp
*bgp
, const struct in_addr
*id
)
252 struct listnode
*node
, *nnode
;
254 if (IPV4_ADDR_SAME(&bgp
->router_id
, id
))
257 /* EVPN uses router id in RD, withdraw them */
258 if (is_evpn_enabled())
259 bgp_evpn_handle_router_id_update(bgp
, TRUE
);
261 IPV4_ADDR_COPY(&bgp
->router_id
, id
);
263 /* Set all peer's local identifier with this value. */
264 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
265 IPV4_ADDR_COPY(&peer
->local_id
, id
);
267 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
268 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
269 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
270 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
274 /* EVPN uses router id in RD, update them */
275 if (is_evpn_enabled())
276 bgp_evpn_handle_router_id_update(bgp
, FALSE
);
281 void bgp_router_id_zebra_bump(vrf_id_t vrf_id
, const struct prefix
*router_id
)
283 struct listnode
*node
, *nnode
;
286 if (vrf_id
== VRF_DEFAULT
) {
287 /* Router-id change for default VRF has to also update all
289 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
)) {
290 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
293 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
294 if (!bgp
->router_id_static
.s_addr
)
295 bgp_router_id_set(bgp
, &router_id
->u
.prefix4
);
298 bgp
= bgp_lookup_by_vrf_id(vrf_id
);
300 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
302 if (!bgp
->router_id_static
.s_addr
)
303 bgp_router_id_set(bgp
, &router_id
->u
.prefix4
);
308 int bgp_router_id_static_set(struct bgp
*bgp
, struct in_addr id
)
310 bgp
->router_id_static
= id
;
311 bgp_router_id_set(bgp
, id
.s_addr
? &id
: &bgp
->router_id_zebra
);
315 /* BGP's cluster-id control. */
316 int bgp_cluster_id_set(struct bgp
*bgp
, struct in_addr
*cluster_id
)
319 struct listnode
*node
, *nnode
;
321 if (bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
)
322 && IPV4_ADDR_SAME(&bgp
->cluster_id
, cluster_id
))
325 IPV4_ADDR_COPY(&bgp
->cluster_id
, cluster_id
);
326 bgp_config_set(bgp
, BGP_CONFIG_CLUSTER_ID
);
328 /* Clear all IBGP peer. */
329 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
330 if (peer
->sort
!= BGP_PEER_IBGP
)
333 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
334 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
335 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
336 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
342 int bgp_cluster_id_unset(struct bgp
*bgp
)
345 struct listnode
*node
, *nnode
;
347 if (!bgp_config_check(bgp
, BGP_CONFIG_CLUSTER_ID
))
350 bgp
->cluster_id
.s_addr
= 0;
351 bgp_config_unset(bgp
, BGP_CONFIG_CLUSTER_ID
);
353 /* Clear all IBGP peer. */
354 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
355 if (peer
->sort
!= BGP_PEER_IBGP
)
358 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
359 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
360 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
361 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
367 /* time_t value that is monotonicly increasing
368 * and uneffected by adjustments to system clock
370 time_t bgp_clock(void)
378 /* BGP timer configuration. */
379 int bgp_timers_set(struct bgp
*bgp
, u_int32_t keepalive
, u_int32_t holdtime
)
381 bgp
->default_keepalive
=
382 (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
383 bgp
->default_holdtime
= holdtime
;
388 int bgp_timers_unset(struct bgp
*bgp
)
390 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
391 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
396 /* BGP confederation configuration. */
397 int bgp_confederation_id_set(struct bgp
*bgp
, as_t as
)
400 struct listnode
*node
, *nnode
;
404 return BGP_ERR_INVALID_AS
;
406 /* Remember - were we doing confederation before? */
407 already_confed
= bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
);
409 bgp_config_set(bgp
, BGP_CONFIG_CONFEDERATION
);
411 /* If we were doing confederation already, this is just an external
412 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
413 were not doing confederation before, reset all EBGP sessions. */
414 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
415 /* We're looking for peers who's AS is not local or part of our
417 if (already_confed
) {
418 if (peer_sort(peer
) == BGP_PEER_EBGP
) {
420 if (BGP_IS_VALID_STATE_FOR_NOTIF(
423 PEER_DOWN_CONFED_ID_CHANGE
;
425 peer
, BGP_NOTIFY_CEASE
,
426 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
428 bgp_session_reset_safe(peer
, &nnode
);
431 /* Not doign confederation before, so reset every
434 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
435 /* Reset the local_as to be our EBGP one */
436 if (peer_sort(peer
) == BGP_PEER_EBGP
)
438 if (BGP_IS_VALID_STATE_FOR_NOTIF(
441 PEER_DOWN_CONFED_ID_CHANGE
;
443 peer
, BGP_NOTIFY_CEASE
,
444 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
446 bgp_session_reset_safe(peer
, &nnode
);
453 int bgp_confederation_id_unset(struct bgp
*bgp
)
456 struct listnode
*node
, *nnode
;
459 bgp_config_unset(bgp
, BGP_CONFIG_CONFEDERATION
);
461 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
462 /* We're looking for peers who's AS is not local */
463 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
464 peer
->local_as
= bgp
->as
;
465 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
466 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
467 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
468 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
472 bgp_session_reset_safe(peer
, &nnode
);
478 /* Is an AS part of the confed or not? */
479 int bgp_confederation_peers_check(struct bgp
*bgp
, as_t as
)
486 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
487 if (bgp
->confed_peers
[i
] == as
)
493 /* Add an AS to the confederation set. */
494 int bgp_confederation_peers_add(struct bgp
*bgp
, as_t as
)
497 struct listnode
*node
, *nnode
;
500 return BGP_ERR_INVALID_BGP
;
503 return BGP_ERR_INVALID_AS
;
505 if (bgp_confederation_peers_check(bgp
, as
))
508 if (bgp
->confed_peers
)
510 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
511 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
514 XMALLOC(MTYPE_BGP_CONFED_LIST
,
515 (bgp
->confed_peers_cnt
+ 1) * sizeof(as_t
));
517 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
518 bgp
->confed_peers_cnt
++;
520 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
521 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
522 if (peer
->as
== as
) {
523 peer
->local_as
= bgp
->as
;
524 if (BGP_IS_VALID_STATE_FOR_NOTIF(
527 PEER_DOWN_CONFED_PEER_CHANGE
;
529 peer
, BGP_NOTIFY_CEASE
,
530 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
532 bgp_session_reset_safe(peer
, &nnode
);
539 /* Delete an AS from the confederation set. */
540 int bgp_confederation_peers_remove(struct bgp
*bgp
, as_t as
)
545 struct listnode
*node
, *nnode
;
550 if (!bgp_confederation_peers_check(bgp
, as
))
553 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
554 if (bgp
->confed_peers
[i
] == as
)
555 for (j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
556 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
558 bgp
->confed_peers_cnt
--;
560 if (bgp
->confed_peers_cnt
== 0) {
561 if (bgp
->confed_peers
)
562 XFREE(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
563 bgp
->confed_peers
= NULL
;
566 XREALLOC(MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
,
567 bgp
->confed_peers_cnt
* sizeof(as_t
));
569 /* Now reset any peer who's remote AS has just been removed from the
571 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)) {
572 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
573 if (peer
->as
== as
) {
574 peer
->local_as
= bgp
->confed_id
;
575 if (BGP_IS_VALID_STATE_FOR_NOTIF(
578 PEER_DOWN_CONFED_PEER_CHANGE
;
580 peer
, BGP_NOTIFY_CEASE
,
581 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
583 bgp_session_reset_safe(peer
, &nnode
);
591 /* Local preference configuration. */
592 int bgp_default_local_preference_set(struct bgp
*bgp
, u_int32_t local_pref
)
597 bgp
->default_local_pref
= local_pref
;
602 int bgp_default_local_preference_unset(struct bgp
*bgp
)
607 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
612 /* Local preference configuration. */
613 int bgp_default_subgroup_pkt_queue_max_set(struct bgp
*bgp
,
614 u_int32_t queue_size
)
619 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
624 int bgp_default_subgroup_pkt_queue_max_unset(struct bgp
*bgp
)
628 bgp
->default_subgroup_pkt_queue_max
=
629 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
634 /* Listen limit configuration. */
635 int bgp_listen_limit_set(struct bgp
*bgp
, int listen_limit
)
640 bgp
->dynamic_neighbors_limit
= listen_limit
;
645 int bgp_listen_limit_unset(struct bgp
*bgp
)
650 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
655 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi
, iana_safi_t pkt_safi
,
656 afi_t
*afi
, safi_t
*safi
)
658 /* Map from IANA values to internal values, return error if
659 * values are unrecognized.
661 *afi
= afi_iana2int(pkt_afi
);
662 *safi
= safi_iana2int(pkt_safi
);
663 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
669 int bgp_map_afi_safi_int2iana(afi_t afi
, safi_t safi
, iana_afi_t
*pkt_afi
,
670 iana_safi_t
*pkt_safi
)
672 /* Map from internal values to IANA values, return error if
673 * internal values are bad (unexpected).
675 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
677 *pkt_afi
= afi_int2iana(afi
);
678 *pkt_safi
= safi_int2iana(safi
);
682 struct peer_af
*peer_af_create(struct peer
*peer
, afi_t afi
, safi_t safi
)
690 afid
= afindex(afi
, safi
);
691 if (afid
>= BGP_AF_MAX
)
694 assert(peer
->peer_af_array
[afid
] == NULL
);
696 /* Allocate new peer af */
697 af
= XCALLOC(MTYPE_BGP_PEER_AF
, sizeof(struct peer_af
));
700 zlog_err("Could not create af structure for peer %s",
705 peer
->peer_af_array
[afid
] = af
;
714 struct peer_af
*peer_af_find(struct peer
*peer
, afi_t afi
, safi_t safi
)
721 afid
= afindex(afi
, safi
);
722 if (afid
>= BGP_AF_MAX
)
725 return peer
->peer_af_array
[afid
];
728 int peer_af_delete(struct peer
*peer
, afi_t afi
, safi_t safi
)
736 afid
= afindex(afi
, safi
);
737 if (afid
>= BGP_AF_MAX
)
740 af
= peer
->peer_af_array
[afid
];
744 bgp_stop_announce_route_timer(af
);
746 if (PAF_SUBGRP(af
)) {
747 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
748 zlog_debug("u%" PRIu64
":s%" PRIu64
" remove peer %s",
749 af
->subgroup
->update_group
->id
,
750 af
->subgroup
->id
, peer
->host
);
753 update_subgroup_remove_peer(af
->subgroup
, af
);
755 peer
->peer_af_array
[afid
] = NULL
;
756 XFREE(MTYPE_BGP_PEER_AF
, af
);
760 /* Peer comparison function for sorting. */
761 int peer_cmp(struct peer
*p1
, struct peer
*p2
)
763 if (p1
->group
&& !p2
->group
)
766 if (!p1
->group
&& p2
->group
)
769 if (p1
->group
== p2
->group
) {
770 if (p1
->conf_if
&& !p2
->conf_if
)
773 if (!p1
->conf_if
&& p2
->conf_if
)
776 if (p1
->conf_if
&& p2
->conf_if
)
777 return if_cmp_name_func(p1
->conf_if
, p2
->conf_if
);
779 return strcmp(p1
->group
->name
, p2
->group
->name
);
781 return sockunion_cmp(&p1
->su
, &p2
->su
);
784 static unsigned int peer_hash_key_make(void *p
)
786 struct peer
*peer
= p
;
787 return sockunion_hash(&peer
->su
);
790 static int peer_hash_same(const void *p1
, const void *p2
)
792 const struct peer
*peer1
= p1
;
793 const struct peer
*peer2
= p2
;
794 return (sockunion_same(&peer1
->su
, &peer2
->su
)
795 && CHECK_FLAG(peer1
->flags
, PEER_FLAG_CONFIG_NODE
)
796 == CHECK_FLAG(peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
799 int peer_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
,
802 return CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
);
805 /* Return true if flag is set for the peer but not the peer-group */
806 static int peergroup_af_flag_check(struct peer
*peer
, afi_t afi
, safi_t safi
,
809 struct peer
*g_peer
= NULL
;
811 if (peer_af_flag_check(peer
, afi
, safi
, flag
)) {
812 if (peer_group_active(peer
)) {
813 g_peer
= peer
->group
->conf
;
815 /* If this flag is not set for the peer's peer-group
816 * then return true */
817 if (!peer_af_flag_check(g_peer
, afi
, safi
, flag
)) {
822 /* peer is not in a peer-group but the flag is set to return
832 /* Reset all address family specific configuration. */
833 static void peer_af_flag_reset(struct peer
*peer
, afi_t afi
, safi_t safi
)
836 struct bgp_filter
*filter
;
837 char orf_name
[BUFSIZ
];
839 filter
= &peer
->filter
[afi
][safi
];
841 /* Clear neighbor filter and route-map */
842 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
843 if (filter
->dlist
[i
].name
) {
844 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
845 filter
->dlist
[i
].name
= NULL
;
847 if (filter
->plist
[i
].name
) {
848 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
849 filter
->plist
[i
].name
= NULL
;
851 if (filter
->aslist
[i
].name
) {
852 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
853 filter
->aslist
[i
].name
= NULL
;
856 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
857 if (filter
->map
[i
].name
) {
858 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
859 filter
->map
[i
].name
= NULL
;
863 /* Clear unsuppress map. */
864 if (filter
->usmap
.name
)
865 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
866 filter
->usmap
.name
= NULL
;
867 filter
->usmap
.map
= NULL
;
869 /* Clear neighbor's all address family flags. */
870 peer
->af_flags
[afi
][safi
] = 0;
872 /* Clear neighbor's all address family sflags. */
873 peer
->af_sflags
[afi
][safi
] = 0;
875 /* Clear neighbor's all address family capabilities. */
876 peer
->af_cap
[afi
][safi
] = 0;
879 peer
->orf_plist
[afi
][safi
] = NULL
;
880 sprintf(orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
881 prefix_bgp_orf_remove_all(afi
, orf_name
);
883 /* Set default neighbor send-community. */
884 if (!bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
885 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
886 SET_FLAG(peer
->af_flags
[afi
][safi
],
887 PEER_FLAG_SEND_EXT_COMMUNITY
);
888 SET_FLAG(peer
->af_flags
[afi
][safi
],
889 PEER_FLAG_SEND_LARGE_COMMUNITY
);
892 /* Clear neighbor default_originate_rmap */
893 if (peer
->default_rmap
[afi
][safi
].name
)
894 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
895 peer
->default_rmap
[afi
][safi
].name
= NULL
;
896 peer
->default_rmap
[afi
][safi
].map
= NULL
;
898 /* Clear neighbor maximum-prefix */
899 peer
->pmax
[afi
][safi
] = 0;
900 peer
->pmax_threshold
[afi
][safi
] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT
;
903 /* peer global config reset */
904 static void peer_global_config_reset(struct peer
*peer
)
908 peer
->change_local_as
= 0;
909 peer
->ttl
= (peer_sort(peer
) == BGP_PEER_IBGP
? MAXTTL
: 1);
910 if (peer
->update_source
) {
911 sockunion_free(peer
->update_source
);
912 peer
->update_source
= NULL
;
914 if (peer
->update_if
) {
915 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
916 peer
->update_if
= NULL
;
919 if (peer_sort(peer
) == BGP_PEER_IBGP
)
920 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
922 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
924 /* These are per-peer specific flags and so we must preserve them */
925 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
926 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
);
928 SET_FLAG(peer
->flags
, saved_flags
);
934 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
936 /* Reset some other configs back to defaults. */
937 peer
->v_start
= BGP_INIT_START_TIMER
;
938 peer
->password
= NULL
;
939 peer
->local_id
= peer
->bgp
->router_id
;
940 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
941 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
943 bfd_info_free(&(peer
->bfd_info
));
945 /* Set back the CONFIG_NODE flag. */
946 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
949 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
950 static inline bgp_peer_sort_t
peer_calc_sort(struct peer
*peer
)
957 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
958 if (peer
->as_type
== AS_INTERNAL
)
959 return BGP_PEER_IBGP
;
961 else if (peer
->as_type
== AS_EXTERNAL
)
962 return BGP_PEER_EBGP
;
964 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
)
965 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
970 peer1
= listnode_head(peer
->group
->peer
);
975 return BGP_PEER_INTERNAL
;
979 if (bgp
&& CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
980 if (peer
->local_as
== 0)
981 return BGP_PEER_INTERNAL
;
983 if (peer
->local_as
== peer
->as
) {
984 if (bgp
->as
== bgp
->confed_id
) {
985 if (peer
->local_as
== bgp
->as
)
986 return BGP_PEER_IBGP
;
988 return BGP_PEER_EBGP
;
990 if (peer
->local_as
== bgp
->confed_id
)
991 return BGP_PEER_EBGP
;
993 return BGP_PEER_IBGP
;
997 if (bgp_confederation_peers_check(bgp
, peer
->as
))
998 return BGP_PEER_CONFED
;
1000 return BGP_PEER_EBGP
;
1002 if (peer
->as_type
!= AS_SPECIFIED
)
1003 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
1006 return (peer
->local_as
== 0
1008 : peer
->local_as
== peer
->as
? BGP_PEER_IBGP
1013 /* Calculate and cache the peer "sort" */
1014 bgp_peer_sort_t
peer_sort(struct peer
*peer
)
1016 peer
->sort
= peer_calc_sort(peer
);
1020 static void peer_free(struct peer
*peer
)
1022 assert(peer
->status
== Deleted
);
1026 /* this /ought/ to have been done already through bgp_stop earlier,
1027 * but just to be sure..
1029 bgp_timer_set(peer
);
1030 bgp_reads_off(peer
);
1031 bgp_writes_off(peer
);
1032 assert(!peer
->t_write
);
1033 assert(!peer
->t_read
);
1034 BGP_EVENT_FLUSH(peer
);
1036 pthread_mutex_destroy(&peer
->io_mtx
);
1038 /* Free connected nexthop, if present */
1039 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)
1040 && !peer_dynamic_neighbor(peer
))
1041 bgp_delete_connected_nexthop(family2afi(peer
->su
.sa
.sa_family
),
1044 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1047 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
1051 /* Free allocated host character. */
1053 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1057 if (peer
->domainname
) {
1058 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1059 peer
->domainname
= NULL
;
1063 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1064 peer
->ifname
= NULL
;
1067 /* Update source configuration. */
1068 if (peer
->update_source
) {
1069 sockunion_free(peer
->update_source
);
1070 peer
->update_source
= NULL
;
1073 if (peer
->update_if
) {
1074 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1075 peer
->update_if
= NULL
;
1078 if (peer
->notify
.data
)
1079 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1080 memset(&peer
->notify
, 0, sizeof(struct bgp_notify
));
1082 if (peer
->clear_node_queue
)
1083 work_queue_free_and_null(&peer
->clear_node_queue
);
1085 bgp_sync_delete(peer
);
1087 if (peer
->conf_if
) {
1088 XFREE(MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1089 peer
->conf_if
= NULL
;
1092 bfd_info_free(&(peer
->bfd_info
));
1094 bgp_unlock(peer
->bgp
);
1096 memset(peer
, 0, sizeof(struct peer
));
1098 XFREE(MTYPE_BGP_PEER
, peer
);
1101 /* increase reference count on a struct peer */
1102 struct peer
*peer_lock_with_caller(const char *name
, struct peer
*peer
)
1104 assert(peer
&& (peer
->lock
>= 0));
1107 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1115 /* decrease reference count on a struct peer
1116 * struct peer is freed and NULL returned if last reference
1118 struct peer
*peer_unlock_with_caller(const char *name
, struct peer
*peer
)
1120 assert(peer
&& (peer
->lock
> 0));
1123 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1128 if (peer
->lock
== 0) {
1136 /* Allocate new peer object, implicitely locked. */
1137 struct peer
*peer_new(struct bgp
*bgp
)
1144 /* bgp argument is absolutely required */
1149 /* Allocate new peer. */
1150 peer
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
1152 /* Set default value. */
1154 peer
->v_start
= BGP_INIT_START_TIMER
;
1155 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1156 peer
->status
= Idle
;
1157 peer
->ostatus
= Idle
;
1158 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1159 peer
->bgp
= bgp_lock(bgp
);
1160 peer
= peer_lock(peer
); /* initial reference */
1161 peer
->password
= NULL
;
1163 /* Set default flags. */
1164 FOREACH_AFI_SAFI (afi
, safi
) {
1165 if (!bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
1166 SET_FLAG(peer
->af_flags
[afi
][safi
],
1167 PEER_FLAG_SEND_COMMUNITY
);
1168 SET_FLAG(peer
->af_flags
[afi
][safi
],
1169 PEER_FLAG_SEND_EXT_COMMUNITY
);
1170 SET_FLAG(peer
->af_flags
[afi
][safi
],
1171 PEER_FLAG_SEND_LARGE_COMMUNITY
);
1173 peer
->orf_plist
[afi
][safi
] = NULL
;
1175 SET_FLAG(peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1177 /* Create buffers. */
1178 peer
->ibuf
= stream_fifo_new();
1179 peer
->obuf
= stream_fifo_new();
1180 pthread_mutex_init(&peer
->io_mtx
, NULL
);
1182 /* We use a larger buffer for peer->obuf_work in the event that:
1183 * - We RX a BGP_UPDATE where the attributes alone are just
1184 * under BGP_MAX_PACKET_SIZE
1185 * - The user configures an outbound route-map that does many as-path
1186 * prepends or adds many communities. At most they can have
1187 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1188 * large they can make the attributes.
1190 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1191 * bounds checking for every single attribute as we construct an
1195 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1197 ringbuf_new(BGP_MAX_PACKET_SIZE
* BGP_READ_PACKET_MAX
);
1199 peer
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
1201 bgp_sync_init(peer
);
1203 /* Get service port number. */
1204 sp
= getservbyname("bgp", "tcp");
1205 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs(sp
->s_port
);
1207 QOBJ_REG(peer
, peer
);
1212 * This function is invoked when a duplicate peer structure associated with
1213 * a neighbor is being deleted. If this about-to-be-deleted structure is
1214 * the one with all the config, then we have to copy over the info.
1216 void peer_xfer_config(struct peer
*peer_dst
, struct peer
*peer_src
)
1218 struct peer_af
*paf
;
1226 /* The following function is used by both peer group config copy to
1227 * individual peer and when we transfer config
1229 if (peer_src
->change_local_as
)
1230 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1232 /* peer flags apply */
1233 peer_dst
->flags
= peer_src
->flags
;
1234 peer_dst
->cap
= peer_src
->cap
;
1235 peer_dst
->config
= peer_src
->config
;
1237 peer_dst
->local_as
= peer_src
->local_as
;
1238 peer_dst
->port
= peer_src
->port
;
1239 (void)peer_sort(peer_dst
);
1240 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1243 peer_dst
->holdtime
= peer_src
->holdtime
;
1244 peer_dst
->keepalive
= peer_src
->keepalive
;
1245 peer_dst
->connect
= peer_src
->connect
;
1246 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1247 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1248 peer_dst
->routeadv
= peer_src
->routeadv
;
1249 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1251 /* password apply */
1252 if (peer_src
->password
&& !peer_dst
->password
)
1253 peer_dst
->password
=
1254 XSTRDUP(MTYPE_PEER_PASSWORD
, peer_src
->password
);
1256 FOREACH_AFI_SAFI (afi
, safi
) {
1257 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1258 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1259 peer_dst
->allowas_in
[afi
][safi
] =
1260 peer_src
->allowas_in
[afi
][safi
];
1261 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1264 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++) {
1265 paf
= peer_src
->peer_af_array
[afidx
];
1267 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1270 /* update-source apply */
1271 if (peer_src
->update_source
) {
1272 if (peer_dst
->update_source
)
1273 sockunion_free(peer_dst
->update_source
);
1274 if (peer_dst
->update_if
) {
1275 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1276 peer_dst
->update_if
= NULL
;
1278 peer_dst
->update_source
=
1279 sockunion_dup(peer_src
->update_source
);
1280 } else if (peer_src
->update_if
) {
1281 if (peer_dst
->update_if
)
1282 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1283 if (peer_dst
->update_source
) {
1284 sockunion_free(peer_dst
->update_source
);
1285 peer_dst
->update_source
= NULL
;
1287 peer_dst
->update_if
=
1288 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1291 if (peer_src
->ifname
) {
1292 if (peer_dst
->ifname
)
1293 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1296 XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1300 static int bgp_peer_conf_if_to_su_update_v4(struct peer
*peer
,
1301 struct interface
*ifp
)
1303 struct connected
*ifc
;
1306 struct listnode
*node
;
1308 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1309 * IPv4 address of the other end.
1311 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
)) {
1312 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
)) {
1313 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1314 if (p
.prefixlen
== 30) {
1315 peer
->su
.sa
.sa_family
= AF_INET
;
1316 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1318 peer
->su
.sin
.sin_addr
.s_addr
=
1320 else if (addr
% 4 == 2)
1321 peer
->su
.sin
.sin_addr
.s_addr
=
1323 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1324 peer
->su
.sin
.sin_len
=
1325 sizeof(struct sockaddr_in
);
1326 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1328 } else if (p
.prefixlen
== 31) {
1329 peer
->su
.sa
.sa_family
= AF_INET
;
1330 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1332 peer
->su
.sin
.sin_addr
.s_addr
=
1335 peer
->su
.sin
.sin_addr
.s_addr
=
1337 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1338 peer
->su
.sin
.sin_len
=
1339 sizeof(struct sockaddr_in
);
1340 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1342 } else if (bgp_debug_neighbor_events(peer
))
1344 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1352 static int bgp_peer_conf_if_to_su_update_v6(struct peer
*peer
,
1353 struct interface
*ifp
)
1355 struct nbr_connected
*ifc_nbr
;
1357 /* Have we learnt the peer's IPv6 link-local address? */
1358 if (ifp
->nbr_connected
1359 && (ifc_nbr
= listnode_head(ifp
->nbr_connected
))) {
1360 peer
->su
.sa
.sa_family
= AF_INET6
;
1361 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1362 sizeof(struct in6_addr
));
1364 peer
->su
.sin6
.sin6_len
= sizeof(struct sockaddr_in6
);
1366 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1374 * Set or reset the peer address socketunion structure based on the
1375 * learnt/derived peer address. If the address has changed, update the
1376 * password on the listen socket, if needed.
1378 void bgp_peer_conf_if_to_su_update(struct peer
*peer
)
1380 struct interface
*ifp
;
1382 int peer_addr_updated
= 0;
1387 prev_family
= peer
->su
.sa
.sa_family
;
1388 if ((ifp
= if_lookup_by_name(peer
->conf_if
, peer
->bgp
->vrf_id
))) {
1390 /* If BGP unnumbered is not "v6only", we first see if we can
1392 * peer's IPv4 address.
1394 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1396 bgp_peer_conf_if_to_su_update_v4(peer
, ifp
);
1398 /* If "v6only" or we can't derive peer's IPv4 address, see if
1400 * learnt the peer's IPv6 link-local address. This is from the
1402 * IPv6 address in router advertisement.
1404 if (!peer_addr_updated
)
1406 bgp_peer_conf_if_to_su_update_v6(peer
, ifp
);
1408 /* If we could derive the peer address, we may need to install the
1410 * configured for the peer, if any, on the listen socket. Otherwise,
1412 * that peer's address is not available and uninstall the password, if
1415 if (peer_addr_updated
) {
1416 if (peer
->password
&& prev_family
== AF_UNSPEC
)
1419 if (peer
->password
&& prev_family
!= AF_UNSPEC
)
1420 bgp_md5_unset(peer
);
1421 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1422 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof(struct in6_addr
));
1425 /* Since our su changed we need to del/add peer to the peerhash */
1426 hash_release(peer
->bgp
->peerhash
, peer
);
1427 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1430 static void bgp_recalculate_afi_safi_bestpaths(struct bgp
*bgp
, afi_t afi
,
1433 struct bgp_node
*rn
, *nrn
;
1435 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
1436 rn
= bgp_route_next(rn
)) {
1437 if (rn
->info
!= NULL
) {
1438 /* Special handling for 2-level routing
1440 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
1441 || safi
== SAFI_EVPN
) {
1442 for (nrn
= bgp_table_top(
1443 (struct bgp_table
*)(rn
->info
));
1444 nrn
; nrn
= bgp_route_next(nrn
))
1445 bgp_process(bgp
, nrn
, afi
, safi
);
1447 bgp_process(bgp
, rn
, afi
, safi
);
1452 /* Force a bestpath recalculation for all prefixes. This is used
1453 * when 'bgp bestpath' commands are entered.
1455 void bgp_recalculate_all_bestpaths(struct bgp
*bgp
)
1460 FOREACH_AFI_SAFI (afi
, safi
) {
1461 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, safi
);
1465 /* Create new BGP peer. */
1466 struct peer
*peer_create(union sockunion
*su
, const char *conf_if
,
1467 struct bgp
*bgp
, as_t local_as
, as_t remote_as
,
1468 int as_type
, afi_t afi
, safi_t safi
,
1469 struct peer_group
*group
)
1473 char buf
[SU_ADDRSTRLEN
];
1475 peer
= peer_new(bgp
);
1477 peer
->conf_if
= XSTRDUP(MTYPE_PEER_CONF_IF
, conf_if
);
1478 bgp_peer_conf_if_to_su_update(peer
);
1480 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1481 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, conf_if
);
1484 sockunion2str(su
, buf
, SU_ADDRSTRLEN
);
1486 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1487 peer
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, buf
);
1489 peer
->local_as
= local_as
;
1490 peer
->as
= remote_as
;
1491 peer
->as_type
= as_type
;
1492 peer
->local_id
= bgp
->router_id
;
1493 peer
->v_holdtime
= bgp
->default_holdtime
;
1494 peer
->v_keepalive
= bgp
->default_keepalive
;
1495 if (peer_sort(peer
) == BGP_PEER_IBGP
)
1496 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1498 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1500 peer
= peer_lock(peer
); /* bgp peer list reference */
1501 peer
->group
= group
;
1502 listnode_add_sort(bgp
->peer
, peer
);
1503 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1505 /* Adjust update-group coalesce timer heuristics for # peers. */
1506 if (bgp
->heuristic_coalesce
) {
1507 long ct
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1509 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME
);
1510 bgp
->coalesce_time
= MIN(BGP_MAX_SUBGROUP_COALESCE_TIME
, ct
);
1513 active
= peer_active(peer
);
1515 /* Last read and reset time set */
1516 peer
->readtime
= peer
->resettime
= bgp_clock();
1518 /* Default TTL set. */
1519 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: 1;
1521 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1524 peer
->afc
[afi
][safi
] = 1;
1525 peer_af_create(peer
, afi
, safi
);
1528 /* auto shutdown if configured */
1529 if (bgp
->autoshutdown
)
1530 peer_flag_set(peer
, PEER_FLAG_SHUTDOWN
);
1531 /* Set up peer's events and timers. */
1532 else if (!active
&& peer_active(peer
))
1533 bgp_timer_set(peer
);
1538 /* Make accept BGP peer. This function is only called from the test code */
1539 struct peer
*peer_create_accept(struct bgp
*bgp
)
1543 peer
= peer_new(bgp
);
1545 peer
= peer_lock(peer
); /* bgp peer list reference */
1546 listnode_add_sort(bgp
->peer
, peer
);
1552 * Return true if we have a peer configured to use this afi/safi
1554 int bgp_afi_safi_peer_exists(struct bgp
*bgp
, afi_t afi
, safi_t safi
)
1556 struct listnode
*node
;
1559 for (ALL_LIST_ELEMENTS_RO(bgp
->peer
, node
, peer
)) {
1560 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
1563 if (peer
->afc
[afi
][safi
])
1570 /* Change peer's AS number. */
1571 void peer_as_change(struct peer
*peer
, as_t as
, int as_specified
)
1573 bgp_peer_sort_t type
;
1577 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1578 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
1579 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1580 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1581 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1583 bgp_session_reset(peer
);
1585 type
= peer_sort(peer
);
1587 peer
->as_type
= as_specified
;
1589 if (bgp_config_check(peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1590 && !bgp_confederation_peers_check(peer
->bgp
, as
)
1591 && peer
->bgp
->as
!= as
)
1592 peer
->local_as
= peer
->bgp
->confed_id
;
1594 peer
->local_as
= peer
->bgp
->as
;
1596 /* Advertisement-interval reset */
1599 conf
= peer
->group
->conf
;
1601 if (conf
&& CHECK_FLAG(conf
->config
, PEER_CONFIG_ROUTEADV
)) {
1602 peer
->v_routeadv
= conf
->routeadv
;
1604 /* Only go back to the default advertisement-interval if the user had
1606 * already configured it */
1607 else if (!CHECK_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
)) {
1608 if (peer_sort(peer
) == BGP_PEER_IBGP
)
1609 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1611 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1614 if (peer_sort(peer
) == BGP_PEER_IBGP
)
1616 else if (type
== BGP_PEER_IBGP
)
1619 /* reflector-client reset */
1620 if (peer_sort(peer
) != BGP_PEER_IBGP
) {
1621 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1622 PEER_FLAG_REFLECTOR_CLIENT
);
1623 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1624 PEER_FLAG_REFLECTOR_CLIENT
);
1625 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1626 PEER_FLAG_REFLECTOR_CLIENT
);
1627 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1628 PEER_FLAG_REFLECTOR_CLIENT
);
1629 UNSET_FLAG(peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1630 PEER_FLAG_REFLECTOR_CLIENT
);
1631 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1632 PEER_FLAG_REFLECTOR_CLIENT
);
1633 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1634 PEER_FLAG_REFLECTOR_CLIENT
);
1635 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1636 PEER_FLAG_REFLECTOR_CLIENT
);
1637 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1638 PEER_FLAG_REFLECTOR_CLIENT
);
1639 UNSET_FLAG(peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1640 PEER_FLAG_REFLECTOR_CLIENT
);
1641 UNSET_FLAG(peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1642 PEER_FLAG_REFLECTOR_CLIENT
);
1645 /* local-as reset */
1646 if (peer_sort(peer
) != BGP_PEER_EBGP
) {
1647 peer
->change_local_as
= 0;
1648 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1649 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1653 /* If peer does not exist, create new one. If peer already exists,
1654 set AS number to the peer. */
1655 int peer_remote_as(struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1656 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1662 peer
= peer_lookup_by_conf_if(bgp
, conf_if
);
1664 peer
= peer_lookup(bgp
, su
);
1667 /* Not allowed for a dynamic peer. */
1668 if (peer_dynamic_neighbor(peer
)) {
1670 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1673 /* When this peer is a member of peer-group. */
1675 if (peer
->group
->conf
->as
) {
1676 /* Return peer group's AS number. */
1677 *as
= peer
->group
->conf
->as
;
1678 return BGP_ERR_PEER_GROUP_MEMBER
;
1680 if (peer_sort(peer
->group
->conf
) == BGP_PEER_IBGP
) {
1681 if ((as_type
!= AS_INTERNAL
)
1682 && (bgp
->as
!= *as
)) {
1684 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1687 if ((as_type
!= AS_EXTERNAL
)
1688 && (bgp
->as
== *as
)) {
1690 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1695 /* Existing peer's AS number change. */
1696 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
1697 || (peer
->as_type
!= as_type
))
1698 peer_as_change(peer
, *as
, as_type
);
1701 return BGP_ERR_NO_INTERFACE_CONFIG
;
1703 /* If the peer is not part of our confederation, and its not an
1704 iBGP peer then spoof the source AS */
1705 if (bgp_config_check(bgp
, BGP_CONFIG_CONFEDERATION
)
1706 && !bgp_confederation_peers_check(bgp
, *as
)
1708 local_as
= bgp
->confed_id
;
1712 /* If this is IPv4 unicast configuration and "no bgp default
1713 ipv4-unicast" is specified. */
1715 if (bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1716 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1717 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0,
1720 peer_create(su
, conf_if
, bgp
, local_as
, *as
, as_type
,
1727 static void peer_group2peer_config_copy_af(struct peer_group
*group
,
1728 struct peer
*peer
, afi_t afi
,
1732 int out
= FILTER_OUT
;
1734 struct bgp_filter
*pfilter
;
1735 struct bgp_filter
*gfilter
;
1738 pfilter
= &peer
->filter
[afi
][safi
];
1739 gfilter
= &conf
->filter
[afi
][safi
];
1741 /* peer af_flags apply */
1742 peer
->af_flags
[afi
][safi
] = conf
->af_flags
[afi
][safi
];
1744 /* maximum-prefix */
1745 peer
->pmax
[afi
][safi
] = conf
->pmax
[afi
][safi
];
1746 peer
->pmax_threshold
[afi
][safi
] = conf
->pmax_threshold
[afi
][safi
];
1747 peer
->pmax_restart
[afi
][safi
] = conf
->pmax_restart
[afi
][safi
];
1750 peer
->allowas_in
[afi
][safi
] = conf
->allowas_in
[afi
][safi
];
1753 peer
->weight
[afi
][safi
] = conf
->weight
[afi
][safi
];
1755 /* default-originate route-map */
1756 if (conf
->default_rmap
[afi
][safi
].name
) {
1757 if (peer
->default_rmap
[afi
][safi
].name
)
1758 XFREE(MTYPE_BGP_FILTER_NAME
,
1759 peer
->default_rmap
[afi
][safi
].name
);
1760 peer
->default_rmap
[afi
][safi
].name
=
1761 XSTRDUP(MTYPE_BGP_FILTER_NAME
,
1762 conf
->default_rmap
[afi
][safi
].name
);
1763 peer
->default_rmap
[afi
][safi
].map
=
1764 conf
->default_rmap
[afi
][safi
].map
;
1767 /* inbound filter apply */
1768 if (gfilter
->dlist
[in
].name
&& !pfilter
->dlist
[in
].name
) {
1769 if (pfilter
->dlist
[in
].name
)
1770 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[in
].name
);
1771 pfilter
->dlist
[in
].name
=
1772 XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[in
].name
);
1773 pfilter
->dlist
[in
].alist
= gfilter
->dlist
[in
].alist
;
1776 if (gfilter
->plist
[in
].name
&& !pfilter
->plist
[in
].name
) {
1777 if (pfilter
->plist
[in
].name
)
1778 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[in
].name
);
1779 pfilter
->plist
[in
].name
=
1780 XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[in
].name
);
1781 pfilter
->plist
[in
].plist
= gfilter
->plist
[in
].plist
;
1784 if (gfilter
->aslist
[in
].name
&& !pfilter
->aslist
[in
].name
) {
1785 if (pfilter
->aslist
[in
].name
)
1786 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[in
].name
);
1787 pfilter
->aslist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
,
1788 gfilter
->aslist
[in
].name
);
1789 pfilter
->aslist
[in
].aslist
= gfilter
->aslist
[in
].aslist
;
1792 if (gfilter
->map
[RMAP_IN
].name
&& !pfilter
->map
[RMAP_IN
].name
) {
1793 if (pfilter
->map
[RMAP_IN
].name
)
1794 XFREE(MTYPE_BGP_FILTER_NAME
,
1795 pfilter
->map
[RMAP_IN
].name
);
1796 pfilter
->map
[RMAP_IN
].name
= XSTRDUP(
1797 MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_IN
].name
);
1798 pfilter
->map
[RMAP_IN
].map
= gfilter
->map
[RMAP_IN
].map
;
1801 /* outbound filter apply */
1802 if (gfilter
->dlist
[out
].name
) {
1803 if (pfilter
->dlist
[out
].name
)
1804 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
1805 pfilter
->dlist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
,
1806 gfilter
->dlist
[out
].name
);
1807 pfilter
->dlist
[out
].alist
= gfilter
->dlist
[out
].alist
;
1809 if (pfilter
->dlist
[out
].name
)
1810 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
1811 pfilter
->dlist
[out
].name
= NULL
;
1812 pfilter
->dlist
[out
].alist
= NULL
;
1815 if (gfilter
->plist
[out
].name
) {
1816 if (pfilter
->plist
[out
].name
)
1817 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
1818 pfilter
->plist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
,
1819 gfilter
->plist
[out
].name
);
1820 pfilter
->plist
[out
].plist
= gfilter
->plist
[out
].plist
;
1822 if (pfilter
->plist
[out
].name
)
1823 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
1824 pfilter
->plist
[out
].name
= NULL
;
1825 pfilter
->plist
[out
].plist
= NULL
;
1828 if (gfilter
->aslist
[out
].name
) {
1829 if (pfilter
->aslist
[out
].name
)
1830 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
1831 pfilter
->aslist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
,
1832 gfilter
->aslist
[out
].name
);
1833 pfilter
->aslist
[out
].aslist
= gfilter
->aslist
[out
].aslist
;
1835 if (pfilter
->aslist
[out
].name
)
1836 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
1837 pfilter
->aslist
[out
].name
= NULL
;
1838 pfilter
->aslist
[out
].aslist
= NULL
;
1841 if (gfilter
->map
[RMAP_OUT
].name
) {
1842 if (pfilter
->map
[RMAP_OUT
].name
)
1843 XFREE(MTYPE_BGP_FILTER_NAME
,
1844 pfilter
->map
[RMAP_OUT
].name
);
1845 pfilter
->map
[RMAP_OUT
].name
= XSTRDUP(
1846 MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_OUT
].name
);
1847 pfilter
->map
[RMAP_OUT
].map
= gfilter
->map
[RMAP_OUT
].map
;
1849 if (pfilter
->map
[RMAP_OUT
].name
)
1850 XFREE(MTYPE_BGP_FILTER_NAME
,
1851 pfilter
->map
[RMAP_OUT
].name
);
1852 pfilter
->map
[RMAP_OUT
].name
= NULL
;
1853 pfilter
->map
[RMAP_OUT
].map
= NULL
;
1856 if (gfilter
->usmap
.name
) {
1857 if (pfilter
->usmap
.name
)
1858 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
1859 pfilter
->usmap
.name
=
1860 XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->usmap
.name
);
1861 pfilter
->usmap
.map
= gfilter
->usmap
.map
;
1863 if (pfilter
->usmap
.name
)
1864 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
1865 pfilter
->usmap
.name
= NULL
;
1866 pfilter
->usmap
.map
= NULL
;
1870 static int peer_activate_af(struct peer
*peer
, afi_t afi
, safi_t safi
)
1874 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1875 zlog_err("%s was called for peer-group %s", __func__
,
1880 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
1882 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1883 || (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1884 return BGP_ERR_PEER_SAFI_CONFLICT
;
1886 /* Nothing to do if we've already activated this peer */
1887 if (peer
->afc
[afi
][safi
])
1890 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1893 active
= peer_active(peer
);
1894 peer
->afc
[afi
][safi
] = 1;
1897 peer_group2peer_config_copy_af(peer
->group
, peer
, afi
, safi
);
1899 if (!active
&& peer_active(peer
)) {
1900 bgp_timer_set(peer
);
1902 if (peer
->status
== Established
) {
1903 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
1904 peer
->afc_adv
[afi
][safi
] = 1;
1905 bgp_capability_send(peer
, afi
, safi
,
1907 CAPABILITY_ACTION_SET
);
1908 if (peer
->afc_recv
[afi
][safi
]) {
1909 peer
->afc_nego
[afi
][safi
] = 1;
1910 bgp_announce_route(peer
, afi
, safi
);
1913 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1914 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1915 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1918 if (peer
->status
== OpenSent
|| peer
->status
== OpenConfirm
) {
1919 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1920 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
1921 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1928 /* Activate the peer or peer group for specified AFI and SAFI. */
1929 int peer_activate(struct peer
*peer
, afi_t afi
, safi_t safi
)
1932 struct peer_group
*group
;
1933 struct listnode
*node
, *nnode
;
1934 struct peer
*tmp_peer
;
1937 /* Nothing to do if we've already activated this peer */
1938 if (peer
->afc
[afi
][safi
])
1943 /* This is a peer-group so activate all of the members of the
1944 * peer-group as well */
1945 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1947 /* Do not activate a peer for both SAFI_UNICAST and
1948 * SAFI_LABELED_UNICAST */
1949 if ((safi
== SAFI_UNICAST
1950 && peer
->afc
[afi
][SAFI_LABELED_UNICAST
])
1951 || (safi
== SAFI_LABELED_UNICAST
1952 && peer
->afc
[afi
][SAFI_UNICAST
]))
1953 return BGP_ERR_PEER_SAFI_CONFLICT
;
1955 peer
->afc
[afi
][safi
] = 1;
1956 group
= peer
->group
;
1958 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
1959 ret
|= peer_activate_af(tmp_peer
, afi
, safi
);
1962 ret
|= peer_activate_af(peer
, afi
, safi
);
1965 /* If this is the first peer to be activated for this
1966 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
1967 if (safi
== SAFI_LABELED_UNICAST
1968 && !bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]) {
1970 if (BGP_DEBUG(zebra
, ZEBRA
))
1972 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
1974 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 1;
1975 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
1981 static int non_peergroup_deactivate_af(struct peer
*peer
, afi_t afi
,
1984 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1985 zlog_err("%s was called for peer-group %s", __func__
,
1990 /* Nothing to do if we've already deactivated this peer */
1991 if (!peer
->afc
[afi
][safi
])
1994 /* De-activate the address family configuration. */
1995 peer
->afc
[afi
][safi
] = 0;
1997 if (peer_af_delete(peer
, afi
, safi
) != 0) {
1998 zlog_err("couldn't delete af structure for peer %s",
2003 if (peer
->status
== Established
) {
2004 if (CHECK_FLAG(peer
->cap
, PEER_CAP_DYNAMIC_RCV
)) {
2005 peer
->afc_adv
[afi
][safi
] = 0;
2006 peer
->afc_nego
[afi
][safi
] = 0;
2008 if (peer_active_nego(peer
)) {
2009 bgp_capability_send(peer
, afi
, safi
,
2011 CAPABILITY_ACTION_UNSET
);
2012 bgp_clear_route(peer
, afi
, safi
);
2013 peer
->pcount
[afi
][safi
] = 0;
2015 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2016 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2017 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2020 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2021 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2022 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2029 int peer_deactivate(struct peer
*peer
, afi_t afi
, safi_t safi
)
2032 struct peer_group
*group
;
2033 struct peer
*tmp_peer
;
2034 struct listnode
*node
, *nnode
;
2037 /* Nothing to do if we've already de-activated this peer */
2038 if (!peer
->afc
[afi
][safi
])
2041 /* This is a peer-group so de-activate all of the members of the
2042 * peer-group as well */
2043 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
2044 peer
->afc
[afi
][safi
] = 0;
2045 group
= peer
->group
;
2047 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2048 zlog_err("couldn't delete af structure for peer %s",
2052 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
2053 ret
|= non_peergroup_deactivate_af(tmp_peer
, afi
, safi
);
2056 ret
|= non_peergroup_deactivate_af(peer
, afi
, safi
);
2061 /* If this is the last peer to be deactivated for this
2062 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2063 if (safi
== SAFI_LABELED_UNICAST
2064 && bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
]
2065 && !bgp_afi_safi_peer_exists(bgp
, afi
, safi
)) {
2067 if (BGP_DEBUG(zebra
, ZEBRA
))
2069 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2071 bgp
->allocate_mpls_labels
[afi
][SAFI_UNICAST
] = 0;
2072 bgp_recalculate_afi_safi_bestpaths(bgp
, afi
, SAFI_UNICAST
);
2077 int peer_afc_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
2080 return peer_activate(peer
, afi
, safi
);
2082 return peer_deactivate(peer
, afi
, safi
);
2085 static void peer_nsf_stop(struct peer
*peer
)
2090 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
);
2091 UNSET_FLAG(peer
->sflags
, PEER_STATUS_NSF_MODE
);
2093 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2094 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MPLS_VPN
; safi
++)
2095 peer
->nsf
[afi
][safi
] = 0;
2097 if (peer
->t_gr_restart
) {
2098 BGP_TIMER_OFF(peer
->t_gr_restart
);
2099 if (bgp_debug_neighbor_events(peer
))
2100 zlog_debug("%s graceful restart timer stopped",
2103 if (peer
->t_gr_stale
) {
2104 BGP_TIMER_OFF(peer
->t_gr_stale
);
2105 if (bgp_debug_neighbor_events(peer
))
2107 "%s graceful restart stalepath timer stopped",
2110 bgp_clear_route_all(peer
);
2113 /* Delete peer from confguration.
2115 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2116 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2118 * This function /should/ take care to be idempotent, to guard against
2119 * it being called multiple times through stray events that come in
2120 * that happen to result in this function being called again. That
2121 * said, getting here for a "Deleted" peer is a bug in the neighbour
2124 int peer_delete(struct peer
*peer
)
2130 struct bgp_filter
*filter
;
2131 struct listnode
*pn
;
2134 assert(peer
->status
!= Deleted
);
2137 accept_peer
= CHECK_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2139 bgp_reads_off(peer
);
2140 bgp_writes_off(peer
);
2141 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_WRITES_ON
));
2142 assert(!CHECK_FLAG(peer
->thread_flags
, PEER_THREAD_READS_ON
));
2144 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2145 peer_nsf_stop(peer
);
2147 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2149 /* If this peer belongs to peer group, clear up the
2152 if (peer_dynamic_neighbor(peer
))
2153 peer_drop_dynamic_neighbor(peer
);
2155 if ((pn
= listnode_lookup(peer
->group
->peer
, peer
))) {
2157 peer
); /* group->peer list reference */
2158 list_delete_node(peer
->group
->peer
, pn
);
2163 /* Withdraw all information from routing table. We can not use
2164 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2165 * executed after peer structure is deleted.
2167 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2169 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2171 if (peer
->doppelganger
) {
2172 peer
->doppelganger
->doppelganger
= NULL
;
2173 peer
->doppelganger
= NULL
;
2176 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2177 bgp_fsm_change_status(peer
, Deleted
);
2179 /* Remove from NHT */
2180 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2181 bgp_unlink_nexthop_by_peer(peer
);
2183 /* Password configuration */
2184 if (peer
->password
) {
2185 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
2186 peer
->password
= NULL
;
2188 if (!accept_peer
&& !BGP_PEER_SU_UNSPEC(peer
)
2189 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
2190 bgp_md5_unset(peer
);
2193 bgp_timer_set(peer
); /* stops all timers for Deleted */
2195 /* Delete from all peer list. */
2196 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
2197 && (pn
= listnode_lookup(bgp
->peer
, peer
))) {
2198 peer_unlock(peer
); /* bgp peer list reference */
2199 list_delete_node(bgp
->peer
, pn
);
2200 hash_release(bgp
->peerhash
, peer
);
2205 stream_fifo_free(peer
->ibuf
);
2210 stream_fifo_free(peer
->obuf
);
2214 if (peer
->ibuf_work
) {
2215 ringbuf_del(peer
->ibuf_work
);
2216 peer
->ibuf_work
= NULL
;
2219 if (peer
->obuf_work
) {
2220 stream_free(peer
->obuf_work
);
2221 peer
->obuf_work
= NULL
;
2224 if (peer
->scratch
) {
2225 stream_free(peer
->scratch
);
2226 peer
->scratch
= NULL
;
2229 /* Local and remote addresses. */
2230 if (peer
->su_local
) {
2231 sockunion_free(peer
->su_local
);
2232 peer
->su_local
= NULL
;
2235 if (peer
->su_remote
) {
2236 sockunion_free(peer
->su_remote
);
2237 peer
->su_remote
= NULL
;
2240 /* Free filter related memory. */
2241 FOREACH_AFI_SAFI (afi
, safi
) {
2242 filter
= &peer
->filter
[afi
][safi
];
2244 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++) {
2245 if (filter
->dlist
[i
].name
) {
2246 XFREE(MTYPE_BGP_FILTER_NAME
,
2247 filter
->dlist
[i
].name
);
2248 filter
->dlist
[i
].name
= NULL
;
2251 if (filter
->plist
[i
].name
) {
2252 XFREE(MTYPE_BGP_FILTER_NAME
,
2253 filter
->plist
[i
].name
);
2254 filter
->plist
[i
].name
= NULL
;
2257 if (filter
->aslist
[i
].name
) {
2258 XFREE(MTYPE_BGP_FILTER_NAME
,
2259 filter
->aslist
[i
].name
);
2260 filter
->aslist
[i
].name
= NULL
;
2264 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++) {
2265 if (filter
->map
[i
].name
) {
2266 XFREE(MTYPE_BGP_FILTER_NAME
,
2267 filter
->map
[i
].name
);
2268 filter
->map
[i
].name
= NULL
;
2272 if (filter
->usmap
.name
) {
2273 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2274 filter
->usmap
.name
= NULL
;
2277 if (peer
->default_rmap
[afi
][safi
].name
) {
2278 XFREE(MTYPE_ROUTE_MAP_NAME
,
2279 peer
->default_rmap
[afi
][safi
].name
);
2280 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2284 FOREACH_AFI_SAFI (afi
, safi
)
2285 peer_af_delete(peer
, afi
, safi
);
2287 if (peer
->hostname
) {
2288 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2289 peer
->hostname
= NULL
;
2292 if (peer
->domainname
) {
2293 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2294 peer
->domainname
= NULL
;
2297 peer_unlock(peer
); /* initial reference */
2302 static int peer_group_cmp(struct peer_group
*g1
, struct peer_group
*g2
)
2304 return strcmp(g1
->name
, g2
->name
);
2307 /* Peer group cofiguration. */
2308 static struct peer_group
*peer_group_new(void)
2310 return (struct peer_group
*)XCALLOC(MTYPE_PEER_GROUP
,
2311 sizeof(struct peer_group
));
2314 static void peer_group_free(struct peer_group
*group
)
2316 XFREE(MTYPE_PEER_GROUP
, group
);
2319 struct peer_group
*peer_group_lookup(struct bgp
*bgp
, const char *name
)
2321 struct peer_group
*group
;
2322 struct listnode
*node
, *nnode
;
2324 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
2325 if (strcmp(group
->name
, name
) == 0)
2331 struct peer_group
*peer_group_get(struct bgp
*bgp
, const char *name
)
2333 struct peer_group
*group
;
2336 group
= peer_group_lookup(bgp
, name
);
2340 group
= peer_group_new();
2343 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2344 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2345 group
->peer
= list_new();
2346 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2347 group
->listen_range
[afi
] = list_new();
2348 group
->conf
= peer_new(bgp
);
2349 if (!bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2350 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2351 if (group
->conf
->host
)
2352 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2353 group
->conf
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, name
);
2354 group
->conf
->group
= group
;
2355 group
->conf
->as
= 0;
2356 group
->conf
->ttl
= 1;
2357 group
->conf
->gtsm_hops
= 0;
2358 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2359 UNSET_FLAG(group
->conf
->config
, PEER_CONFIG_TIMER
);
2360 UNSET_FLAG(group
->conf
->config
, PEER_GROUP_CONFIG_TIMER
);
2361 UNSET_FLAG(group
->conf
->config
, PEER_CONFIG_CONNECT
);
2362 group
->conf
->keepalive
= 0;
2363 group
->conf
->holdtime
= 0;
2364 group
->conf
->connect
= 0;
2365 SET_FLAG(group
->conf
->sflags
, PEER_STATUS_GROUP
);
2366 listnode_add_sort(bgp
->group
, group
);
2371 static void peer_group2peer_config_copy(struct peer_group
*group
,
2375 int saved_flags
= 0;
2381 peer
->as
= conf
->as
;
2384 if (conf
->change_local_as
)
2385 peer
->change_local_as
= conf
->change_local_as
;
2388 peer
->ttl
= conf
->ttl
;
2391 peer
->gtsm_hops
= conf
->gtsm_hops
;
2393 /* These are per-peer specific flags and so we must preserve them */
2394 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2395 saved_flags
|= CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
);
2396 peer
->flags
= conf
->flags
;
2397 SET_FLAG(peer
->flags
, saved_flags
);
2399 /* peer config apply */
2400 peer
->config
= conf
->config
;
2402 /* peer timers apply */
2403 peer
->holdtime
= conf
->holdtime
;
2404 peer
->keepalive
= conf
->keepalive
;
2405 peer
->connect
= conf
->connect
;
2406 if (CHECK_FLAG(conf
->config
, PEER_CONFIG_CONNECT
))
2407 peer
->v_connect
= conf
->connect
;
2409 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2411 /* advertisement-interval reset */
2412 if (CHECK_FLAG(conf
->config
, PEER_CONFIG_ROUTEADV
))
2413 peer
->v_routeadv
= conf
->routeadv
;
2414 else if (peer_sort(peer
) == BGP_PEER_IBGP
)
2415 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2417 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2419 /* password apply */
2420 if (conf
->password
&& !peer
->password
)
2421 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, conf
->password
);
2423 if (!BGP_PEER_SU_UNSPEC(peer
))
2426 /* update-source apply */
2427 if (conf
->update_source
) {
2428 if (peer
->update_source
)
2429 sockunion_free(peer
->update_source
);
2430 if (peer
->update_if
) {
2431 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2432 peer
->update_if
= NULL
;
2434 peer
->update_source
= sockunion_dup(conf
->update_source
);
2435 } else if (conf
->update_if
) {
2436 if (peer
->update_if
)
2437 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2438 if (peer
->update_source
) {
2439 sockunion_free(peer
->update_source
);
2440 peer
->update_source
= NULL
;
2443 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2446 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2449 /* Peer group's remote AS configuration. */
2450 int peer_group_remote_as(struct bgp
*bgp
, const char *group_name
, as_t
*as
,
2453 struct peer_group
*group
;
2455 struct listnode
*node
, *nnode
;
2457 group
= peer_group_lookup(bgp
, group_name
);
2461 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2465 /* When we setup peer-group AS number all peer group member's AS
2466 number must be updated to same number. */
2467 peer_as_change(group
->conf
, *as
, as_type
);
2469 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2470 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
)
2471 || (peer
->as_type
!= as_type
))
2472 peer_as_change(peer
, *as
, as_type
);
2478 int peer_group_delete(struct peer_group
*group
)
2482 struct prefix
*prefix
;
2484 struct listnode
*node
, *nnode
;
2489 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2490 other
= peer
->doppelganger
;
2492 if (other
&& other
->status
!= Deleted
) {
2493 other
->group
= NULL
;
2497 list_delete_and_null(&group
->peer
);
2499 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2500 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
2502 prefix_free(prefix
);
2504 list_delete_and_null(&group
->listen_range
[afi
]);
2507 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2510 bfd_info_free(&(group
->conf
->bfd_info
));
2512 group
->conf
->group
= NULL
;
2513 peer_delete(group
->conf
);
2515 /* Delete from all peer_group list. */
2516 listnode_delete(bgp
->group
, group
);
2518 peer_group_free(group
);
2523 int peer_group_remote_as_delete(struct peer_group
*group
)
2525 struct peer
*peer
, *other
;
2526 struct listnode
*node
, *nnode
;
2528 if ((group
->conf
->as_type
== AS_UNSPECIFIED
)
2529 || ((!group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2532 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2533 other
= peer
->doppelganger
;
2537 if (other
&& other
->status
!= Deleted
) {
2538 other
->group
= NULL
;
2542 list_delete_all_node(group
->peer
);
2544 group
->conf
->as
= 0;
2545 group
->conf
->as_type
= AS_UNSPECIFIED
;
2550 int peer_group_listen_range_add(struct peer_group
*group
, struct prefix
*range
)
2552 struct prefix
*prefix
;
2553 struct listnode
*node
, *nnode
;
2556 afi
= family2afi(range
->family
);
2558 /* Group needs remote AS configured. */
2559 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2560 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2562 /* Ensure no duplicates. Currently we don't care about overlaps. */
2563 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2564 if (prefix_same(range
, prefix
))
2568 prefix
= prefix_new();
2569 prefix_copy(prefix
, range
);
2570 listnode_add(group
->listen_range
[afi
], prefix
);
2574 int peer_group_listen_range_del(struct peer_group
*group
, struct prefix
*range
)
2576 struct prefix
*prefix
, prefix2
;
2577 struct listnode
*node
, *nnode
;
2580 char buf
[PREFIX2STR_BUFFER
];
2582 afi
= family2afi(range
->family
);
2584 /* Identify the listen range. */
2585 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
, prefix
)) {
2586 if (prefix_same(range
, prefix
))
2591 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2593 prefix2str(prefix
, buf
, sizeof(buf
));
2595 /* Dispose off any dynamic neighbors that exist due to this listen range
2597 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
2598 if (!peer_dynamic_neighbor(peer
))
2601 sockunion2hostprefix(&peer
->su
, &prefix2
);
2602 if (prefix_match(prefix
, &prefix2
)) {
2603 if (bgp_debug_neighbor_events(peer
))
2605 "Deleting dynamic neighbor %s group %s upon "
2606 "delete of listen range %s",
2607 peer
->host
, group
->name
, buf
);
2612 /* Get rid of the listen range */
2613 listnode_delete(group
->listen_range
[afi
], prefix
);
2618 /* Bind specified peer to peer group. */
2619 int peer_group_bind(struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2620 struct peer_group
*group
, as_t
*as
)
2622 int first_member
= 0;
2625 int cap_enhe_preset
= 0;
2627 /* Lookup the peer. */
2629 peer
= peer_lookup(bgp
, su
);
2631 /* The peer exist, bind it to the peer-group */
2633 /* When the peer already belongs to a peer-group, check the
2635 if (peer_group_active(peer
)) {
2637 /* The peer is already bound to the peer-group,
2640 if (strcmp(peer
->group
->name
, group
->name
) == 0)
2643 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2646 /* The peer has not specified a remote-as, inherit it from the
2648 if (peer
->as_type
== AS_UNSPECIFIED
) {
2649 peer
->as_type
= group
->conf
->as_type
;
2650 peer
->as
= group
->conf
->as
;
2653 if (!group
->conf
->as
) {
2654 if (peer_sort(group
->conf
) != BGP_PEER_INTERNAL
2655 && peer_sort(group
->conf
) != peer_sort(peer
)) {
2658 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2661 if (peer_sort(group
->conf
) == BGP_PEER_INTERNAL
)
2665 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2666 cap_enhe_preset
= 1;
2668 peer_group2peer_config_copy(group
, peer
);
2671 * Capability extended-nexthop is enabled for an interface
2673 * default. So, fix that up here.
2675 if (peer
->conf_if
&& cap_enhe_preset
)
2676 peer_flag_set(peer
, PEER_FLAG_CAPABILITY_ENHE
);
2678 FOREACH_AFI_SAFI (afi
, safi
) {
2679 if (group
->conf
->afc
[afi
][safi
]) {
2680 peer
->afc
[afi
][safi
] = 1;
2682 if (peer_af_find(peer
, afi
, safi
)
2683 || peer_af_create(peer
, afi
, safi
)) {
2684 peer_group2peer_config_copy_af(
2685 group
, peer
, afi
, safi
);
2687 } else if (peer
->afc
[afi
][safi
])
2688 peer_deactivate(peer
, afi
, safi
);
2692 assert(group
&& peer
->group
== group
);
2694 struct listnode
*pn
;
2695 pn
= listnode_lookup(bgp
->peer
, peer
);
2696 list_delete_node(bgp
->peer
, pn
);
2697 peer
->group
= group
;
2698 listnode_add_sort(bgp
->peer
, peer
);
2700 peer
= peer_lock(peer
); /* group->peer list reference */
2701 listnode_add(group
->peer
, peer
);
2705 /* Advertisement-interval reset */
2706 if (!CHECK_FLAG(group
->conf
->config
,
2707 PEER_CONFIG_ROUTEADV
)) {
2708 if (peer_sort(group
->conf
) == BGP_PEER_IBGP
)
2709 group
->conf
->v_routeadv
=
2710 BGP_DEFAULT_IBGP_ROUTEADV
;
2712 group
->conf
->v_routeadv
=
2713 BGP_DEFAULT_EBGP_ROUTEADV
;
2716 /* ebgp-multihop reset */
2717 if (peer_sort(group
->conf
) == BGP_PEER_IBGP
)
2718 group
->conf
->ttl
= MAXTTL
;
2720 /* local-as reset */
2721 if (peer_sort(group
->conf
) != BGP_PEER_EBGP
) {
2722 group
->conf
->change_local_as
= 0;
2723 UNSET_FLAG(peer
->flags
,
2724 PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2725 UNSET_FLAG(peer
->flags
,
2726 PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2730 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2732 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2733 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2734 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2735 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2737 bgp_session_reset(peer
);
2741 /* Create a new peer. */
2743 if ((group
->conf
->as_type
== AS_SPECIFIED
)
2744 && (!group
->conf
->as
)) {
2745 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2748 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
2749 group
->conf
->as_type
, 0, 0, group
);
2751 peer
= peer_lock(peer
); /* group->peer list reference */
2752 listnode_add(group
->peer
, peer
);
2754 peer_group2peer_config_copy(group
, peer
);
2756 /* If the peer-group is active for this afi/safi then activate
2758 FOREACH_AFI_SAFI (afi
, safi
) {
2759 if (group
->conf
->afc
[afi
][safi
]) {
2760 peer
->afc
[afi
][safi
] = 1;
2761 peer_af_create(peer
, afi
, safi
);
2762 peer_group2peer_config_copy_af(group
, peer
, afi
,
2764 } else if (peer
->afc
[afi
][safi
])
2765 peer_deactivate(peer
, afi
, safi
);
2768 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2770 /* Set up peer's events and timers. */
2771 if (peer_active(peer
))
2772 bgp_timer_set(peer
);
2778 int peer_group_unbind(struct bgp
*bgp
, struct peer
*peer
,
2779 struct peer_group
*group
)
2785 if (group
!= peer
->group
)
2786 return BGP_ERR_PEER_GROUP_MISMATCH
;
2788 FOREACH_AFI_SAFI (afi
, safi
) {
2789 if (peer
->afc
[afi
][safi
]) {
2790 peer
->afc
[afi
][safi
] = 0;
2791 peer_af_flag_reset(peer
, afi
, safi
);
2793 if (peer_af_delete(peer
, afi
, safi
) != 0) {
2795 "couldn't delete af structure for peer %s",
2801 assert(listnode_lookup(group
->peer
, peer
));
2802 peer_unlock(peer
); /* peer group list reference */
2803 listnode_delete(group
->peer
, peer
);
2805 other
= peer
->doppelganger
;
2807 if (group
->conf
->as
) {
2809 if (other
&& other
->status
!= Deleted
) {
2812 listnode_delete(group
->peer
, other
);
2814 other
->group
= NULL
;
2820 bgp_bfd_deregister_peer(peer
);
2821 peer_global_config_reset(peer
);
2823 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
2824 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2825 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
2826 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2828 bgp_session_reset(peer
);
2833 static int bgp_startup_timer_expire(struct thread
*thread
)
2837 bgp
= THREAD_ARG(thread
);
2838 bgp
->t_startup
= NULL
;
2843 /* BGP instance creation by `router bgp' commands. */
2844 static struct bgp
*bgp_create(as_t
*as
, const char *name
,
2845 enum bgp_instance_type inst_type
)
2851 if ((bgp
= XCALLOC(MTYPE_BGP
, sizeof(struct bgp
))) == NULL
)
2854 if (BGP_DEBUG(zebra
, ZEBRA
)) {
2855 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2856 zlog_debug("Creating Default VRF, AS %u", *as
);
2858 zlog_debug("Creating %s %s, AS %u",
2859 (inst_type
== BGP_INSTANCE_TYPE_VRF
)
2866 bgp
->inst_type
= inst_type
;
2867 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ? VRF_DEFAULT
2869 bgp
->peer_self
= peer_new(bgp
);
2870 if (bgp
->peer_self
->host
)
2871 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2872 bgp
->peer_self
->host
=
2873 XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2874 if (bgp
->peer_self
->hostname
!= NULL
) {
2875 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->hostname
);
2876 bgp
->peer_self
->hostname
= NULL
;
2878 if (cmd_hostname_get())
2879 bgp
->peer_self
->hostname
=
2880 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_hostname_get());
2882 if (bgp
->peer_self
->domainname
!= NULL
) {
2883 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->domainname
);
2884 bgp
->peer_self
->domainname
= NULL
;
2886 if (cmd_domainname_get())
2887 bgp
->peer_self
->domainname
=
2888 XSTRDUP(MTYPE_BGP_PEER_HOST
, cmd_domainname_get());
2889 bgp
->peer
= list_new();
2890 bgp
->peer
->cmp
= (int (*)(void *, void *))peer_cmp
;
2891 bgp
->peerhash
= hash_create(peer_hash_key_make
, peer_hash_same
,
2893 bgp
->peerhash
->max_size
= BGP_PEER_MAX_HASH_SIZE
;
2895 bgp
->group
= list_new();
2896 bgp
->group
->cmp
= (int (*)(void *, void *))peer_group_cmp
;
2898 FOREACH_AFI_SAFI (afi
, safi
) {
2899 bgp
->route
[afi
][safi
] = bgp_table_init(afi
, safi
);
2900 bgp
->aggregate
[afi
][safi
] = bgp_table_init(afi
, safi
);
2901 bgp
->rib
[afi
][safi
] = bgp_table_init(afi
, safi
);
2903 /* Enable maximum-paths */
2904 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_EBGP
,
2906 bgp_maximum_paths_set(bgp
, afi
, safi
, BGP_PEER_IBGP
,
2910 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2911 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2912 bgp
->default_subgroup_pkt_queue_max
=
2913 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2914 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2915 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2916 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2917 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2918 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2919 bgp
->dynamic_neighbors_count
= 0;
2920 #if DFLT_BGP_IMPORT_CHECK
2921 bgp_flag_set(bgp
, BGP_FLAG_IMPORT_CHECK
);
2923 #if DFLT_BGP_SHOW_HOSTNAME
2924 bgp_flag_set(bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2926 #if DFLT_BGP_LOG_NEIGHBOR_CHANGES
2927 bgp_flag_set(bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2929 #if DFLT_BGP_DETERMINISTIC_MED
2930 bgp_flag_set(bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2932 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2937 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
) {
2938 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2940 assert(bgp
->rfapi_cfg
);
2942 #endif /* ENABLE_BGP_VNC */
2944 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
2945 bgp
->vpn_policy
[afi
].tovpn_label
= MPLS_LABEL_NONE
;
2946 bgp
->vpn_policy
[afi
].tovpn_zebra_vrf_label_last_sent
=
2950 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2952 /* TODO - The startup timer needs to be run for the whole of BGP
2954 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
2955 bgp
->restart_time
, &bgp
->t_startup
);
2958 atomic_store_explicit(&bgp
->wpkt_quanta
, BGP_WRITE_PACKET_MAX
,
2959 memory_order_relaxed
);
2960 atomic_store_explicit(&bgp
->rpkt_quanta
, BGP_READ_PACKET_MAX
,
2961 memory_order_relaxed
);
2962 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
2966 update_bgp_group_init(bgp
);
2971 /* Return the "default VRF" instance of BGP. */
2972 struct bgp
*bgp_get_default(void)
2975 struct listnode
*node
, *nnode
;
2977 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
2978 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2983 /* Lookup BGP entry. */
2984 struct bgp
*bgp_lookup(as_t as
, const char *name
)
2987 struct listnode
*node
, *nnode
;
2989 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
2991 && ((bgp
->name
== NULL
&& name
== NULL
)
2992 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0)))
2997 /* Lookup BGP structure by view name. */
2998 struct bgp
*bgp_lookup_by_name(const char *name
)
3001 struct listnode
*node
, *nnode
;
3003 for (ALL_LIST_ELEMENTS(bm
->bgp
, node
, nnode
, bgp
))
3004 if ((bgp
->name
== NULL
&& name
== NULL
)
3005 || (bgp
->name
&& name
&& strcmp(bgp
->name
, name
) == 0))
3010 /* Lookup BGP instance based on VRF id. */
3011 /* Note: Only to be used for incoming messages from Zebra. */
3012 struct bgp
*bgp_lookup_by_vrf_id(vrf_id_t vrf_id
)
3016 /* Lookup VRF (in tree) and follow link. */
3017 vrf
= vrf_lookup_by_id(vrf_id
);
3020 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3023 /* handle socket creation or deletion, if necessary
3024 * this is called for all new BGP instances
3026 int bgp_handle_socket(struct bgp
*bgp
, struct vrf
*vrf
, vrf_id_t old_vrf_id
,
3031 /* Create BGP server socket, if listen mode not disabled */
3032 if (!bgp
|| bgp_option_check(BGP_OPT_NO_LISTEN
))
3034 if (bgp
->name
&& bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
&& vrf
) {
3036 * suppress vrf socket
3038 if (create
== FALSE
) {
3039 if (vrf_is_mapped_on_netns(vrf
->vrf_id
))
3040 bgp_close_vrf_socket(bgp
);
3042 ret
= bgp_check_main_socket(create
, bgp
);
3046 * if vrf_id did not change
3048 if (vrf
->vrf_id
== old_vrf_id
)
3050 if (old_vrf_id
!= VRF_UNKNOWN
) {
3051 /* look for old socket. close it. */
3052 bgp_close_vrf_socket(bgp
);
3054 /* if backend is not yet identified ( VRF_UNKNOWN) then
3055 * creation will be done later
3057 if (vrf
->vrf_id
== VRF_UNKNOWN
)
3059 /* if BGP VRF instance requested
3060 * if backend is NETNS, create BGP server socket in the NETNS
3062 if (vrf_is_mapped_on_netns(bgp
->vrf_id
)) {
3063 ret
= bgp_socket(bgp
, bm
->port
, bm
->address
);
3065 return BGP_ERR_INVALID_VALUE
;
3069 /* if BGP VRF instance requested or VRF lite backend
3070 * if BGP non VRF instance, create it
3071 * if not already done
3073 return bgp_check_main_socket(create
, bgp
);
3076 /* Called from VTY commands. */
3077 int bgp_get(struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3078 enum bgp_instance_type inst_type
)
3081 struct vrf
*vrf
= NULL
;
3083 /* Multiple instance check. */
3084 if (bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
3086 bgp
= bgp_lookup_by_name(name
);
3088 bgp
= bgp_get_default();
3090 /* Already exists. */
3092 if (bgp
->as
!= *as
) {
3094 return BGP_ERR_INSTANCE_MISMATCH
;
3096 if (bgp
->inst_type
!= inst_type
)
3097 return BGP_ERR_INSTANCE_MISMATCH
;
3102 /* BGP instance name can not be specified for single instance.
3105 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3107 /* Get default BGP structure if exists. */
3108 bgp
= bgp_get_default();
3111 if (bgp
->as
!= *as
) {
3113 return BGP_ERR_AS_MISMATCH
;
3120 bgp
= bgp_create(as
, name
, inst_type
);
3121 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3122 bgp_address_init(bgp
);
3123 bgp_tip_hash_init(bgp
);
3127 bgp
->t_rmap_def_originate_eval
= NULL
;
3129 /* If Default instance or VRF, link to the VRF structure, if present. */
3130 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
3131 || bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
3132 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3134 bgp_vrf_link(bgp
, vrf
);
3136 /* BGP server socket already processed if BGP instance
3137 * already part of the list
3139 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, true);
3140 listnode_add(bm
->bgp
, bgp
);
3142 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3143 bgp_zebra_instance_register(bgp
);
3150 * Make BGP instance "up". Applies only to VRFs (non-default) and
3151 * implies the VRF has been learnt from Zebra.
3153 void bgp_instance_up(struct bgp
*bgp
)
3156 struct listnode
*node
, *next
;
3158 /* Register with zebra. */
3159 bgp_zebra_instance_register(bgp
);
3161 /* Kick off any peers that may have been configured. */
3162 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3163 if (!BGP_PEER_START_SUPPRESSED(peer
))
3164 BGP_EVENT_ADD(peer
, BGP_Start
);
3167 /* Process any networks that have been configured. */
3168 bgp_static_add(bgp
);
3172 * Make BGP instance "down". Applies only to VRFs (non-default) and
3173 * implies the VRF has been deleted by Zebra.
3175 void bgp_instance_down(struct bgp
*bgp
)
3178 struct listnode
*node
;
3179 struct listnode
*next
;
3182 if (bgp
->t_rmap_def_originate_eval
) {
3183 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3184 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3188 /* Bring down peers, so corresponding routes are purged. */
3189 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3190 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3191 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3192 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3194 bgp_session_reset(peer
);
3197 /* Purge network and redistributed routes. */
3198 bgp_purge_static_redist_routes(bgp
);
3200 /* Cleanup registered nexthops (flags) */
3201 bgp_cleanup_nexthops(bgp
);
3204 /* Delete BGP instance. */
3205 int bgp_delete(struct bgp
*bgp
)
3208 struct peer_group
*group
;
3209 struct listnode
*node
, *next
;
3214 THREAD_OFF(bgp
->t_startup
);
3216 if (BGP_DEBUG(zebra
, ZEBRA
)) {
3217 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3218 zlog_debug("Deleting Default VRF");
3220 zlog_debug("Deleting %s %s",
3221 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3227 /* unmap from RT list */
3228 bgp_evpn_vrf_delete(bgp
);
3231 if (bgp
->t_rmap_def_originate_eval
) {
3232 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3233 bgp_unlock(bgp
); /* TODO - This timer is started with a lock -
3237 /* Inform peers we're going down. */
3238 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
)) {
3239 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3240 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3241 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3244 /* Delete static routes (networks). */
3245 bgp_static_delete(bgp
);
3247 /* Unset redistribution. */
3248 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3249 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3250 if (i
!= ZEBRA_ROUTE_BGP
)
3251 bgp_redistribute_unset(bgp
, afi
, i
, 0);
3253 /* Free peers and peer-groups. */
3254 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, next
, group
))
3255 peer_group_delete(group
);
3257 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, next
, peer
))
3260 if (bgp
->peer_self
) {
3261 peer_delete(bgp
->peer_self
);
3262 bgp
->peer_self
= NULL
;
3265 update_bgp_group_free(bgp
);
3267 /* TODO - Other memory may need to be freed - e.g., NHT */
3272 bgp_cleanup_routes(bgp
);
3274 /* Remove visibility via the master list - there may however still be
3275 * routes to be processed still referencing the struct bgp.
3277 listnode_delete(bm
->bgp
, bgp
);
3279 /* Deregister from Zebra, if needed */
3280 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3281 bgp_zebra_instance_deregister(bgp
);
3283 /* Free interfaces in this instance. */
3286 vrf
= bgp_vrf_lookup_by_instance_type(bgp
);
3287 bgp_handle_socket(bgp
, vrf
, VRF_UNKNOWN
, false);
3289 bgp_vrf_unlink(bgp
, vrf
);
3291 thread_master_free_unused(bm
->master
);
3292 bgp_unlock(bgp
); /* initial reference */
3297 void bgp_free(struct bgp
*bgp
)
3301 struct bgp_table
*table
;
3302 struct bgp_node
*rn
;
3303 struct bgp_rmap
*rmap
;
3307 list_delete_and_null(&bgp
->group
);
3308 list_delete_and_null(&bgp
->peer
);
3310 if (bgp
->peerhash
) {
3311 hash_free(bgp
->peerhash
);
3312 bgp
->peerhash
= NULL
;
3315 FOREACH_AFI_SAFI (afi
, safi
) {
3316 /* Special handling for 2-level routing tables. */
3317 if (safi
== SAFI_MPLS_VPN
|| safi
== SAFI_ENCAP
3318 || safi
== SAFI_EVPN
) {
3319 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
3320 rn
= bgp_route_next(rn
)) {
3321 table
= (struct bgp_table
*)rn
->info
;
3322 bgp_table_finish(&table
);
3325 if (bgp
->route
[afi
][safi
])
3326 bgp_table_finish(&bgp
->route
[afi
][safi
]);
3327 if (bgp
->aggregate
[afi
][safi
])
3328 bgp_table_finish(&bgp
->aggregate
[afi
][safi
]);
3329 if (bgp
->rib
[afi
][safi
])
3330 bgp_table_finish(&bgp
->rib
[afi
][safi
]);
3331 rmap
= &bgp
->table_map
[afi
][safi
];
3333 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap
->name
);
3336 bgp_scan_finish(bgp
);
3337 bgp_address_destroy(bgp
);
3338 bgp_tip_hash_destroy(bgp
);
3340 bgp_evpn_cleanup(bgp
);
3343 XFREE(MTYPE_BGP
, bgp
->name
);
3345 XFREE(MTYPE_BGP
, bgp
);
3348 struct peer
*peer_lookup_by_conf_if(struct bgp
*bgp
, const char *conf_if
)
3351 struct listnode
*node
, *nnode
;
3357 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3358 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3359 && !CHECK_FLAG(peer
->sflags
,
3360 PEER_STATUS_ACCEPT_PEER
))
3362 } else if (bm
->bgp
!= NULL
) {
3363 struct listnode
*bgpnode
, *nbgpnode
;
3365 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3366 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3368 && !strcmp(peer
->conf_if
, conf_if
)
3369 && !CHECK_FLAG(peer
->sflags
,
3370 PEER_STATUS_ACCEPT_PEER
))
3376 struct peer
*peer_lookup_by_hostname(struct bgp
*bgp
, const char *hostname
)
3379 struct listnode
*node
, *nnode
;
3385 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3386 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3387 && !CHECK_FLAG(peer
->sflags
,
3388 PEER_STATUS_ACCEPT_PEER
))
3390 } else if (bm
->bgp
!= NULL
) {
3391 struct listnode
*bgpnode
, *nbgpnode
;
3393 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3394 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
3396 && !strcmp(peer
->hostname
, hostname
)
3397 && !CHECK_FLAG(peer
->sflags
,
3398 PEER_STATUS_ACCEPT_PEER
))
3404 struct peer
*peer_lookup(struct bgp
*bgp
, union sockunion
*su
)
3406 struct peer
*peer
= NULL
;
3407 struct peer tmp_peer
;
3409 memset(&tmp_peer
, 0, sizeof(struct peer
));
3412 * We do not want to find the doppelganger peer so search for the peer
3414 * the hash that has PEER_FLAG_CONFIG_NODE
3416 SET_FLAG(tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3421 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3422 } else if (bm
->bgp
!= NULL
) {
3423 struct listnode
*bgpnode
, *nbgpnode
;
3425 for (ALL_LIST_ELEMENTS(bm
->bgp
, bgpnode
, nbgpnode
, bgp
)) {
3426 /* Skip VRFs Lite only, this function will not be
3427 * invoked without an instance
3428 * when examining VRFs.
3430 if ((bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3431 && !vrf_is_mapped_on_netns(bgp
->vrf_id
))
3434 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3444 struct peer
*peer_create_bind_dynamic_neighbor(struct bgp
*bgp
,
3445 union sockunion
*su
,
3446 struct peer_group
*group
)
3452 /* Create peer first; we've already checked group config is valid. */
3453 peer
= peer_create(su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
,
3454 group
->conf
->as_type
, 0, 0, group
);
3459 peer
= peer_lock(peer
);
3460 listnode_add(group
->peer
, peer
);
3462 peer_group2peer_config_copy(group
, peer
);
3465 * Bind peer for all AFs configured for the group. We don't call
3466 * peer_group_bind as that is sub-optimal and does some stuff we don't
3469 FOREACH_AFI_SAFI (afi
, safi
) {
3470 if (!group
->conf
->afc
[afi
][safi
])
3472 peer
->afc
[afi
][safi
] = 1;
3474 if (!peer_af_find(peer
, afi
, safi
))
3475 peer_af_create(peer
, afi
, safi
);
3477 peer_group2peer_config_copy_af(group
, peer
, afi
, safi
);
3480 /* Mark as dynamic, but also as a "config node" for other things to
3482 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3483 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3489 peer_group_lookup_dynamic_neighbor_range(struct peer_group
*group
,
3490 struct prefix
*prefix
)
3492 struct listnode
*node
, *nnode
;
3493 struct prefix
*range
;
3496 afi
= family2afi(prefix
->family
);
3498 if (group
->listen_range
[afi
])
3499 for (ALL_LIST_ELEMENTS(group
->listen_range
[afi
], node
, nnode
,
3501 if (prefix_match(range
, prefix
))
3508 peer_group_lookup_dynamic_neighbor(struct bgp
*bgp
, struct prefix
*prefix
,
3509 struct prefix
**listen_range
)
3511 struct prefix
*range
= NULL
;
3512 struct peer_group
*group
= NULL
;
3513 struct listnode
*node
, *nnode
;
3515 *listen_range
= NULL
;
3517 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
3518 if ((range
= peer_group_lookup_dynamic_neighbor_range(
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
->group
, node
, nnode
, group
))
3526 if ((range
= peer_group_lookup_dynamic_neighbor_range(
3532 *listen_range
= range
;
3533 return (group
&& range
) ? group
: NULL
;
3536 struct peer
*peer_lookup_dynamic_neighbor(struct bgp
*bgp
, union sockunion
*su
)
3538 struct peer_group
*group
;
3541 struct prefix prefix
;
3542 struct prefix
*listen_range
;
3544 char buf
[PREFIX2STR_BUFFER
];
3545 char buf1
[PREFIX2STR_BUFFER
];
3547 sockunion2hostprefix(su
, &prefix
);
3549 /* See if incoming connection matches a configured listen range. */
3550 group
= peer_group_lookup_dynamic_neighbor(bgp
, &prefix
, &listen_range
);
3561 prefix2str(&prefix
, buf
, sizeof(buf
));
3562 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3564 if (bgp_debug_neighbor_events(NULL
))
3566 "Dynamic Neighbor %s matches group %s listen range %s",
3567 buf
, group
->name
, buf1
);
3569 /* Are we within the listen limit? */
3570 dncount
= gbgp
->dynamic_neighbors_count
;
3572 if (dncount
>= gbgp
->dynamic_neighbors_limit
) {
3573 if (bgp_debug_neighbor_events(NULL
))
3574 zlog_debug("Dynamic Neighbor %s rejected - at limit %d",
3575 inet_sutop(su
, buf
),
3576 gbgp
->dynamic_neighbors_limit
);
3580 /* Ensure group is not disabled. */
3581 if (CHECK_FLAG(group
->conf
->flags
, PEER_FLAG_SHUTDOWN
)) {
3582 if (bgp_debug_neighbor_events(NULL
))
3584 "Dynamic Neighbor %s rejected - group %s disabled",
3589 /* Check that at least one AF is activated for the group. */
3590 if (!peer_group_af_configured(group
)) {
3591 if (bgp_debug_neighbor_events(NULL
))
3593 "Dynamic Neighbor %s rejected - no AF activated for group %s",
3598 /* Create dynamic peer and bind to associated group. */
3599 peer
= peer_create_bind_dynamic_neighbor(gbgp
, su
, group
);
3602 gbgp
->dynamic_neighbors_count
= ++dncount
;
3604 if (bgp_debug_neighbor_events(peer
))
3605 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
3606 peer
->host
, group
->name
, dncount
);
3611 void peer_drop_dynamic_neighbor(struct peer
*peer
)
3614 if (peer
->group
&& peer
->group
->bgp
) {
3615 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3617 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3619 if (bgp_debug_neighbor_events(peer
))
3620 zlog_debug("%s dropped from group %s, count %d", peer
->host
,
3621 peer
->group
->name
, dncount
);
3625 /* If peer is configured at least one address family return 1. */
3626 int peer_active(struct peer
*peer
)
3628 if (BGP_PEER_SU_UNSPEC(peer
))
3630 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
] || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3631 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3632 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
] || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3633 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3634 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3635 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3636 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3637 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
3638 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
3643 /* If peer is negotiated at least one address family return 1. */
3644 int peer_active_nego(struct peer
*peer
)
3646 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3647 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3648 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3649 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3650 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3651 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3652 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3653 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3654 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3655 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
3656 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
3661 /* peer_flag_change_type. */
3662 enum peer_change_type
{
3665 peer_change_reset_in
,
3666 peer_change_reset_out
,
3669 static void peer_change_action(struct peer
*peer
, afi_t afi
, safi_t safi
,
3670 enum peer_change_type type
)
3672 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
3675 if (peer
->status
!= Established
)
3678 if (type
== peer_change_reset
) {
3679 /* If we're resetting session, we've to delete both peer struct
3681 if ((peer
->doppelganger
)
3682 && (peer
->doppelganger
->status
!= Deleted
)
3683 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3684 PEER_FLAG_CONFIG_NODE
)))
3685 peer_delete(peer
->doppelganger
);
3687 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3688 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3689 } else if (type
== peer_change_reset_in
) {
3690 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3691 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3692 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
3694 if ((peer
->doppelganger
)
3695 && (peer
->doppelganger
->status
!= Deleted
)
3696 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3697 PEER_FLAG_CONFIG_NODE
)))
3698 peer_delete(peer
->doppelganger
);
3700 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3701 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3703 } else if (type
== peer_change_reset_out
) {
3704 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3705 bgp_announce_route(peer
, afi
, safi
);
3709 struct peer_flag_action
{
3713 /* This flag can be set for peer-group member. */
3714 u_char not_for_member
;
3716 /* Action when the flag is changed. */
3717 enum peer_change_type type
;
3719 /* Peer down cause */
3723 static const struct peer_flag_action peer_flag_action_list
[] = {
3724 {PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3725 {PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3726 {PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3727 {PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3728 {PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3729 {PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3730 {PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3731 {PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3734 static const struct peer_flag_action peer_af_flag_action_list
[] = {
3735 {PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3736 {PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3737 {PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3738 {PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3739 {PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3740 {PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3741 {PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3742 {PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3743 {PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3744 {PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3745 // PEER_FLAG_DEFAULT_ORIGINATE
3746 {PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3747 {PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3748 {PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3749 {PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3750 {PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3751 // PEER_FLAG_MAX_PREFIX
3752 // PEER_FLAG_MAX_PREFIX_WARNING
3753 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3754 {PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3755 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3756 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
, 1, peer_change_reset_out
},
3757 {PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3758 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
, 1, peer_change_reset_out
},
3759 {PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3760 {PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3761 {PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3764 /* Proper action set. */
3765 static int peer_flag_action_set(const struct peer_flag_action
*action_list
,
3766 int size
, struct peer_flag_action
*action
,
3773 const struct peer_flag_action
*match
= NULL
;
3775 /* Check peer's frag action. */
3776 for (i
= 0; i
< size
; i
++) {
3777 match
= &action_list
[i
];
3779 if (match
->flag
== 0)
3782 if (match
->flag
& flag
) {
3785 if (match
->type
== peer_change_reset_in
)
3787 if (match
->type
== peer_change_reset_out
)
3789 if (match
->type
== peer_change_reset
) {
3793 if (match
->not_for_member
)
3794 action
->not_for_member
= 1;
3798 /* Set peer clear type. */
3799 if (reset_in
&& reset_out
)
3800 action
->type
= peer_change_reset
;
3802 action
->type
= peer_change_reset_in
;
3804 action
->type
= peer_change_reset_out
;
3806 action
->type
= peer_change_none
;
3811 static void peer_flag_modify_action(struct peer
*peer
, u_int32_t flag
)
3813 if (flag
== PEER_FLAG_SHUTDOWN
) {
3814 if (CHECK_FLAG(peer
->flags
, flag
)) {
3815 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3816 peer_nsf_stop(peer
);
3818 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3819 if (peer
->t_pmax_restart
) {
3820 BGP_TIMER_OFF(peer
->t_pmax_restart
);
3821 if (bgp_debug_neighbor_events(peer
))
3823 "%s Maximum-prefix restart timer canceled",
3827 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3828 peer_nsf_stop(peer
);
3830 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3831 char *msg
= peer
->tx_shutdown_message
;
3834 if (!msg
&& peer_group_active(peer
))
3835 msg
= peer
->group
->conf
3836 ->tx_shutdown_message
;
3837 msglen
= msg
? strlen(msg
) : 0;
3845 memcpy(msgbuf
+ 1, msg
, msglen
);
3847 bgp_notify_send_with_data(
3848 peer
, BGP_NOTIFY_CEASE
,
3849 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3850 msgbuf
, msglen
+ 1);
3853 peer
, BGP_NOTIFY_CEASE
,
3854 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3856 bgp_session_reset(peer
);
3858 peer
->v_start
= BGP_INIT_START_TIMER
;
3859 BGP_EVENT_ADD(peer
, BGP_Stop
);
3861 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
3862 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3863 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3864 else if (flag
== PEER_FLAG_PASSIVE
)
3865 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3866 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3867 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3869 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
3870 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3872 bgp_session_reset(peer
);
3875 /* Change specified peer flag. */
3876 static int peer_flag_modify(struct peer
*peer
, u_int32_t flag
, int set
)
3880 struct peer_group
*group
;
3881 struct peer
*tmp_peer
;
3882 struct listnode
*node
, *nnode
;
3883 struct peer_flag_action action
;
3885 memset(&action
, 0, sizeof(struct peer_flag_action
));
3886 size
= sizeof peer_flag_action_list
/ sizeof(struct peer_flag_action
);
3888 found
= peer_flag_action_set(peer_flag_action_list
, size
, &action
,
3891 /* No flag action is found. */
3893 return BGP_ERR_INVALID_FLAG
;
3895 /* When unset the peer-group member's flag we have to check
3896 peer-group configuration. */
3897 if (!set
&& peer_group_active(peer
))
3898 if (CHECK_FLAG(peer
->group
->conf
->flags
, flag
)) {
3899 if (flag
== PEER_FLAG_SHUTDOWN
)
3900 return BGP_ERR_PEER_GROUP_SHUTDOWN
;
3903 /* Flag conflict check. */
3904 if (set
&& CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
3905 && CHECK_FLAG(peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
3906 return BGP_ERR_PEER_FLAG_CONFLICT
;
3908 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
3909 if (set
&& CHECK_FLAG(peer
->flags
, flag
) == flag
)
3911 if (!set
&& !CHECK_FLAG(peer
->flags
, flag
))
3916 SET_FLAG(peer
->flags
, flag
);
3918 UNSET_FLAG(peer
->flags
, flag
);
3920 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
3921 if (action
.type
== peer_change_reset
)
3922 peer_flag_modify_action(peer
, flag
);
3927 /* peer-group member updates. */
3928 group
= peer
->group
;
3930 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
3932 if (set
&& CHECK_FLAG(tmp_peer
->flags
, flag
) == flag
)
3935 if (!set
&& !CHECK_FLAG(tmp_peer
->flags
, flag
))
3939 SET_FLAG(tmp_peer
->flags
, flag
);
3941 UNSET_FLAG(tmp_peer
->flags
, flag
);
3943 if (action
.type
== peer_change_reset
)
3944 peer_flag_modify_action(tmp_peer
, flag
);
3949 int peer_flag_set(struct peer
*peer
, u_int32_t flag
)
3951 return peer_flag_modify(peer
, flag
, 1);
3954 int peer_flag_unset(struct peer
*peer
, u_int32_t flag
)
3956 return peer_flag_modify(peer
, flag
, 0);
3959 static int peer_af_flag_modify(struct peer
*peer
, afi_t afi
, safi_t safi
,
3960 u_int32_t flag
, int set
)
3964 struct listnode
*node
, *nnode
;
3965 struct peer_group
*group
;
3966 struct peer_flag_action action
;
3967 struct peer
*tmp_peer
;
3969 int addpath_tx_used
;
3971 memset(&action
, 0, sizeof(struct peer_flag_action
));
3972 size
= sizeof peer_af_flag_action_list
3973 / sizeof(struct peer_flag_action
);
3975 found
= peer_flag_action_set(peer_af_flag_action_list
, size
, &action
,
3978 /* No flag action is found. */
3980 return BGP_ERR_INVALID_FLAG
;
3982 /* Special check for reflector client. */
3983 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
3984 && peer_sort(peer
) != BGP_PEER_IBGP
)
3985 return BGP_ERR_NOT_INTERNAL_PEER
;
3987 /* Special check for remove-private-AS. */
3988 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
3989 && peer_sort(peer
) == BGP_PEER_IBGP
)
3990 return BGP_ERR_REMOVE_PRIVATE_AS
;
3992 /* as-override is not allowed for IBGP peers */
3993 if (flag
& PEER_FLAG_AS_OVERRIDE
&& peer_sort(peer
) == BGP_PEER_IBGP
)
3994 return BGP_ERR_AS_OVERRIDE
;
3996 /* When current flag configuration is same as requested one. */
3997 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
3998 if (set
&& CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
) == flag
)
4000 if (!set
&& !CHECK_FLAG(peer
->af_flags
[afi
][safi
], flag
))
4005 SET_FLAG(peer
->af_flags
[afi
][safi
], flag
);
4007 UNSET_FLAG(peer
->af_flags
[afi
][safi
], flag
);
4009 /* Execute action when peer is established. */
4010 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4011 && peer
->status
== Established
) {
4012 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4013 bgp_clear_adj_in(peer
, afi
, safi
);
4015 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4016 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4017 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4018 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4019 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4020 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4021 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4022 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4024 peer_change_action(peer
, afi
, safi
, action
.type
);
4028 /* Peer group member updates. */
4029 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4030 group
= peer
->group
;
4032 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
4034 && CHECK_FLAG(tmp_peer
->af_flags
[afi
][safi
], flag
)
4039 && !CHECK_FLAG(tmp_peer
->af_flags
[afi
][safi
], flag
))
4043 SET_FLAG(tmp_peer
->af_flags
[afi
][safi
], flag
);
4045 UNSET_FLAG(tmp_peer
->af_flags
[afi
][safi
], flag
);
4047 if (tmp_peer
->status
== Established
) {
4048 if (!set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4049 bgp_clear_adj_in(tmp_peer
, afi
, safi
);
4051 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4052 tmp_peer
->last_reset
=
4053 PEER_DOWN_RR_CLIENT_CHANGE
;
4055 == PEER_FLAG_RSERVER_CLIENT
)
4056 tmp_peer
->last_reset
=
4057 PEER_DOWN_RS_CLIENT_CHANGE
;
4059 == PEER_FLAG_ORF_PREFIX_SM
)
4060 tmp_peer
->last_reset
=
4061 PEER_DOWN_CAPABILITY_CHANGE
;
4063 == PEER_FLAG_ORF_PREFIX_RM
)
4064 tmp_peer
->last_reset
=
4065 PEER_DOWN_CAPABILITY_CHANGE
;
4067 peer_change_action(tmp_peer
, afi
, safi
,
4074 /* Track if addpath TX is in use */
4075 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
4076 | PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
4078 addpath_tx_used
= 0;
4081 addpath_tx_used
= 1;
4083 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
) {
4084 if (!bgp_flag_check(
4085 bgp
, BGP_FLAG_DETERMINISTIC_MED
)) {
4087 "%s: enabling bgp deterministic-med, this is required"
4088 " for addpath-tx-bestpath-per-AS",
4092 BGP_FLAG_DETERMINISTIC_MED
);
4093 bgp_recalculate_all_bestpaths(bgp
);
4097 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
,
4099 if (CHECK_FLAG(tmp_peer
->af_flags
[afi
][safi
],
4100 PEER_FLAG_ADDPATH_TX_ALL_PATHS
)
4102 tmp_peer
->af_flags
[afi
][safi
],
4103 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
4104 addpath_tx_used
= 1;
4110 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4116 int peer_af_flag_set(struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4118 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 1);
4121 int peer_af_flag_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
4124 return peer_af_flag_modify(peer
, afi
, safi
, flag
, 0);
4128 int peer_tx_shutdown_message_set(struct peer
*peer
, const char *msg
)
4130 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4131 peer
->tx_shutdown_message
=
4132 msg
? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4136 int peer_tx_shutdown_message_unset(struct peer
*peer
)
4138 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4143 /* EBGP multihop configuration. */
4144 int peer_ebgp_multihop_set(struct peer
*peer
, int ttl
)
4146 struct peer_group
*group
;
4147 struct listnode
*node
, *nnode
;
4150 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4153 /* see comment in peer_ttl_security_hops_set() */
4154 if (ttl
!= MAXTTL
) {
4155 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4156 group
= peer
->group
;
4157 if (group
->conf
->gtsm_hops
!= 0)
4158 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4160 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4162 if (peer1
->sort
== BGP_PEER_IBGP
)
4165 if (peer1
->gtsm_hops
!= 0)
4166 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4169 if (peer
->gtsm_hops
!= 0)
4170 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4176 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4177 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
) {
4178 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4179 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4180 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4182 bgp_session_reset(peer
);
4185 group
= peer
->group
;
4186 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4187 if (peer
->sort
== BGP_PEER_IBGP
)
4190 peer
->ttl
= group
->conf
->ttl
;
4192 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4193 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4194 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4196 bgp_session_reset(peer
);
4202 int peer_ebgp_multihop_unset(struct peer
*peer
)
4204 struct peer_group
*group
;
4205 struct listnode
*node
, *nnode
;
4207 if (peer
->sort
== BGP_PEER_IBGP
)
4210 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4211 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4213 if (peer_group_active(peer
))
4214 peer
->ttl
= peer
->group
->conf
->ttl
;
4218 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4219 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4220 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4221 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4223 bgp_session_reset(peer
);
4225 group
= peer
->group
;
4226 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4227 if (peer
->sort
== BGP_PEER_IBGP
)
4232 if (peer
->fd
>= 0) {
4233 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4235 peer
, BGP_NOTIFY_CEASE
,
4236 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4238 bgp_session_reset(peer
);
4245 /* Neighbor description. */
4246 int peer_description_set(struct peer
*peer
, const char *desc
)
4249 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4251 peer
->desc
= XSTRDUP(MTYPE_PEER_DESC
, desc
);
4256 int peer_description_unset(struct peer
*peer
)
4259 XFREE(MTYPE_PEER_DESC
, peer
->desc
);
4266 /* Neighbor update-source. */
4267 int peer_update_source_if_set(struct peer
*peer
, const char *ifname
)
4269 struct peer_group
*group
;
4270 struct listnode
*node
, *nnode
;
4272 if (peer
->update_if
) {
4273 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4274 && strcmp(peer
->update_if
, ifname
) == 0)
4277 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4278 peer
->update_if
= NULL
;
4281 if (peer
->update_source
) {
4282 sockunion_free(peer
->update_source
);
4283 peer
->update_source
= NULL
;
4286 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4288 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4289 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4290 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4291 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4292 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4294 bgp_session_reset(peer
);
4298 /* peer-group member updates. */
4299 group
= peer
->group
;
4300 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4301 if (peer
->update_if
) {
4302 if (strcmp(peer
->update_if
, ifname
) == 0)
4305 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4306 peer
->update_if
= NULL
;
4309 if (peer
->update_source
) {
4310 sockunion_free(peer
->update_source
);
4311 peer
->update_source
= NULL
;
4314 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4316 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4317 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4318 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4319 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4321 bgp_session_reset(peer
);
4326 int peer_update_source_addr_set(struct peer
*peer
, const union sockunion
*su
)
4328 struct peer_group
*group
;
4329 struct listnode
*node
, *nnode
;
4331 if (peer
->update_source
) {
4332 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)
4333 && sockunion_cmp(peer
->update_source
, su
) == 0)
4335 sockunion_free(peer
->update_source
);
4336 peer
->update_source
= NULL
;
4339 if (peer
->update_if
) {
4340 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4341 peer
->update_if
= NULL
;
4344 peer
->update_source
= sockunion_dup(su
);
4346 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4347 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4348 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4349 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4350 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4352 bgp_session_reset(peer
);
4356 /* peer-group member updates. */
4357 group
= peer
->group
;
4358 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4359 if (peer
->update_source
) {
4360 if (sockunion_cmp(peer
->update_source
, su
) == 0)
4362 sockunion_free(peer
->update_source
);
4363 peer
->update_source
= NULL
;
4366 if (peer
->update_if
) {
4367 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4368 peer
->update_if
= NULL
;
4371 peer
->update_source
= sockunion_dup(su
);
4373 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4374 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4375 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4376 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4378 bgp_session_reset(peer
);
4383 int peer_update_source_unset(struct peer
*peer
)
4385 union sockunion
*su
;
4386 struct peer_group
*group
;
4387 struct listnode
*node
, *nnode
;
4389 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
) && !peer
->update_source
4390 && !peer
->update_if
)
4393 if (peer
->update_source
) {
4394 sockunion_free(peer
->update_source
);
4395 peer
->update_source
= NULL
;
4397 if (peer
->update_if
) {
4398 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4399 peer
->update_if
= NULL
;
4402 if (peer_group_active(peer
)) {
4403 group
= peer
->group
;
4405 if (group
->conf
->update_source
) {
4406 su
= sockunion_dup(group
->conf
->update_source
);
4407 peer
->update_source
= su
;
4408 } else if (group
->conf
->update_if
)
4409 peer
->update_if
= XSTRDUP(MTYPE_PEER_UPDATE_SOURCE
,
4410 group
->conf
->update_if
);
4413 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4414 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4415 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4416 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4417 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4419 bgp_session_reset(peer
);
4423 /* peer-group member updates. */
4424 group
= peer
->group
;
4425 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4426 if (!peer
->update_source
&& !peer
->update_if
)
4429 if (peer
->update_source
) {
4430 sockunion_free(peer
->update_source
);
4431 peer
->update_source
= NULL
;
4434 if (peer
->update_if
) {
4435 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4436 peer
->update_if
= NULL
;
4439 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
4440 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4441 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
4442 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4444 bgp_session_reset(peer
);
4449 int peer_default_originate_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
4452 struct peer_group
*group
;
4453 struct listnode
*node
, *nnode
;
4455 if (!CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
)
4456 || (rmap
&& !peer
->default_rmap
[afi
][safi
].name
)
4458 && strcmp(rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0)) {
4459 SET_FLAG(peer
->af_flags
[afi
][safi
],
4460 PEER_FLAG_DEFAULT_ORIGINATE
);
4463 if (peer
->default_rmap
[afi
][safi
].name
)
4464 XFREE(MTYPE_ROUTE_MAP_NAME
,
4465 peer
->default_rmap
[afi
][safi
].name
);
4466 peer
->default_rmap
[afi
][safi
].name
=
4467 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4468 peer
->default_rmap
[afi
][safi
].map
=
4469 route_map_lookup_by_name(rmap
);
4473 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4474 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4475 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4476 bgp_default_originate(peer
, afi
, safi
, 0);
4477 bgp_announce_route(peer
, afi
, safi
);
4482 /* peer-group member updates. */
4483 group
= peer
->group
;
4484 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4485 SET_FLAG(peer
->af_flags
[afi
][safi
],
4486 PEER_FLAG_DEFAULT_ORIGINATE
);
4489 if (peer
->default_rmap
[afi
][safi
].name
)
4490 XFREE(MTYPE_ROUTE_MAP_NAME
,
4491 peer
->default_rmap
[afi
][safi
].name
);
4492 peer
->default_rmap
[afi
][safi
].name
=
4493 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4494 peer
->default_rmap
[afi
][safi
].map
=
4495 route_map_lookup_by_name(rmap
);
4498 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4499 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4500 bgp_default_originate(peer
, afi
, safi
, 0);
4501 bgp_announce_route(peer
, afi
, safi
);
4507 int peer_default_originate_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4509 struct peer_group
*group
;
4510 struct listnode
*node
, *nnode
;
4512 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4513 PEER_FLAG_DEFAULT_ORIGINATE
)) {
4514 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4515 PEER_FLAG_DEFAULT_ORIGINATE
);
4517 if (peer
->default_rmap
[afi
][safi
].name
)
4518 XFREE(MTYPE_ROUTE_MAP_NAME
,
4519 peer
->default_rmap
[afi
][safi
].name
);
4520 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4521 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4524 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4525 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4526 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4527 bgp_default_originate(peer
, afi
, safi
, 1);
4528 bgp_announce_route(peer
, afi
, safi
);
4533 /* peer-group member updates. */
4534 group
= peer
->group
;
4535 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4536 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
4537 PEER_FLAG_DEFAULT_ORIGINATE
);
4539 if (peer
->default_rmap
[afi
][safi
].name
)
4540 XFREE(MTYPE_ROUTE_MAP_NAME
,
4541 peer
->default_rmap
[afi
][safi
].name
);
4542 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4543 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4545 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4546 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4547 bgp_default_originate(peer
, afi
, safi
, 1);
4548 bgp_announce_route(peer
, afi
, safi
);
4554 int peer_port_set(struct peer
*peer
, u_int16_t port
)
4560 int peer_port_unset(struct peer
*peer
)
4562 peer
->port
= BGP_PORT_DEFAULT
;
4567 * Helper function that is called after the name of the policy
4568 * being used by a peer has changed (AF specific). Automatically
4569 * initiates inbound or outbound processing as needed.
4571 static void peer_on_policy_change(struct peer
*peer
, afi_t afi
, safi_t safi
,
4575 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4576 if (peer
->status
== Established
)
4577 bgp_announce_route(peer
, afi
, safi
);
4579 if (peer
->status
!= Established
)
4582 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4583 PEER_FLAG_SOFT_RECONFIG
))
4584 bgp_soft_reconfig_in(peer
, afi
, safi
);
4585 else if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4586 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4587 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0, 0);
4592 /* neighbor weight. */
4593 int peer_weight_set(struct peer
*peer
, afi_t afi
, safi_t safi
, u_int16_t weight
)
4595 struct peer_group
*group
;
4596 struct listnode
*node
, *nnode
;
4598 if (peer
->weight
[afi
][safi
] != weight
) {
4599 peer
->weight
[afi
][safi
] = weight
;
4600 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4601 peer_on_policy_change(peer
, afi
, safi
, 0);
4604 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4607 /* peer-group member updates. */
4608 group
= peer
->group
;
4609 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4610 if (peer
->weight
[afi
][safi
] != weight
) {
4611 peer
->weight
[afi
][safi
] = weight
;
4612 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4613 peer_on_policy_change(peer
, afi
, safi
, 0);
4619 int peer_weight_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4621 struct peer_group
*group
;
4622 struct listnode
*node
, *nnode
;
4624 /* not the peer-group itself but a peer in a peer-group */
4625 if (peer_group_active(peer
)) {
4626 group
= peer
->group
;
4628 /* inherit weight from the peer-group */
4629 if (CHECK_FLAG(group
->conf
->af_flags
[afi
][safi
],
4630 PEER_FLAG_WEIGHT
)) {
4631 peer
->weight
[afi
][safi
] =
4632 group
->conf
->weight
[afi
][safi
];
4633 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4634 peer_on_policy_change(peer
, afi
, safi
, 0);
4636 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4637 PEER_FLAG_WEIGHT
)) {
4638 peer
->weight
[afi
][safi
] = 0;
4639 peer_af_flag_unset(peer
, afi
, safi
,
4641 peer_on_policy_change(peer
, afi
, safi
, 0);
4647 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
)) {
4648 peer
->weight
[afi
][safi
] = 0;
4649 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4650 peer_on_policy_change(peer
, afi
, safi
, 0);
4653 /* peer-group member updates. */
4654 group
= peer
->group
;
4657 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
4659 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4660 PEER_FLAG_WEIGHT
)) {
4661 peer
->weight
[afi
][safi
] = 0;
4662 peer_af_flag_unset(peer
, afi
, safi
,
4664 peer_on_policy_change(peer
, afi
, safi
,
4673 int peer_timers_set(struct peer
*peer
, u_int32_t keepalive
, u_int32_t holdtime
)
4675 struct peer_group
*group
;
4676 struct listnode
*node
, *nnode
;
4678 /* keepalive value check. */
4679 if (keepalive
> 65535)
4680 return BGP_ERR_INVALID_VALUE
;
4682 /* Holdtime value check. */
4683 if (holdtime
> 65535)
4684 return BGP_ERR_INVALID_VALUE
;
4686 /* Holdtime value must be either 0 or greater than 3. */
4687 if (holdtime
< 3 && holdtime
!= 0)
4688 return BGP_ERR_INVALID_VALUE
;
4690 /* Set value to the configuration. */
4691 peer
->holdtime
= holdtime
;
4692 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4694 /* First work on real peers with timers */
4695 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4696 SET_FLAG(peer
->config
, PEER_CONFIG_TIMER
);
4697 UNSET_FLAG(peer
->config
, PEER_GROUP_CONFIG_TIMER
);
4699 /* Now work on the peer-group timers */
4700 SET_FLAG(peer
->config
, PEER_GROUP_CONFIG_TIMER
);
4702 /* peer-group member updates. */
4703 group
= peer
->group
;
4704 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4705 /* Skip peers that have their own timers */
4706 if (CHECK_FLAG(peer
->config
, PEER_CONFIG_TIMER
))
4709 SET_FLAG(peer
->config
, PEER_GROUP_CONFIG_TIMER
);
4710 peer
->holdtime
= group
->conf
->holdtime
;
4711 peer
->keepalive
= group
->conf
->keepalive
;
4718 int peer_timers_unset(struct peer
*peer
)
4720 struct peer_group
*group
;
4721 struct listnode
*node
, *nnode
;
4723 /* First work on real peers vs the peer-group */
4724 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4725 UNSET_FLAG(peer
->config
, PEER_CONFIG_TIMER
);
4726 peer
->keepalive
= 0;
4729 if (peer
->group
&& peer
->group
->conf
->holdtime
) {
4730 SET_FLAG(peer
->config
, PEER_GROUP_CONFIG_TIMER
);
4731 peer
->keepalive
= peer
->group
->conf
->keepalive
;
4732 peer
->holdtime
= peer
->group
->conf
->holdtime
;
4735 /* peer-group member updates. */
4736 group
= peer
->group
;
4737 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4738 if (!CHECK_FLAG(peer
->config
, PEER_CONFIG_TIMER
)) {
4739 UNSET_FLAG(peer
->config
,
4740 PEER_GROUP_CONFIG_TIMER
);
4742 peer
->keepalive
= 0;
4746 UNSET_FLAG(group
->conf
->config
, PEER_GROUP_CONFIG_TIMER
);
4747 group
->conf
->holdtime
= 0;
4748 group
->conf
->keepalive
= 0;
4754 int peer_timers_connect_set(struct peer
*peer
, u_int32_t connect
)
4756 struct peer_group
*group
;
4757 struct listnode
*node
, *nnode
;
4759 if (connect
> 65535)
4760 return BGP_ERR_INVALID_VALUE
;
4762 /* Set value to the configuration. */
4763 SET_FLAG(peer
->config
, PEER_CONFIG_CONNECT
);
4764 peer
->connect
= connect
;
4766 /* Set value to timer setting. */
4767 peer
->v_connect
= connect
;
4769 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4772 /* peer-group member updates. */
4773 group
= peer
->group
;
4774 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4775 SET_FLAG(peer
->config
, PEER_CONFIG_CONNECT
);
4776 peer
->connect
= connect
;
4777 peer
->v_connect
= connect
;
4782 int peer_timers_connect_unset(struct peer
*peer
)
4784 struct peer_group
*group
;
4785 struct listnode
*node
, *nnode
;
4787 /* Clear configuration. */
4788 UNSET_FLAG(peer
->config
, PEER_CONFIG_CONNECT
);
4791 /* Set timer setting to default value. */
4792 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4794 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4797 /* peer-group member updates. */
4798 group
= peer
->group
;
4799 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4800 UNSET_FLAG(peer
->config
, PEER_CONFIG_CONNECT
);
4802 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4807 int peer_advertise_interval_set(struct peer
*peer
, u_int32_t routeadv
)
4809 struct peer_group
*group
;
4810 struct listnode
*node
, *nnode
;
4813 return BGP_ERR_INVALID_VALUE
;
4815 SET_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
);
4816 peer
->routeadv
= routeadv
;
4817 peer
->v_routeadv
= routeadv
;
4819 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4820 update_group_adjust_peer_afs(peer
);
4821 if (peer
->status
== Established
)
4822 bgp_announce_route_all(peer
);
4826 /* peer-group member updates. */
4827 group
= peer
->group
;
4828 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4829 SET_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
);
4830 peer
->routeadv
= routeadv
;
4831 peer
->v_routeadv
= routeadv
;
4832 update_group_adjust_peer_afs(peer
);
4833 if (peer
->status
== Established
)
4834 bgp_announce_route_all(peer
);
4840 int peer_advertise_interval_unset(struct peer
*peer
)
4842 struct peer_group
*group
;
4843 struct listnode
*node
, *nnode
;
4845 UNSET_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
);
4848 if (peer
->sort
== BGP_PEER_IBGP
)
4849 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4851 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4853 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4854 update_group_adjust_peer_afs(peer
);
4855 if (peer
->status
== Established
)
4856 bgp_announce_route_all(peer
);
4860 /* peer-group member updates. */
4861 group
= peer
->group
;
4862 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4863 UNSET_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
);
4866 if (peer
->sort
== BGP_PEER_IBGP
)
4867 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4869 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4871 update_group_adjust_peer_afs(peer
);
4872 if (peer
->status
== Established
)
4873 bgp_announce_route_all(peer
);
4879 /* neighbor interface */
4880 void peer_interface_set(struct peer
*peer
, const char *str
)
4883 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4884 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
4887 void peer_interface_unset(struct peer
*peer
)
4890 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4891 peer
->ifname
= NULL
;
4895 int peer_allowas_in_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
4896 int allow_num
, int origin
)
4898 struct peer_group
*group
;
4899 struct listnode
*node
, *nnode
;
4902 if (peer
->allowas_in
[afi
][safi
]
4903 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4904 PEER_FLAG_ALLOWAS_IN
)
4905 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4906 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4907 peer
->allowas_in
[afi
][safi
] = 0;
4908 peer_af_flag_unset(peer
, afi
, safi
,
4909 PEER_FLAG_ALLOWAS_IN
);
4910 peer_af_flag_set(peer
, afi
, safi
,
4911 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4912 peer_on_policy_change(peer
, afi
, safi
, 0);
4915 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4918 group
= peer
->group
;
4919 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4920 if (peer
->allowas_in
[afi
][safi
]
4921 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4922 PEER_FLAG_ALLOWAS_IN
)
4923 || !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4924 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4925 peer
->allowas_in
[afi
][safi
] = 0;
4926 peer_af_flag_unset(peer
, afi
, safi
,
4927 PEER_FLAG_ALLOWAS_IN
);
4928 peer_af_flag_set(peer
, afi
, safi
,
4929 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4930 peer_on_policy_change(peer
, afi
, safi
, 0);
4934 if (allow_num
< 1 || allow_num
> 10)
4935 return BGP_ERR_INVALID_VALUE
;
4937 if (peer
->allowas_in
[afi
][safi
] != allow_num
4938 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4939 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4940 peer
->allowas_in
[afi
][safi
] = allow_num
;
4941 peer_af_flag_set(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4942 peer_af_flag_unset(peer
, afi
, safi
,
4943 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4944 peer_on_policy_change(peer
, afi
, safi
, 0);
4947 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
4950 group
= peer
->group
;
4951 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
4952 if (peer
->allowas_in
[afi
][safi
] != allow_num
4953 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4954 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4955 peer
->allowas_in
[afi
][safi
] = allow_num
;
4956 peer_af_flag_set(peer
, afi
, safi
,
4957 PEER_FLAG_ALLOWAS_IN
);
4958 peer_af_flag_unset(peer
, afi
, safi
,
4959 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4960 peer_on_policy_change(peer
, afi
, safi
, 0);
4968 int peer_allowas_in_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
4970 struct peer_group
*group
;
4971 struct peer
*tmp_peer
;
4972 struct listnode
*node
, *nnode
;
4974 /* If this is a peer-group we must first clear the flags for all of the
4975 * peer-group members
4977 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
4978 group
= peer
->group
;
4979 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, tmp_peer
)) {
4980 if (CHECK_FLAG(tmp_peer
->af_flags
[afi
][safi
],
4981 PEER_FLAG_ALLOWAS_IN
)
4982 || CHECK_FLAG(tmp_peer
->af_flags
[afi
][safi
],
4983 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4984 tmp_peer
->allowas_in
[afi
][safi
] = 0;
4985 peer_af_flag_unset(tmp_peer
, afi
, safi
,
4986 PEER_FLAG_ALLOWAS_IN
);
4987 peer_af_flag_unset(tmp_peer
, afi
, safi
,
4988 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4989 peer_on_policy_change(tmp_peer
, afi
, safi
, 0);
4994 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
)
4995 || CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4996 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
4997 peer
->allowas_in
[afi
][safi
] = 0;
4998 peer_af_flag_unset(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4999 peer_af_flag_unset(peer
, afi
, safi
,
5000 PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5001 peer_on_policy_change(peer
, afi
, safi
, 0);
5007 int peer_local_as_set(struct peer
*peer
, as_t as
, int no_prepend
,
5010 struct bgp
*bgp
= peer
->bgp
;
5011 struct peer_group
*group
;
5012 struct listnode
*node
, *nnode
;
5014 if (peer_sort(peer
) != BGP_PEER_EBGP
5015 && peer_sort(peer
) != BGP_PEER_INTERNAL
)
5016 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5019 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5022 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5024 if (peer
->change_local_as
== as
5025 && ((CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
5027 || (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
5029 && ((CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)
5031 || (!CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)
5035 peer
->change_local_as
= as
;
5037 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5039 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5042 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5044 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5046 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5047 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5048 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5049 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5050 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5052 bgp_session_reset(peer
);
5056 group
= peer
->group
;
5057 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5058 peer
->change_local_as
= as
;
5060 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5062 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5065 SET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5067 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5069 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5070 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5071 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5072 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5074 BGP_EVENT_ADD(peer
, BGP_Stop
);
5080 int peer_local_as_unset(struct peer
*peer
)
5082 struct peer_group
*group
;
5083 struct listnode
*node
, *nnode
;
5085 if (!peer
->change_local_as
)
5088 peer
->change_local_as
= 0;
5089 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5090 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5092 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5093 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5094 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5095 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5096 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5098 BGP_EVENT_ADD(peer
, BGP_Stop
);
5103 group
= peer
->group
;
5104 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5105 peer
->change_local_as
= 0;
5106 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5107 UNSET_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5109 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
)) {
5110 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5111 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5112 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5114 bgp_session_reset(peer
);
5119 /* Set password for authenticating with the peer. */
5120 int peer_password_set(struct peer
*peer
, const char *password
)
5122 struct listnode
*nn
, *nnode
;
5123 int len
= password
? strlen(password
) : 0;
5124 int ret
= BGP_SUCCESS
;
5126 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5127 return BGP_ERR_INVALID_VALUE
;
5129 if (peer
->password
&& strcmp(peer
->password
, password
) == 0
5130 && !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5134 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5136 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5138 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5139 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5140 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5141 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5143 bgp_session_reset(peer
);
5145 if (BGP_PEER_SU_UNSPEC(peer
))
5148 return (bgp_md5_set(peer
) >= 0) ? BGP_SUCCESS
5149 : BGP_ERR_TCPSIG_FAILED
;
5152 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, nn
, nnode
, peer
)) {
5153 if (peer
->password
&& strcmp(peer
->password
, password
) == 0)
5157 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5159 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5161 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5162 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5163 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5165 bgp_session_reset(peer
);
5167 if (!BGP_PEER_SU_UNSPEC(peer
)) {
5168 if (bgp_md5_set(peer
) < 0)
5169 ret
= BGP_ERR_TCPSIG_FAILED
;
5176 int peer_password_unset(struct peer
*peer
)
5178 struct listnode
*nn
, *nnode
;
5180 if (!peer
->password
&& !CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5183 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5184 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5185 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5186 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5188 bgp_session_reset(peer
);
5191 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5193 peer
->password
= NULL
;
5195 if (!BGP_PEER_SU_UNSPEC(peer
))
5196 bgp_md5_unset(peer
);
5201 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5202 peer
->password
= NULL
;
5204 for (ALL_LIST_ELEMENTS(peer
->group
->peer
, nn
, nnode
, peer
)) {
5205 if (!peer
->password
)
5208 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5209 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
5210 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5212 bgp_session_reset(peer
);
5214 XFREE(MTYPE_PEER_PASSWORD
, peer
->password
);
5215 peer
->password
= NULL
;
5217 if (!BGP_PEER_SU_UNSPEC(peer
))
5218 bgp_md5_unset(peer
);
5225 /* Set distribute list to the peer. */
5226 int peer_distribute_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5229 struct bgp_filter
*filter
;
5230 struct peer_group
*group
;
5231 struct listnode
*node
, *nnode
;
5233 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5234 return BGP_ERR_INVALID_VALUE
;
5236 filter
= &peer
->filter
[afi
][safi
];
5238 if (filter
->plist
[direct
].name
)
5239 return BGP_ERR_PEER_FILTER_CONFLICT
;
5241 if (filter
->dlist
[direct
].name
)
5242 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5243 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5244 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5246 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5247 peer_on_policy_change(peer
, afi
, safi
,
5248 (direct
== FILTER_OUT
) ? 1 : 0);
5252 group
= peer
->group
;
5253 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5254 filter
= &peer
->filter
[afi
][safi
];
5256 if (filter
->dlist
[direct
].name
)
5257 XFREE(MTYPE_BGP_FILTER_NAME
,
5258 filter
->dlist
[direct
].name
);
5259 filter
->dlist
[direct
].name
=
5260 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5261 filter
->dlist
[direct
].alist
= access_list_lookup(afi
, name
);
5262 peer_on_policy_change(peer
, afi
, safi
,
5263 (direct
== FILTER_OUT
) ? 1 : 0);
5269 int peer_distribute_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5271 struct bgp_filter
*filter
;
5272 struct bgp_filter
*gfilter
;
5273 struct peer_group
*group
;
5274 struct listnode
*node
, *nnode
;
5276 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5277 return BGP_ERR_INVALID_VALUE
;
5279 filter
= &peer
->filter
[afi
][safi
];
5281 /* apply peer-group filter */
5282 if (peer_group_active(peer
)) {
5283 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5285 if (gfilter
->dlist
[direct
].name
) {
5286 if (filter
->dlist
[direct
].name
)
5287 XFREE(MTYPE_BGP_FILTER_NAME
,
5288 filter
->dlist
[direct
].name
);
5289 filter
->dlist
[direct
].name
=
5290 XSTRDUP(MTYPE_BGP_FILTER_NAME
,
5291 gfilter
->dlist
[direct
].name
);
5292 filter
->dlist
[direct
].alist
=
5293 gfilter
->dlist
[direct
].alist
;
5294 peer_on_policy_change(peer
, afi
, safi
,
5295 (direct
== FILTER_OUT
) ? 1 : 0);
5300 if (filter
->dlist
[direct
].name
)
5301 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5302 filter
->dlist
[direct
].name
= NULL
;
5303 filter
->dlist
[direct
].alist
= NULL
;
5305 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5306 peer_on_policy_change(peer
, afi
, safi
,
5307 (direct
== FILTER_OUT
) ? 1 : 0);
5311 group
= peer
->group
;
5312 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5313 filter
= &peer
->filter
[afi
][safi
];
5315 if (filter
->dlist
[direct
].name
)
5316 XFREE(MTYPE_BGP_FILTER_NAME
,
5317 filter
->dlist
[direct
].name
);
5318 filter
->dlist
[direct
].name
= NULL
;
5319 filter
->dlist
[direct
].alist
= NULL
;
5320 peer_on_policy_change(peer
, afi
, safi
,
5321 (direct
== FILTER_OUT
) ? 1 : 0);
5327 /* Update distribute list. */
5328 static void peer_distribute_update(struct access_list
*access
)
5333 struct listnode
*mnode
, *mnnode
;
5334 struct listnode
*node
, *nnode
;
5337 struct peer_group
*group
;
5338 struct bgp_filter
*filter
;
5340 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5342 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
5343 access
->name
, 0, 0);
5344 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5345 FOREACH_AFI_SAFI (afi
, safi
) {
5346 filter
= &peer
->filter
[afi
][safi
];
5348 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5350 if (filter
->dlist
[direct
].name
)
5351 filter
->dlist
[direct
]
5352 .alist
= access_list_lookup(
5354 filter
->dlist
[direct
]
5357 filter
->dlist
[direct
].alist
=
5362 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5363 FOREACH_AFI_SAFI (afi
, safi
) {
5364 filter
= &group
->conf
->filter
[afi
][safi
];
5366 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5368 if (filter
->dlist
[direct
].name
)
5369 filter
->dlist
[direct
]
5370 .alist
= access_list_lookup(
5372 filter
->dlist
[direct
]
5375 filter
->dlist
[direct
].alist
=
5381 vnc_prefix_list_update(bgp
);
5386 /* Set prefix list to the peer. */
5387 int peer_prefix_list_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5390 struct bgp_filter
*filter
;
5391 struct peer_group
*group
;
5392 struct listnode
*node
, *nnode
;
5394 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5395 return BGP_ERR_INVALID_VALUE
;
5397 filter
= &peer
->filter
[afi
][safi
];
5399 if (filter
->dlist
[direct
].name
)
5400 return BGP_ERR_PEER_FILTER_CONFLICT
;
5402 if (filter
->plist
[direct
].name
)
5403 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5404 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5405 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5407 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5408 peer_on_policy_change(peer
, afi
, safi
,
5409 (direct
== FILTER_OUT
) ? 1 : 0);
5413 group
= peer
->group
;
5414 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5415 filter
= &peer
->filter
[afi
][safi
];
5417 if (filter
->plist
[direct
].name
)
5418 XFREE(MTYPE_BGP_FILTER_NAME
,
5419 filter
->plist
[direct
].name
);
5420 filter
->plist
[direct
].name
=
5421 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5422 filter
->plist
[direct
].plist
= prefix_list_lookup(afi
, name
);
5423 peer_on_policy_change(peer
, afi
, safi
,
5424 (direct
== FILTER_OUT
) ? 1 : 0);
5429 int peer_prefix_list_unset(struct peer
*peer
, afi_t afi
, safi_t safi
,
5432 struct bgp_filter
*filter
;
5433 struct bgp_filter
*gfilter
;
5434 struct peer_group
*group
;
5435 struct listnode
*node
, *nnode
;
5437 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5438 return BGP_ERR_INVALID_VALUE
;
5440 filter
= &peer
->filter
[afi
][safi
];
5442 /* apply peer-group filter */
5443 if (peer_group_active(peer
)) {
5444 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5446 if (gfilter
->plist
[direct
].name
) {
5447 if (filter
->plist
[direct
].name
)
5448 XFREE(MTYPE_BGP_FILTER_NAME
,
5449 filter
->plist
[direct
].name
);
5450 filter
->plist
[direct
].name
=
5451 XSTRDUP(MTYPE_BGP_FILTER_NAME
,
5452 gfilter
->plist
[direct
].name
);
5453 filter
->plist
[direct
].plist
=
5454 gfilter
->plist
[direct
].plist
;
5455 peer_on_policy_change(peer
, afi
, safi
,
5456 (direct
== FILTER_OUT
) ? 1 : 0);
5461 if (filter
->plist
[direct
].name
)
5462 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5463 filter
->plist
[direct
].name
= NULL
;
5464 filter
->plist
[direct
].plist
= NULL
;
5466 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5467 peer_on_policy_change(peer
, afi
, safi
,
5468 (direct
== FILTER_OUT
) ? 1 : 0);
5472 group
= peer
->group
;
5473 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5474 filter
= &peer
->filter
[afi
][safi
];
5476 if (filter
->plist
[direct
].name
)
5477 XFREE(MTYPE_BGP_FILTER_NAME
,
5478 filter
->plist
[direct
].name
);
5479 filter
->plist
[direct
].name
= NULL
;
5480 filter
->plist
[direct
].plist
= NULL
;
5481 peer_on_policy_change(peer
, afi
, safi
,
5482 (direct
== FILTER_OUT
) ? 1 : 0);
5488 /* Update prefix-list list. */
5489 static void peer_prefix_list_update(struct prefix_list
*plist
)
5491 struct listnode
*mnode
, *mnnode
;
5492 struct listnode
*node
, *nnode
;
5495 struct peer_group
*group
;
5496 struct bgp_filter
*filter
;
5501 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5504 * Update the prefix-list on update groups.
5506 update_group_policy_update(
5507 bgp
, BGP_POLICY_PREFIX_LIST
,
5508 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5510 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5511 FOREACH_AFI_SAFI (afi
, safi
) {
5512 filter
= &peer
->filter
[afi
][safi
];
5514 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5516 if (filter
->plist
[direct
].name
)
5517 filter
->plist
[direct
]
5518 .plist
= prefix_list_lookup(
5520 filter
->plist
[direct
]
5523 filter
->plist
[direct
].plist
=
5528 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5529 FOREACH_AFI_SAFI (afi
, safi
) {
5530 filter
= &group
->conf
->filter
[afi
][safi
];
5532 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5534 if (filter
->plist
[direct
].name
)
5535 filter
->plist
[direct
]
5536 .plist
= prefix_list_lookup(
5538 filter
->plist
[direct
]
5541 filter
->plist
[direct
].plist
=
5549 int peer_aslist_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5552 struct bgp_filter
*filter
;
5553 struct peer_group
*group
;
5554 struct listnode
*node
, *nnode
;
5556 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5557 return BGP_ERR_INVALID_VALUE
;
5559 filter
= &peer
->filter
[afi
][safi
];
5561 if (filter
->aslist
[direct
].name
)
5562 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5563 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5564 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
5566 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5567 peer_on_policy_change(peer
, afi
, safi
,
5568 (direct
== FILTER_OUT
) ? 1 : 0);
5572 group
= peer
->group
;
5573 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5574 filter
= &peer
->filter
[afi
][safi
];
5576 if (filter
->aslist
[direct
].name
)
5577 XFREE(MTYPE_BGP_FILTER_NAME
,
5578 filter
->aslist
[direct
].name
);
5579 filter
->aslist
[direct
].name
=
5580 XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5581 filter
->aslist
[direct
].aslist
= as_list_lookup(name
);
5582 peer_on_policy_change(peer
, afi
, safi
,
5583 (direct
== FILTER_OUT
) ? 1 : 0);
5588 int peer_aslist_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5590 struct bgp_filter
*filter
;
5591 struct bgp_filter
*gfilter
;
5592 struct peer_group
*group
;
5593 struct listnode
*node
, *nnode
;
5595 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5596 return BGP_ERR_INVALID_VALUE
;
5598 filter
= &peer
->filter
[afi
][safi
];
5600 /* apply peer-group filter */
5601 if (peer_group_active(peer
)) {
5602 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5604 if (gfilter
->aslist
[direct
].name
) {
5605 if (filter
->aslist
[direct
].name
)
5606 XFREE(MTYPE_BGP_FILTER_NAME
,
5607 filter
->aslist
[direct
].name
);
5608 filter
->aslist
[direct
].name
=
5609 XSTRDUP(MTYPE_BGP_FILTER_NAME
,
5610 gfilter
->aslist
[direct
].name
);
5611 filter
->aslist
[direct
].aslist
=
5612 gfilter
->aslist
[direct
].aslist
;
5613 peer_on_policy_change(peer
, afi
, safi
,
5614 (direct
== FILTER_OUT
) ? 1 : 0);
5619 if (filter
->aslist
[direct
].name
)
5620 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5621 filter
->aslist
[direct
].name
= NULL
;
5622 filter
->aslist
[direct
].aslist
= NULL
;
5624 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5625 peer_on_policy_change(peer
, afi
, safi
,
5626 (direct
== FILTER_OUT
) ? 1 : 0);
5630 group
= peer
->group
;
5631 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5632 filter
= &peer
->filter
[afi
][safi
];
5634 if (filter
->aslist
[direct
].name
)
5635 XFREE(MTYPE_BGP_FILTER_NAME
,
5636 filter
->aslist
[direct
].name
);
5637 filter
->aslist
[direct
].name
= NULL
;
5638 filter
->aslist
[direct
].aslist
= NULL
;
5639 peer_on_policy_change(peer
, afi
, safi
,
5640 (direct
== FILTER_OUT
) ? 1 : 0);
5646 static void peer_aslist_update(const char *aslist_name
)
5651 struct listnode
*mnode
, *mnnode
;
5652 struct listnode
*node
, *nnode
;
5655 struct peer_group
*group
;
5656 struct bgp_filter
*filter
;
5658 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
5659 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
,
5662 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
5663 FOREACH_AFI_SAFI (afi
, safi
) {
5664 filter
= &peer
->filter
[afi
][safi
];
5666 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5668 if (filter
->aslist
[direct
].name
)
5669 filter
->aslist
[direct
]
5670 .aslist
= as_list_lookup(
5671 filter
->aslist
[direct
]
5674 filter
->aslist
[direct
].aslist
=
5679 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
5680 FOREACH_AFI_SAFI (afi
, safi
) {
5681 filter
= &group
->conf
->filter
[afi
][safi
];
5683 for (direct
= FILTER_IN
; direct
< FILTER_MAX
;
5685 if (filter
->aslist
[direct
].name
)
5686 filter
->aslist
[direct
]
5687 .aslist
= as_list_lookup(
5688 filter
->aslist
[direct
]
5691 filter
->aslist
[direct
].aslist
=
5699 static void peer_aslist_add(char *aslist_name
)
5701 peer_aslist_update(aslist_name
);
5702 route_map_notify_dependencies((char *)aslist_name
,
5703 RMAP_EVENT_ASLIST_ADDED
);
5706 static void peer_aslist_del(const char *aslist_name
)
5708 peer_aslist_update(aslist_name
);
5709 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
5713 int peer_route_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5716 struct bgp_filter
*filter
;
5717 struct peer_group
*group
;
5718 struct listnode
*node
, *nnode
;
5720 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5721 return BGP_ERR_INVALID_VALUE
;
5723 filter
= &peer
->filter
[afi
][safi
];
5725 if (filter
->map
[direct
].name
)
5726 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5728 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5729 filter
->map
[direct
].map
= route_map_lookup_by_name(name
);
5731 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5732 peer_on_policy_change(peer
, afi
, safi
,
5733 (direct
== RMAP_OUT
) ? 1 : 0);
5737 group
= peer
->group
;
5738 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5739 filter
= &peer
->filter
[afi
][safi
];
5741 if (filter
->map
[direct
].name
)
5742 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5743 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5744 filter
->map
[direct
].map
= route_map_lookup_by_name(name
);
5745 peer_on_policy_change(peer
, afi
, safi
,
5746 (direct
== RMAP_OUT
) ? 1 : 0);
5751 /* Unset route-map from the peer. */
5752 int peer_route_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5754 struct bgp_filter
*filter
;
5755 struct bgp_filter
*gfilter
;
5756 struct peer_group
*group
;
5757 struct listnode
*node
, *nnode
;
5759 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5760 return BGP_ERR_INVALID_VALUE
;
5762 filter
= &peer
->filter
[afi
][safi
];
5764 /* apply peer-group filter */
5765 if (peer_group_active(peer
)) {
5766 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5768 if (gfilter
->map
[direct
].name
) {
5769 if (filter
->map
[direct
].name
)
5770 XFREE(MTYPE_BGP_FILTER_NAME
,
5771 filter
->map
[direct
].name
);
5772 filter
->map
[direct
].name
=
5773 XSTRDUP(MTYPE_BGP_FILTER_NAME
,
5774 gfilter
->map
[direct
].name
);
5775 filter
->map
[direct
].map
= gfilter
->map
[direct
].map
;
5776 peer_on_policy_change(peer
, afi
, safi
,
5777 (direct
== RMAP_OUT
) ? 1 : 0);
5782 if (filter
->map
[direct
].name
)
5783 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5784 filter
->map
[direct
].name
= NULL
;
5785 filter
->map
[direct
].map
= NULL
;
5787 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5788 peer_on_policy_change(peer
, afi
, safi
,
5789 (direct
== RMAP_OUT
) ? 1 : 0);
5793 group
= peer
->group
;
5794 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5795 filter
= &peer
->filter
[afi
][safi
];
5797 if (filter
->map
[direct
].name
)
5798 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5799 filter
->map
[direct
].name
= NULL
;
5800 filter
->map
[direct
].map
= NULL
;
5801 peer_on_policy_change(peer
, afi
, safi
,
5802 (direct
== RMAP_OUT
) ? 1 : 0);
5807 /* Set unsuppress-map to the peer. */
5808 int peer_unsuppress_map_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5811 struct bgp_filter
*filter
;
5812 struct peer_group
*group
;
5813 struct listnode
*node
, *nnode
;
5815 filter
= &peer
->filter
[afi
][safi
];
5817 if (filter
->usmap
.name
)
5818 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5820 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5821 filter
->usmap
.map
= route_map_lookup_by_name(name
);
5823 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5824 peer_on_policy_change(peer
, afi
, safi
, 1);
5828 group
= peer
->group
;
5829 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5830 filter
= &peer
->filter
[afi
][safi
];
5832 if (filter
->usmap
.name
)
5833 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5834 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5835 filter
->usmap
.map
= route_map_lookup_by_name(name
);
5836 peer_on_policy_change(peer
, afi
, safi
, 1);
5841 /* Unset route-map from the peer. */
5842 int peer_unsuppress_map_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5844 struct bgp_filter
*filter
;
5845 struct peer_group
*group
;
5846 struct listnode
*node
, *nnode
;
5848 filter
= &peer
->filter
[afi
][safi
];
5850 if (filter
->usmap
.name
)
5851 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5852 filter
->usmap
.name
= NULL
;
5853 filter
->usmap
.map
= NULL
;
5855 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5856 peer_on_policy_change(peer
, afi
, safi
, 1);
5860 group
= peer
->group
;
5861 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5862 filter
= &peer
->filter
[afi
][safi
];
5864 if (filter
->usmap
.name
)
5865 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5866 filter
->usmap
.name
= NULL
;
5867 filter
->usmap
.map
= NULL
;
5868 peer_on_policy_change(peer
, afi
, safi
, 1);
5873 int peer_maximum_prefix_set(struct peer
*peer
, afi_t afi
, safi_t safi
,
5874 u_int32_t max
, u_char threshold
, int warning
,
5877 struct peer_group
*group
;
5878 struct listnode
*node
, *nnode
;
5880 SET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5881 peer
->pmax
[afi
][safi
] = max
;
5882 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5883 peer
->pmax_restart
[afi
][safi
] = restart
;
5885 SET_FLAG(peer
->af_flags
[afi
][safi
],
5886 PEER_FLAG_MAX_PREFIX_WARNING
);
5888 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
5889 PEER_FLAG_MAX_PREFIX_WARNING
);
5891 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5892 group
= peer
->group
;
5893 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5894 SET_FLAG(peer
->af_flags
[afi
][safi
],
5895 PEER_FLAG_MAX_PREFIX
);
5896 peer
->pmax
[afi
][safi
] = max
;
5897 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5898 peer
->pmax_restart
[afi
][safi
] = restart
;
5900 SET_FLAG(peer
->af_flags
[afi
][safi
],
5901 PEER_FLAG_MAX_PREFIX_WARNING
);
5903 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
5904 PEER_FLAG_MAX_PREFIX_WARNING
);
5906 if ((peer
->status
== Established
)
5907 && (peer
->afc
[afi
][safi
]))
5908 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
5911 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5912 bgp_maximum_prefix_overflow(peer
, afi
, safi
, 1);
5918 int peer_maximum_prefix_unset(struct peer
*peer
, afi_t afi
, safi_t safi
)
5920 struct peer_group
*group
;
5921 struct listnode
*node
, *nnode
;
5923 /* apply peer-group config */
5924 if (peer_group_active(peer
)) {
5925 if (CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
],
5926 PEER_FLAG_MAX_PREFIX
))
5927 SET_FLAG(peer
->af_flags
[afi
][safi
],
5928 PEER_FLAG_MAX_PREFIX
);
5930 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
5931 PEER_FLAG_MAX_PREFIX
);
5933 if (CHECK_FLAG(peer
->group
->conf
->af_flags
[afi
][safi
],
5934 PEER_FLAG_MAX_PREFIX_WARNING
))
5935 SET_FLAG(peer
->af_flags
[afi
][safi
],
5936 PEER_FLAG_MAX_PREFIX_WARNING
);
5938 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
5939 PEER_FLAG_MAX_PREFIX_WARNING
);
5941 peer
->pmax
[afi
][safi
] = peer
->group
->conf
->pmax
[afi
][safi
];
5942 peer
->pmax_threshold
[afi
][safi
] =
5943 peer
->group
->conf
->pmax_threshold
[afi
][safi
];
5944 peer
->pmax_restart
[afi
][safi
] =
5945 peer
->group
->conf
->pmax_restart
[afi
][safi
];
5949 UNSET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5950 UNSET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5951 peer
->pmax
[afi
][safi
] = 0;
5952 peer
->pmax_threshold
[afi
][safi
] = 0;
5953 peer
->pmax_restart
[afi
][safi
] = 0;
5955 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
))
5958 group
= peer
->group
;
5959 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
5960 UNSET_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5961 UNSET_FLAG(peer
->af_flags
[afi
][safi
],
5962 PEER_FLAG_MAX_PREFIX_WARNING
);
5963 peer
->pmax
[afi
][safi
] = 0;
5964 peer
->pmax_threshold
[afi
][safi
] = 0;
5965 peer
->pmax_restart
[afi
][safi
] = 0;
5970 int is_ebgp_multihop_configured(struct peer
*peer
)
5972 struct peer_group
*group
;
5973 struct listnode
*node
, *nnode
;
5976 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
5977 group
= peer
->group
;
5978 if ((peer_sort(peer
) != BGP_PEER_IBGP
)
5979 && (group
->conf
->ttl
!= 1))
5982 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer1
)) {
5983 if ((peer_sort(peer1
) != BGP_PEER_IBGP
)
5984 && (peer1
->ttl
!= 1))
5988 if ((peer_sort(peer
) != BGP_PEER_IBGP
) && (peer
->ttl
!= 1))
5994 /* Set # of hops between us and BGP peer. */
5995 int peer_ttl_security_hops_set(struct peer
*peer
, int gtsm_hops
)
5997 struct peer_group
*group
;
5998 struct listnode
*node
, *nnode
;
6001 zlog_debug("peer_ttl_security_hops_set: set gtsm_hops to %d for %s",
6002 gtsm_hops
, peer
->host
);
6004 /* We cannot configure ttl-security hops when ebgp-multihop is already
6005 set. For non peer-groups, the check is simple. For peer-groups,
6007 slightly messy, because we need to check both the peer-group
6009 and all peer-group members for any trace of ebgp-multihop
6011 before actually applying the ttl-security rules. Cisco really made a
6012 mess of this configuration parameter, and OpenBGPD got it right.
6015 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
)) {
6016 if (is_ebgp_multihop_configured(peer
))
6017 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6019 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6020 peer
->gtsm_hops
= gtsm_hops
;
6022 /* Calling ebgp multihop also resets the session.
6023 * On restart, NHT will get setup correctly as will the
6024 * min & max ttls on the socket. The return value is
6027 ret
= peer_ebgp_multihop_set(peer
, MAXTTL
);
6032 group
= peer
->group
;
6033 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6035 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6037 /* Calling ebgp multihop also resets the
6039 * On restart, NHT will get setup correctly as
6041 * min & max ttls on the socket. The return
6045 peer_ebgp_multihop_set(peer
, MAXTTL
);
6049 /* Post the first gtsm setup or if its ibgp, maxttl setting
6051 * necessary, just set the minttl.
6053 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6054 peer
->gtsm_hops
= gtsm_hops
;
6057 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6058 MAXTTL
+ 1 - gtsm_hops
);
6059 if ((peer
->status
< Established
) && peer
->doppelganger
6060 && (peer
->doppelganger
->fd
>= 0))
6061 sockopt_minttl(peer
->su
.sa
.sa_family
,
6062 peer
->doppelganger
->fd
,
6063 MAXTTL
+ 1 - gtsm_hops
);
6065 group
= peer
->group
;
6066 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
,
6068 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6070 /* Change setting of existing peer
6071 * established then change value (may break
6073 * not established yet (teardown session and
6075 * no session then do nothing (will get
6076 * handled by next connection)
6078 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6080 peer
->su
.sa
.sa_family
, peer
->fd
,
6081 MAXTTL
+ 1 - peer
->gtsm_hops
);
6082 if ((peer
->status
< Established
)
6083 && peer
->doppelganger
6084 && (peer
->doppelganger
->fd
>= 0))
6085 sockopt_minttl(peer
->su
.sa
.sa_family
,
6086 peer
->doppelganger
->fd
,
6087 MAXTTL
+ 1 - gtsm_hops
);
6095 int peer_ttl_security_hops_unset(struct peer
*peer
)
6097 struct peer_group
*group
;
6098 struct listnode
*node
, *nnode
;
6101 zlog_debug("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s",
6104 /* if a peer-group member, then reset to peer-group default rather than
6106 if (peer_group_active(peer
))
6107 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6109 peer
->gtsm_hops
= 0;
6111 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6112 /* Invoking ebgp_multihop_set will set the TTL back to the
6114 * value as well as restting the NHT and such. The session is
6117 if (peer
->sort
== BGP_PEER_EBGP
)
6118 ret
= peer_ebgp_multihop_unset(peer
);
6121 sockopt_minttl(peer
->su
.sa
.sa_family
, peer
->fd
,
6124 if ((peer
->status
< Established
) && peer
->doppelganger
6125 && (peer
->doppelganger
->fd
>= 0))
6126 sockopt_minttl(peer
->su
.sa
.sa_family
,
6127 peer
->doppelganger
->fd
, 0);
6130 group
= peer
->group
;
6131 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
6132 peer
->gtsm_hops
= 0;
6133 if (peer
->sort
== BGP_PEER_EBGP
)
6134 ret
= peer_ebgp_multihop_unset(peer
);
6137 sockopt_minttl(peer
->su
.sa
.sa_family
,
6140 if ((peer
->status
< Established
)
6141 && peer
->doppelganger
6142 && (peer
->doppelganger
->fd
>= 0))
6143 sockopt_minttl(peer
->su
.sa
.sa_family
,
6144 peer
->doppelganger
->fd
,
6154 * If peer clear is invoked in a loop for all peers on the BGP instance,
6155 * it may end up freeing the doppelganger, and if this was the next node
6156 * to the current node, we would end up accessing the freed next node.
6157 * Pass along additional parameter which can be updated if next node
6158 * is freed; only required when walking the peer list on BGP instance.
6160 int peer_clear(struct peer
*peer
, struct listnode
**nnode
)
6162 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)) {
6163 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
)) {
6164 UNSET_FLAG(peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6165 if (peer
->t_pmax_restart
) {
6166 BGP_TIMER_OFF(peer
->t_pmax_restart
);
6167 if (bgp_debug_neighbor_events(peer
))
6169 "%s Maximum-prefix restart timer canceled",
6172 BGP_EVENT_ADD(peer
, BGP_Start
);
6176 peer
->v_start
= BGP_INIT_START_TIMER
;
6177 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6178 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
6179 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6181 bgp_session_reset_safe(peer
, nnode
);
6186 int peer_clear_soft(struct peer
*peer
, afi_t afi
, safi_t safi
,
6187 enum bgp_clear_type stype
)
6189 struct peer_af
*paf
;
6191 if (peer
->status
!= Established
)
6194 if (!peer
->afc
[afi
][safi
])
6195 return BGP_ERR_AF_UNCONFIGURED
;
6197 peer
->rtt
= sockopt_tcp_rtt(peer
->fd
);
6199 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
) {
6200 /* Clear the "neighbor x.x.x.x default-originate" flag */
6201 paf
= peer_af_find(peer
, afi
, safi
);
6202 if (paf
&& paf
->subgroup
6203 && CHECK_FLAG(paf
->subgroup
->sflags
,
6204 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6205 UNSET_FLAG(paf
->subgroup
->sflags
,
6206 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6208 bgp_announce_route(peer
, afi
, safi
);
6211 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6212 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6213 PEER_CAP_ORF_PREFIX_SM_ADV
)
6214 && (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6215 PEER_CAP_ORF_PREFIX_RM_RCV
)
6216 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6217 PEER_CAP_ORF_PREFIX_RM_OLD_RCV
))) {
6218 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6221 if (CHECK_FLAG(peer
->af_cap
[afi
][safi
],
6222 PEER_CAP_ORF_PREFIX_RM_RCV
))
6223 prefix_type
= ORF_TYPE_PREFIX
;
6225 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6227 if (filter
->plist
[FILTER_IN
].plist
) {
6228 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6229 PEER_STATUS_ORF_PREFIX_SEND
))
6230 bgp_route_refresh_send(
6231 peer
, afi
, safi
, prefix_type
,
6233 bgp_route_refresh_send(peer
, afi
, safi
,
6235 REFRESH_IMMEDIATE
, 0);
6237 if (CHECK_FLAG(peer
->af_sflags
[afi
][safi
],
6238 PEER_STATUS_ORF_PREFIX_SEND
))
6239 bgp_route_refresh_send(
6240 peer
, afi
, safi
, prefix_type
,
6241 REFRESH_IMMEDIATE
, 1);
6243 bgp_route_refresh_send(peer
, afi
, safi
,
6250 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6251 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
) {
6252 /* If neighbor has soft reconfiguration inbound flag.
6253 Use Adj-RIB-In database. */
6254 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6255 PEER_FLAG_SOFT_RECONFIG
))
6256 bgp_soft_reconfig_in(peer
, afi
, safi
);
6258 /* If neighbor has route refresh capability, send route
6260 message to the peer. */
6261 if (CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6262 || CHECK_FLAG(peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6263 bgp_route_refresh_send(peer
, afi
, safi
, 0, 0,
6266 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6272 /* Display peer uptime.*/
6273 char *peer_uptime(time_t uptime2
, char *buf
, size_t len
, u_char use_json
,
6276 time_t uptime1
, epoch_tbuf
;
6279 /* Check buffer length. */
6280 if (len
< BGP_UPTIME_LEN
) {
6282 zlog_warn("peer_uptime (): buffer shortage %lu",
6284 /* XXX: should return status instead of buf... */
6285 snprintf(buf
, len
, "<error> ");
6290 /* If there is no connection has been done before print `never'. */
6293 json_object_string_add(json
, "peerUptime", "never");
6294 json_object_int_add(json
, "peerUptimeMsec", 0);
6296 snprintf(buf
, len
, "never");
6300 /* Get current time. */
6301 uptime1
= bgp_clock();
6303 tm
= gmtime(&uptime1
);
6305 if (uptime1
< ONE_DAY_SECOND
)
6306 snprintf(buf
, len
, "%02d:%02d:%02d", tm
->tm_hour
, tm
->tm_min
,
6308 else if (uptime1
< ONE_WEEK_SECOND
)
6309 snprintf(buf
, len
, "%dd%02dh%02dm", tm
->tm_yday
, tm
->tm_hour
,
6311 else if (uptime1
< ONE_YEAR_SECOND
)
6312 snprintf(buf
, len
, "%02dw%dd%02dh", tm
->tm_yday
/ 7,
6313 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7), tm
->tm_hour
);
6315 snprintf(buf
, len
, "%02dy%02dw%dd", tm
->tm_year
- 70,
6317 tm
->tm_yday
- ((tm
->tm_yday
/ 7) * 7));
6320 epoch_tbuf
= time(NULL
) - uptime1
;
6321 json_object_string_add(json
, "peerUptime", buf
);
6322 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
6323 json_object_int_add(json
, "peerUptimeEstablishedEpoch",
6330 static void bgp_config_write_filter(struct vty
*vty
, struct peer
*peer
,
6331 afi_t afi
, safi_t safi
)
6333 struct bgp_filter
*filter
;
6334 struct bgp_filter
*gfilter
= NULL
;
6337 int out
= FILTER_OUT
;
6340 filter
= &peer
->filter
[afi
][safi
];
6342 if (peer_group_active(peer
))
6343 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
6345 /* distribute-list. */
6346 if (filter
->dlist
[in
].name
)
6347 if (!gfilter
|| !gfilter
->dlist
[in
].name
6348 || strcmp(filter
->dlist
[in
].name
, gfilter
->dlist
[in
].name
)
6350 vty_out(vty
, " neighbor %s distribute-list %s in\n",
6351 addr
, filter
->dlist
[in
].name
);
6354 if (filter
->dlist
[out
].name
&& !gfilter
) {
6355 vty_out(vty
, " neighbor %s distribute-list %s out\n", addr
,
6356 filter
->dlist
[out
].name
);
6360 if (filter
->plist
[in
].name
)
6361 if (!gfilter
|| !gfilter
->plist
[in
].name
6362 || strcmp(filter
->plist
[in
].name
, gfilter
->plist
[in
].name
)
6364 vty_out(vty
, " neighbor %s prefix-list %s in\n", addr
,
6365 filter
->plist
[in
].name
);
6368 if (filter
->plist
[out
].name
)
6369 if (!gfilter
|| !gfilter
->plist
[out
].name
6370 || strcmp(filter
->plist
[out
].name
, gfilter
->plist
[out
].name
)
6372 vty_out(vty
, " neighbor %s prefix-list %s out\n", addr
,
6373 filter
->plist
[out
].name
);
6377 if (filter
->map
[RMAP_IN
].name
)
6378 if (!gfilter
|| !gfilter
->map
[RMAP_IN
].name
6379 || strcmp(filter
->map
[RMAP_IN
].name
,
6380 gfilter
->map
[RMAP_IN
].name
)
6382 vty_out(vty
, " neighbor %s route-map %s in\n", addr
,
6383 filter
->map
[RMAP_IN
].name
);
6386 if (filter
->map
[RMAP_OUT
].name
)
6387 if (!gfilter
|| !gfilter
->map
[RMAP_OUT
].name
6388 || strcmp(filter
->map
[RMAP_OUT
].name
,
6389 gfilter
->map
[RMAP_OUT
].name
)
6391 vty_out(vty
, " neighbor %s route-map %s out\n", addr
,
6392 filter
->map
[RMAP_OUT
].name
);
6395 /* unsuppress-map */
6396 if (filter
->usmap
.name
&& !gfilter
) {
6397 vty_out(vty
, " neighbor %s unsuppress-map %s\n", addr
,
6398 filter
->usmap
.name
);
6402 if (filter
->aslist
[in
].name
)
6403 if (!gfilter
|| !gfilter
->aslist
[in
].name
6404 || strcmp(filter
->aslist
[in
].name
, gfilter
->aslist
[in
].name
)
6406 vty_out(vty
, " neighbor %s filter-list %s in\n", addr
,
6407 filter
->aslist
[in
].name
);
6410 if (filter
->aslist
[out
].name
&& !gfilter
) {
6411 vty_out(vty
, " neighbor %s filter-list %s out\n", addr
,
6412 filter
->aslist
[out
].name
);
6416 /* BGP peer configuration display function. */
6417 static void bgp_config_write_peer_global(struct vty
*vty
, struct bgp
*bgp
,
6420 struct peer
*g_peer
= NULL
;
6421 char buf
[SU_ADDRSTRLEN
];
6423 int if_pg_printed
= FALSE
;
6424 int if_ras_printed
= FALSE
;
6426 /* Skip dynamic neighbors. */
6427 if (peer_dynamic_neighbor(peer
))
6431 addr
= peer
->conf_if
;
6435 /************************************
6436 ****** Global to the neighbor ******
6437 ************************************/
6438 if (peer
->conf_if
) {
6439 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6440 vty_out(vty
, " neighbor %s interface v6only", addr
);
6442 vty_out(vty
, " neighbor %s interface", addr
);
6444 if (peer_group_active(peer
)) {
6445 vty_out(vty
, " peer-group %s", peer
->group
->name
);
6446 if_pg_printed
= TRUE
;
6447 } else if (peer
->as_type
== AS_SPECIFIED
) {
6448 vty_out(vty
, " remote-as %u", peer
->as
);
6449 if_ras_printed
= TRUE
;
6450 } else if (peer
->as_type
== AS_INTERNAL
) {
6451 vty_out(vty
, " remote-as internal");
6452 if_ras_printed
= TRUE
;
6453 } else if (peer
->as_type
== AS_EXTERNAL
) {
6454 vty_out(vty
, " remote-as external");
6455 if_ras_printed
= TRUE
;
6461 /* remote-as and peer-group */
6462 /* peer is a member of a peer-group */
6463 if (peer_group_active(peer
)) {
6464 g_peer
= peer
->group
->conf
;
6466 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
) {
6467 if (peer
->as_type
== AS_SPECIFIED
) {
6468 vty_out(vty
, " neighbor %s remote-as %u\n",
6470 } else if (peer
->as_type
== AS_INTERNAL
) {
6472 " neighbor %s remote-as internal\n",
6474 } else if (peer
->as_type
== AS_EXTERNAL
) {
6476 " neighbor %s remote-as external\n",
6481 /* For swpX peers we displayed the peer-group
6482 * via 'neighbor swpX interface peer-group WORD' */
6484 vty_out(vty
, " neighbor %s peer-group %s\n", addr
,
6488 /* peer is NOT a member of a peer-group */
6490 /* peer is a peer-group, declare the peer-group */
6491 if (CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
6492 vty_out(vty
, " neighbor %s peer-group\n", addr
);
6495 if (!if_ras_printed
) {
6496 if (peer
->as_type
== AS_SPECIFIED
) {
6497 vty_out(vty
, " neighbor %s remote-as %u\n",
6499 } else if (peer
->as_type
== AS_INTERNAL
) {
6501 " neighbor %s remote-as internal\n",
6503 } else if (peer
->as_type
== AS_EXTERNAL
) {
6505 " neighbor %s remote-as external\n",
6512 if (peer
->change_local_as
) {
6513 if (!peer_group_active(peer
)
6514 || peer
->change_local_as
!= g_peer
->change_local_as
6515 || (CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)
6516 != CHECK_FLAG(g_peer
->flags
,
6517 PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6518 || (CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)
6519 != CHECK_FLAG(g_peer
->flags
,
6520 PEER_FLAG_LOCAL_AS_REPLACE_AS
))) {
6521 vty_out(vty
, " neighbor %s local-as %u%s%s\n", addr
,
6522 peer
->change_local_as
,
6523 CHECK_FLAG(peer
->flags
,
6524 PEER_FLAG_LOCAL_AS_NO_PREPEND
)
6527 CHECK_FLAG(peer
->flags
,
6528 PEER_FLAG_LOCAL_AS_REPLACE_AS
)
6536 vty_out(vty
, " neighbor %s description %s\n", addr
, peer
->desc
);
6540 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_SHUTDOWN
)) {
6541 if (!peer_group_active(peer
)
6542 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_SHUTDOWN
)
6543 || peer
->tx_shutdown_message
) {
6544 if (peer
->tx_shutdown_message
)
6546 " neighbor %s shutdown message %s\n",
6547 addr
, peer
->tx_shutdown_message
);
6549 vty_out(vty
, " neighbor %s shutdown\n", addr
);
6554 if (peer
->bfd_info
) {
6555 if (!peer_group_active(peer
) || !g_peer
->bfd_info
) {
6556 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6561 if (peer
->password
) {
6562 if (!peer_group_active(peer
) || !g_peer
->password
6563 || strcmp(peer
->password
, g_peer
->password
) != 0) {
6564 vty_out(vty
, " neighbor %s password %s\n", addr
,
6570 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
)) {
6571 if (!peer_group_active(peer
)) {
6572 vty_out(vty
, " neighbor %s solo\n", addr
);
6577 if (peer
->port
!= BGP_PORT_DEFAULT
) {
6578 vty_out(vty
, " neighbor %s port %d\n", addr
, peer
->port
);
6581 /* Local interface name */
6583 vty_out(vty
, " neighbor %s interface %s\n", addr
, peer
->ifname
);
6587 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_PASSIVE
)) {
6588 if (!peer_group_active(peer
)
6589 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_PASSIVE
)) {
6590 vty_out(vty
, " neighbor %s passive\n", addr
);
6595 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1
6596 && !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
)) {
6597 if (!peer_group_active(peer
) || g_peer
->ttl
!= peer
->ttl
) {
6598 vty_out(vty
, " neighbor %s ebgp-multihop %d\n", addr
,
6603 /* ttl-security hops */
6604 if (peer
->gtsm_hops
!= 0) {
6605 if (!peer_group_active(peer
)
6606 || g_peer
->gtsm_hops
!= peer
->gtsm_hops
) {
6607 vty_out(vty
, " neighbor %s ttl-security hops %d\n",
6608 addr
, peer
->gtsm_hops
);
6612 /* disable-connected-check */
6613 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
)) {
6614 if (!peer_group_active(peer
)
6615 || !CHECK_FLAG(g_peer
->flags
,
6616 PEER_FLAG_DISABLE_CONNECTED_CHECK
)) {
6617 vty_out(vty
, " neighbor %s disable-connected-check\n",
6623 if (peer
->update_if
) {
6624 if (!peer_group_active(peer
) || !g_peer
->update_if
6625 || strcmp(g_peer
->update_if
, peer
->update_if
) != 0) {
6626 vty_out(vty
, " neighbor %s update-source %s\n", addr
,
6630 if (peer
->update_source
) {
6631 if (!peer_group_active(peer
) || !g_peer
->update_source
6632 || sockunion_cmp(g_peer
->update_source
, peer
->update_source
)
6634 vty_out(vty
, " neighbor %s update-source %s\n", addr
,
6635 sockunion2str(peer
->update_source
, buf
,
6640 /* advertisement-interval */
6641 if (CHECK_FLAG(peer
->config
, PEER_CONFIG_ROUTEADV
)
6642 && ((!peer_group_active(peer
)
6643 && peer
->v_routeadv
!= BGP_DEFAULT_EBGP_ROUTEADV
)
6644 || (peer_group_active(peer
)
6645 && peer
->v_routeadv
!= g_peer
->v_routeadv
))) {
6646 vty_out(vty
, " neighbor %s advertisement-interval %u\n", addr
,
6651 if ((PEER_OR_GROUP_TIMER_SET(peer
))
6652 && ((!peer_group_active(peer
)
6653 && (peer
->keepalive
!= BGP_DEFAULT_KEEPALIVE
6654 || peer
->holdtime
!= BGP_DEFAULT_HOLDTIME
))
6655 || (peer_group_active(peer
)
6656 && (peer
->keepalive
!= g_peer
->keepalive
6657 || peer
->holdtime
!= g_peer
->holdtime
)))) {
6658 vty_out(vty
, " neighbor %s timers %u %u\n", addr
,
6659 peer
->keepalive
, peer
->holdtime
);
6662 if (CHECK_FLAG(peer
->config
, PEER_CONFIG_CONNECT
)
6663 && ((!peer_group_active(peer
)
6664 && peer
->connect
!= BGP_DEFAULT_CONNECT_RETRY
)
6665 || (peer_group_active(peer
)
6666 && peer
->connect
!= g_peer
->connect
)))
6669 vty_out(vty
, " neighbor %s timers connect %u\n", addr
,
6673 /* capability dynamic */
6674 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
)) {
6675 if (!peer_group_active(peer
)
6676 || !CHECK_FLAG(g_peer
->flags
,
6677 PEER_FLAG_DYNAMIC_CAPABILITY
)) {
6678 vty_out(vty
, " neighbor %s capability dynamic\n", addr
);
6682 /* capability extended-nexthop */
6683 if (peer
->ifp
&& !CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)) {
6684 if (!peer_group_active(peer
)
6685 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)) {
6687 " no neighbor %s capability extended-nexthop\n",
6692 if (!peer
->ifp
&& CHECK_FLAG(peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)) {
6693 if (!peer_group_active(peer
)
6694 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
)) {
6696 " neighbor %s capability extended-nexthop\n",
6701 /* dont-capability-negotiation */
6702 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_DONT_CAPABILITY
)) {
6703 if (!peer_group_active(peer
)
6704 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_DONT_CAPABILITY
)) {
6705 vty_out(vty
, " neighbor %s dont-capability-negotiate\n",
6710 /* override-capability */
6711 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
)) {
6712 if (!peer_group_active(peer
)
6713 || !CHECK_FLAG(g_peer
->flags
,
6714 PEER_FLAG_OVERRIDE_CAPABILITY
)) {
6715 vty_out(vty
, " neighbor %s override-capability\n",
6720 /* strict-capability-match */
6721 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
6722 if (!peer_group_active(peer
)
6723 || !CHECK_FLAG(g_peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
)) {
6724 vty_out(vty
, " neighbor %s strict-capability-match\n",
6730 /* BGP peer configuration display function. */
6731 static void bgp_config_write_peer_af(struct vty
*vty
, struct bgp
*bgp
,
6732 struct peer
*peer
, afi_t afi
, safi_t safi
)
6734 struct peer
*g_peer
= NULL
;
6737 /* Skip dynamic neighbors. */
6738 if (peer_dynamic_neighbor(peer
))
6742 addr
= peer
->conf_if
;
6746 /************************************
6747 ****** Per AF to the neighbor ******
6748 ************************************/
6749 if (peer_group_active(peer
)) {
6750 g_peer
= peer
->group
->conf
;
6752 /* If the peer-group is active but peer is not, print a 'no
6754 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
]) {
6755 vty_out(vty
, " no neighbor %s activate\n", addr
);
6758 /* If the peer-group is not active but peer is, print an
6760 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
]) {
6761 vty_out(vty
, " neighbor %s activate\n", addr
);
6764 if (peer
->afc
[afi
][safi
]) {
6765 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
)) {
6766 if (bgp_flag_check(bgp
,
6767 BGP_FLAG_NO_DEFAULT_IPV4
)) {
6768 vty_out(vty
, " neighbor %s activate\n",
6772 vty_out(vty
, " neighbor %s activate\n", addr
);
6774 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
)) {
6775 if (!bgp_flag_check(bgp
,
6776 BGP_FLAG_NO_DEFAULT_IPV4
)) {
6778 " no neighbor %s activate\n",
6785 /* addpath TX knobs */
6786 if (peergroup_af_flag_check(peer
, afi
, safi
,
6787 PEER_FLAG_ADDPATH_TX_ALL_PATHS
)) {
6788 vty_out(vty
, " neighbor %s addpath-tx-all-paths\n", addr
);
6791 if (peergroup_af_flag_check(peer
, afi
, safi
,
6792 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)) {
6793 vty_out(vty
, " neighbor %s addpath-tx-bestpath-per-AS\n",
6797 /* ORF capability. */
6798 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
)
6799 || peergroup_af_flag_check(peer
, afi
, safi
,
6800 PEER_FLAG_ORF_PREFIX_RM
)) {
6801 vty_out(vty
, " neighbor %s capability orf prefix-list", addr
);
6803 if (peergroup_af_flag_check(peer
, afi
, safi
,
6804 PEER_FLAG_ORF_PREFIX_SM
)
6805 && peergroup_af_flag_check(peer
, afi
, safi
,
6806 PEER_FLAG_ORF_PREFIX_RM
))
6807 vty_out(vty
, " both");
6808 else if (peergroup_af_flag_check(peer
, afi
, safi
,
6809 PEER_FLAG_ORF_PREFIX_SM
))
6810 vty_out(vty
, " send");
6812 vty_out(vty
, " receive");
6816 /* Route reflector client. */
6817 if (peergroup_af_flag_check(peer
, afi
, safi
,
6818 PEER_FLAG_REFLECTOR_CLIENT
)) {
6819 vty_out(vty
, " neighbor %s route-reflector-client\n", addr
);
6822 /* next-hop-self force */
6823 if (peergroup_af_flag_check(peer
, afi
, safi
,
6824 PEER_FLAG_FORCE_NEXTHOP_SELF
)) {
6825 vty_out(vty
, " neighbor %s next-hop-self force\n", addr
);
6829 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
)) {
6830 vty_out(vty
, " neighbor %s next-hop-self\n", addr
);
6833 /* remove-private-AS */
6834 if (peergroup_af_flag_check(peer
, afi
, safi
,
6835 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)) {
6836 vty_out(vty
, " neighbor %s remove-private-AS all replace-AS\n",
6840 else if (peergroup_af_flag_check(peer
, afi
, safi
,
6841 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)) {
6842 vty_out(vty
, " neighbor %s remove-private-AS replace-AS\n",
6846 else if (peergroup_af_flag_check(peer
, afi
, safi
,
6847 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)) {
6848 vty_out(vty
, " neighbor %s remove-private-AS all\n", addr
);
6851 else if (peergroup_af_flag_check(peer
, afi
, safi
,
6852 PEER_FLAG_REMOVE_PRIVATE_AS
)) {
6853 vty_out(vty
, " neighbor %s remove-private-AS\n", addr
);
6857 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
)) {
6858 vty_out(vty
, " neighbor %s as-override\n", addr
);
6861 /* send-community print. */
6862 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
6863 if (peergroup_af_flag_check(peer
, afi
, safi
,
6864 PEER_FLAG_SEND_COMMUNITY
)
6865 && peergroup_af_flag_check(peer
, afi
, safi
,
6866 PEER_FLAG_SEND_EXT_COMMUNITY
)
6867 && peergroup_af_flag_check(
6869 PEER_FLAG_SEND_LARGE_COMMUNITY
)) {
6870 vty_out(vty
, " neighbor %s send-community all\n",
6872 } else if (peergroup_af_flag_check(
6874 PEER_FLAG_SEND_LARGE_COMMUNITY
)) {
6875 vty_out(vty
, " neighbor %s send-community large\n",
6877 } else if (peergroup_af_flag_check(
6879 PEER_FLAG_SEND_EXT_COMMUNITY
)) {
6880 vty_out(vty
, " neighbor %s send-community extended\n",
6882 } else if (peergroup_af_flag_check(peer
, afi
, safi
,
6883 PEER_FLAG_SEND_COMMUNITY
)) {
6884 vty_out(vty
, " neighbor %s send-community\n", addr
);
6887 if (!peer_af_flag_check(peer
, afi
, safi
,
6888 PEER_FLAG_SEND_COMMUNITY
)
6889 && (!g_peer
|| peer_af_flag_check(g_peer
, afi
, safi
,
6890 PEER_FLAG_SEND_COMMUNITY
))
6891 && !peer_af_flag_check(peer
, afi
, safi
,
6892 PEER_FLAG_SEND_EXT_COMMUNITY
)
6894 || peer_af_flag_check(g_peer
, afi
, safi
,
6895 PEER_FLAG_SEND_EXT_COMMUNITY
))
6896 && !peer_af_flag_check(peer
, afi
, safi
,
6897 PEER_FLAG_SEND_LARGE_COMMUNITY
)
6898 && (!g_peer
|| peer_af_flag_check(
6900 PEER_FLAG_SEND_LARGE_COMMUNITY
))) {
6901 vty_out(vty
, " no neighbor %s send-community all\n",
6904 if (!peer_af_flag_check(peer
, afi
, safi
,
6905 PEER_FLAG_SEND_LARGE_COMMUNITY
)
6907 || peer_af_flag_check(
6909 PEER_FLAG_SEND_LARGE_COMMUNITY
))) {
6911 " no neighbor %s send-community large\n",
6915 if (!peer_af_flag_check(peer
, afi
, safi
,
6916 PEER_FLAG_SEND_EXT_COMMUNITY
)
6918 || peer_af_flag_check(
6920 PEER_FLAG_SEND_EXT_COMMUNITY
))) {
6922 " no neighbor %s send-community extended\n",
6926 if (!peer_af_flag_check(peer
, afi
, safi
,
6927 PEER_FLAG_SEND_COMMUNITY
)
6928 && (!g_peer
|| peer_af_flag_check(
6930 PEER_FLAG_SEND_COMMUNITY
))) {
6932 " no neighbor %s send-community\n",
6938 /* Default information */
6939 if (peergroup_af_flag_check(peer
, afi
, safi
,
6940 PEER_FLAG_DEFAULT_ORIGINATE
)
6942 && ((peer
->default_rmap
[afi
][safi
].name
6943 && !g_peer
->default_rmap
[afi
][safi
].name
)
6944 || (!peer
->default_rmap
[afi
][safi
].name
6945 && g_peer
->default_rmap
[afi
][safi
].name
)
6946 || (peer
->default_rmap
[afi
][safi
].name
6947 && strcmp(peer
->default_rmap
[afi
][safi
].name
,
6948 g_peer
->default_rmap
[afi
][safi
].name
))))) {
6949 vty_out(vty
, " neighbor %s default-originate", addr
);
6950 if (peer
->default_rmap
[afi
][safi
].name
)
6951 vty_out(vty
, " route-map %s",
6952 peer
->default_rmap
[afi
][safi
].name
);
6956 /* Soft reconfiguration inbound. */
6957 if (peergroup_af_flag_check(peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
)) {
6958 vty_out(vty
, " neighbor %s soft-reconfiguration inbound\n",
6962 /* maximum-prefix. */
6963 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
6964 if (!peer_group_active(peer
)
6965 || g_peer
->pmax
[afi
][safi
] != peer
->pmax
[afi
][safi
]
6966 || g_peer
->pmax_threshold
[afi
][safi
]
6967 != peer
->pmax_threshold
[afi
][safi
]
6968 || CHECK_FLAG(g_peer
->af_flags
[afi
][safi
],
6969 PEER_FLAG_MAX_PREFIX_WARNING
)
6970 != CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6971 PEER_FLAG_MAX_PREFIX_WARNING
)) {
6972 vty_out(vty
, " neighbor %s maximum-prefix %lu", addr
,
6973 peer
->pmax
[afi
][safi
]);
6974 if (peer
->pmax_threshold
[afi
][safi
]
6975 != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
6977 peer
->pmax_threshold
[afi
][safi
]);
6978 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
6979 PEER_FLAG_MAX_PREFIX_WARNING
))
6980 vty_out(vty
, " warning-only");
6981 if (peer
->pmax_restart
[afi
][safi
])
6982 vty_out(vty
, " restart %u",
6983 peer
->pmax_restart
[afi
][safi
]);
6987 /* Route server client. */
6988 if (peergroup_af_flag_check(peer
, afi
, safi
,
6989 PEER_FLAG_RSERVER_CLIENT
)) {
6990 vty_out(vty
, " neighbor %s route-server-client\n", addr
);
6993 /* Nexthop-local unchanged. */
6994 if (peergroup_af_flag_check(peer
, afi
, safi
,
6995 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
)) {
6996 vty_out(vty
, " neighbor %s nexthop-local unchanged\n", addr
);
6999 /* allowas-in <1-10> */
7000 if (peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)) {
7001 if (!peer_group_active(peer
)
7002 || !peer_af_flag_check(g_peer
, afi
, safi
,
7003 PEER_FLAG_ALLOWAS_IN
)
7004 || peer
->allowas_in
[afi
][safi
]
7005 != g_peer
->allowas_in
[afi
][safi
]) {
7006 if (peer
->allowas_in
[afi
][safi
] == 3) {
7007 vty_out(vty
, " neighbor %s allowas-in\n",
7010 vty_out(vty
, " neighbor %s allowas-in %d\n",
7011 addr
, peer
->allowas_in
[afi
][safi
]);
7016 /* allowas-in origin */
7017 else if (peer_af_flag_check(peer
, afi
, safi
,
7018 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
7019 if (!peer_group_active(peer
)
7020 || !peer_af_flag_check(g_peer
, afi
, safi
,
7021 PEER_FLAG_ALLOWAS_IN_ORIGIN
)) {
7022 vty_out(vty
, " neighbor %s allowas-in origin\n", addr
);
7027 if (peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7028 if (!peer_group_active(peer
)
7029 || !peer_af_flag_check(g_peer
, afi
, safi
, PEER_FLAG_WEIGHT
)
7030 || peer
->weight
[afi
][safi
] != g_peer
->weight
[afi
][safi
]) {
7031 if (peer
->weight
[afi
][safi
]) {
7032 vty_out(vty
, " neighbor %s weight %lu\n", addr
,
7033 peer
->weight
[afi
][safi
]);
7038 bgp_config_write_filter(vty
, peer
, afi
, safi
);
7040 /* atribute-unchanged. */
7041 if (peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7042 || peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
)
7043 || peer_af_flag_check(peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
)) {
7045 if (!peer_group_active(peer
)
7046 || peergroup_af_flag_check(peer
, afi
, safi
,
7047 PEER_FLAG_AS_PATH_UNCHANGED
)
7048 || peergroup_af_flag_check(peer
, afi
, safi
,
7049 PEER_FLAG_NEXTHOP_UNCHANGED
)
7050 || peergroup_af_flag_check(peer
, afi
, safi
,
7051 PEER_FLAG_MED_UNCHANGED
)) {
7054 " neighbor %s attribute-unchanged%s%s%s\n",
7056 peer_af_flag_check(peer
, afi
, safi
,
7057 PEER_FLAG_AS_PATH_UNCHANGED
)
7060 peer_af_flag_check(peer
, afi
, safi
,
7061 PEER_FLAG_NEXTHOP_UNCHANGED
)
7064 peer_af_flag_check(peer
, afi
, safi
,
7065 PEER_FLAG_MED_UNCHANGED
)
7072 /* Address family based peer configuration display. */
7073 static void bgp_config_write_family(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7077 struct peer_group
*group
;
7078 struct listnode
*node
, *nnode
;
7081 vty_frame(vty
, " !\n address-family ");
7082 if (afi
== AFI_IP
) {
7083 if (safi
== SAFI_UNICAST
)
7084 vty_frame(vty
, "ipv4 unicast");
7085 else if (safi
== SAFI_LABELED_UNICAST
)
7086 vty_frame(vty
, "ipv4 labeled-unicast");
7087 else if (safi
== SAFI_MULTICAST
)
7088 vty_frame(vty
, "ipv4 multicast");
7089 else if (safi
== SAFI_MPLS_VPN
)
7090 vty_frame(vty
, "ipv4 vpn");
7091 else if (safi
== SAFI_ENCAP
)
7092 vty_frame(vty
, "ipv4 encap");
7093 } else if (afi
== AFI_IP6
) {
7094 if (safi
== SAFI_UNICAST
)
7095 vty_frame(vty
, "ipv6 unicast");
7096 else if (safi
== SAFI_LABELED_UNICAST
)
7097 vty_frame(vty
, "ipv6 labeled-unicast");
7098 else if (safi
== SAFI_MULTICAST
)
7099 vty_frame(vty
, "ipv6 multicast");
7100 else if (safi
== SAFI_MPLS_VPN
)
7101 vty_frame(vty
, "ipv6 vpn");
7102 else if (safi
== SAFI_ENCAP
)
7103 vty_frame(vty
, "ipv6 encap");
7104 } else if (afi
== AFI_L2VPN
) {
7105 if (safi
== SAFI_EVPN
)
7106 vty_frame(vty
, "l2vpn evpn");
7108 vty_frame(vty
, "\n");
7110 bgp_config_write_distance(vty
, bgp
, afi
, safi
);
7112 bgp_config_write_network(vty
, bgp
, afi
, safi
);
7114 bgp_config_write_redistribute(vty
, bgp
, afi
, safi
);
7116 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
))
7117 bgp_config_write_peer_af(vty
, bgp
, group
->conf
, afi
, safi
);
7119 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7120 /* Skip dynamic neighbors. */
7121 if (peer_dynamic_neighbor(peer
))
7124 /* Do not display doppelganger peers */
7125 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7126 bgp_config_write_peer_af(vty
, bgp
, peer
, afi
, safi
);
7129 bgp_config_write_maxpaths(vty
, bgp
, afi
, safi
);
7130 bgp_config_write_table_map(vty
, bgp
, afi
, safi
);
7132 if (safi
== SAFI_EVPN
)
7133 bgp_config_write_evpn_info(vty
, bgp
, afi
, safi
);
7135 if (safi
== SAFI_UNICAST
) {
7136 bgp_vpn_policy_config_write_afi(vty
, bgp
, afi
);
7137 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
7138 BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT
)) {
7140 vty_out(vty
, " export vpn\n");
7142 if (CHECK_FLAG(bgp
->af_flags
[afi
][safi
],
7143 BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT
)) {
7145 vty_out(vty
, " import vpn\n");
7149 vty_endframe(vty
, " exit-address-family\n");
7152 int bgp_config_write(struct vty
*vty
)
7156 struct peer_group
*group
;
7158 struct listnode
*node
, *nnode
;
7159 struct listnode
*mnode
, *mnnode
;
7161 /* BGP Multiple instance. */
7162 if (!bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
7163 vty_out(vty
, "no bgp multiple-instance\n");
7167 /* BGP Config type. */
7168 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
)) {
7169 vty_out(vty
, "bgp config-type cisco\n");
7173 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7174 vty_out(vty
, "bgp route-map delay-timer %u\n",
7175 bm
->rmap_update_timer
);
7178 vty_out(vty
, "!\n");
7180 /* BGP configuration. */
7181 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
)) {
7183 /* skip all auto created vrf as they dont have user config */
7184 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_AUTO
))
7187 /* Router bgp ASN */
7188 vty_out(vty
, "router bgp %u", bgp
->as
);
7190 if (bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE
)) {
7192 vty_out(vty
, " %s %s",
7194 == BGP_INSTANCE_TYPE_VIEW
)
7201 /* No Synchronization */
7202 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
))
7203 vty_out(vty
, " no synchronization\n");
7205 /* BGP fast-external-failover. */
7206 if (CHECK_FLAG(bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7207 vty_out(vty
, " no bgp fast-external-failover\n");
7209 /* BGP router ID. */
7210 if (bgp
->router_id_static
.s_addr
!= 0)
7211 vty_out(vty
, " bgp router-id %s\n",
7212 inet_ntoa(bgp
->router_id_static
));
7214 /* BGP log-neighbor-changes. */
7215 if (!!bgp_flag_check(bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7216 != DFLT_BGP_LOG_NEIGHBOR_CHANGES
)
7217 vty_out(vty
, " %sbgp log-neighbor-changes\n",
7219 BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7223 /* BGP configuration. */
7224 if (bgp_flag_check(bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7225 vty_out(vty
, " bgp always-compare-med\n");
7227 /* BGP default ipv4-unicast. */
7228 if (bgp_flag_check(bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7229 vty_out(vty
, " no bgp default ipv4-unicast\n");
7231 /* BGP default local-preference. */
7232 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7233 vty_out(vty
, " bgp default local-preference %u\n",
7234 bgp
->default_local_pref
);
7236 /* BGP default show-hostname */
7237 if (!!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7238 != DFLT_BGP_SHOW_HOSTNAME
)
7239 vty_out(vty
, " %sbgp default show-hostname\n",
7240 bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7244 /* BGP default subgroup-pkt-queue-max. */
7245 if (bgp
->default_subgroup_pkt_queue_max
7246 != BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7247 vty_out(vty
, " bgp default subgroup-pkt-queue-max %u\n",
7248 bgp
->default_subgroup_pkt_queue_max
);
7250 /* BGP default autoshutdown neighbors */
7251 if (bgp
->autoshutdown
)
7252 vty_out(vty
, " bgp default shutdown\n");
7254 /* BGP client-to-client reflection. */
7255 if (bgp_flag_check(bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7256 vty_out(vty
, " no bgp client-to-client reflection\n");
7258 /* BGP cluster ID. */
7259 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7260 vty_out(vty
, " bgp cluster-id %s\n",
7261 inet_ntoa(bgp
->cluster_id
));
7263 /* Disable ebgp connected nexthop check */
7264 if (bgp_flag_check(bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7266 " bgp disable-ebgp-connected-route-check\n");
7268 /* Confederation identifier*/
7269 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7270 vty_out(vty
, " bgp confederation identifier %i\n",
7273 /* Confederation peer */
7274 if (bgp
->confed_peers_cnt
> 0) {
7277 vty_out(vty
, " bgp confederation peers");
7279 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7280 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7285 /* BGP enforce-first-as. */
7286 if (bgp_flag_check(bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
7287 vty_out(vty
, " bgp enforce-first-as\n");
7289 /* BGP deterministic-med. */
7290 if (!!bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7291 != DFLT_BGP_DETERMINISTIC_MED
)
7292 vty_out(vty
, " %sbgp deterministic-med\n",
7293 bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7297 /* BGP update-delay. */
7298 bgp_config_write_update_delay(vty
, bgp
);
7300 if (bgp
->v_maxmed_onstartup
7301 != BGP_MAXMED_ONSTARTUP_UNCONFIGURED
) {
7302 vty_out(vty
, " bgp max-med on-startup %u",
7303 bgp
->v_maxmed_onstartup
);
7304 if (bgp
->maxmed_onstartup_value
7305 != BGP_MAXMED_VALUE_DEFAULT
)
7307 bgp
->maxmed_onstartup_value
);
7310 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
) {
7311 vty_out(vty
, " bgp max-med administrative");
7312 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7313 vty_out(vty
, " %u", bgp
->maxmed_admin_value
);
7318 bgp_config_write_wpkt_quanta(vty
, bgp
);
7320 bgp_config_write_rpkt_quanta(vty
, bgp
);
7323 bgp_config_write_coalesce_time(vty
, bgp
);
7325 /* BGP graceful-restart. */
7326 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7328 " bgp graceful-restart stalepath-time %u\n",
7329 bgp
->stalepath_time
);
7330 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7331 vty_out(vty
, " bgp graceful-restart restart-time %u\n",
7333 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7334 vty_out(vty
, " bgp graceful-restart\n");
7336 /* BGP graceful-shutdown */
7337 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
))
7338 vty_out(vty
, " bgp graceful-shutdown\n");
7340 /* BGP graceful-restart Preserve State F bit. */
7341 if (bgp_flag_check(bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
7343 " bgp graceful-restart preserve-fw-state\n");
7345 /* BGP bestpath method. */
7346 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_IGNORE
))
7347 vty_out(vty
, " bgp bestpath as-path ignore\n");
7348 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_CONFED
))
7349 vty_out(vty
, " bgp bestpath as-path confed\n");
7351 if (bgp_flag_check(bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
)) {
7352 if (bgp_flag_check(bgp
,
7353 BGP_FLAG_MULTIPATH_RELAX_AS_SET
)) {
7355 " bgp bestpath as-path multipath-relax as-set\n");
7358 " bgp bestpath as-path multipath-relax\n");
7362 if (bgp_flag_check(bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7364 " bgp route-reflector allow-outbound-policy\n");
7366 if (bgp_flag_check(bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7367 vty_out(vty
, " bgp bestpath compare-routerid\n");
7368 if (bgp_flag_check(bgp
, BGP_FLAG_MED_CONFED
)
7369 || bgp_flag_check(bgp
, BGP_FLAG_MED_MISSING_AS_WORST
)) {
7370 vty_out(vty
, " bgp bestpath med");
7371 if (bgp_flag_check(bgp
, BGP_FLAG_MED_CONFED
))
7372 vty_out(vty
, " confed");
7373 if (bgp_flag_check(bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7374 vty_out(vty
, " missing-as-worst");
7378 /* BGP network import check. */
7379 if (!!bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
7380 != DFLT_BGP_IMPORT_CHECK
)
7381 vty_out(vty
, " %sbgp network import-check\n",
7382 bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
)
7386 /* BGP flag dampening. */
7387 if (CHECK_FLAG(bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7388 BGP_CONFIG_DAMPENING
))
7389 bgp_config_write_damp(vty
);
7391 /* BGP timers configuration. */
7392 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7393 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7394 vty_out(vty
, " timers bgp %u %u\n",
7395 bgp
->default_keepalive
, bgp
->default_holdtime
);
7398 for (ALL_LIST_ELEMENTS(bgp
->group
, node
, nnode
, group
)) {
7399 bgp_config_write_peer_global(vty
, bgp
, group
->conf
);
7402 /* Normal neighbor configuration. */
7403 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
)) {
7404 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7405 bgp_config_write_peer_global(vty
, bgp
, peer
);
7408 /* listen range and limit for dynamic BGP neighbors */
7409 bgp_config_write_listen(vty
, bgp
);
7411 /* No auto-summary */
7412 if (bgp_option_check(BGP_OPT_CONFIG_CISCO
))
7413 vty_out(vty
, " no auto-summary\n");
7415 /* IPv4 unicast configuration. */
7416 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7418 /* IPv4 multicast configuration. */
7419 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7421 /* IPv4 labeled-unicast configuration. */
7422 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_LABELED_UNICAST
);
7424 /* IPv4 VPN configuration. */
7425 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7427 /* ENCAPv4 configuration. */
7428 bgp_config_write_family(vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7430 /* IPv6 unicast configuration. */
7431 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7433 /* IPv6 multicast configuration. */
7434 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7436 /* IPv6 labeled-unicast configuration. */
7437 bgp_config_write_family(vty
, bgp
, AFI_IP6
,
7438 SAFI_LABELED_UNICAST
);
7440 /* IPv6 VPN configuration. */
7441 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7443 /* ENCAPv6 configuration. */
7444 bgp_config_write_family(vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7446 /* EVPN configuration. */
7447 bgp_config_write_family(vty
, bgp
, AFI_L2VPN
, SAFI_EVPN
);
7450 bgp_rfapi_cfg_write(vty
, bgp
);
7453 vty_out(vty
, "!\n");
7458 void bgp_master_init(struct thread_master
*master
)
7462 memset(&bgp_master
, 0, sizeof(struct bgp_master
));
7465 bm
->bgp
= list_new();
7466 bm
->listen_sockets
= list_new();
7467 bm
->port
= BGP_PORT_DEFAULT
;
7468 bm
->master
= master
;
7469 bm
->start_time
= bgp_clock();
7470 bm
->t_rmap_update
= NULL
;
7471 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7473 bgp_process_queue_init();
7475 /* init the rd id space.
7476 assign 0th index in the bitfield,
7477 so that we start with id 1
7479 bf_init(bm
->rd_idspace
, UINT16_MAX
);
7480 bf_assign_zero_index(bm
->rd_idspace
);
7482 /* Enable multiple instances by default. */
7483 bgp_option_set(BGP_OPT_MULTIPLE_INSTANCE
);
7485 QOBJ_REG(bm
, bgp_master
);
7489 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7490 * instance delete (non-default only) or BGP exit.
7492 static void bgp_if_finish(struct bgp
*bgp
)
7494 struct vrf
*vrf
= vrf_lookup_by_id(bgp
->vrf_id
);
7495 struct interface
*ifp
;
7497 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
|| !vrf
)
7500 FOR_ALL_INTERFACES (vrf
, ifp
) {
7501 struct listnode
*c_node
, *c_nnode
;
7502 struct connected
*c
;
7504 for (ALL_LIST_ELEMENTS(ifp
->connected
, c_node
, c_nnode
, c
))
7505 bgp_connected_delete(bgp
, c
);
7509 extern void bgp_snmp_init(void);
7511 static void bgp_viewvrf_autocomplete(vector comps
, struct cmd_token
*token
)
7513 struct vrf
*vrf
= NULL
;
7514 struct listnode
*next
;
7517 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
7518 if (vrf
->vrf_id
!= VRF_DEFAULT
)
7519 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
7522 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, next
, bgp
)) {
7523 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
7526 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, bgp
->name
));
7530 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
7531 {.tokenname
= "VIEWVRFNAME", .completions
= bgp_viewvrf_autocomplete
},
7532 {.completions
= NULL
},
7535 static void bgp_pthreads_init()
7539 struct frr_pthread_attr io
= {
7541 .start
= frr_pthread_attr_default
.start
,
7542 .stop
= frr_pthread_attr_default
.stop
,
7544 struct frr_pthread_attr ka
= {
7545 .id
= PTHREAD_KEEPALIVES
,
7546 .start
= bgp_keepalives_start
,
7547 .stop
= bgp_keepalives_stop
,
7549 frr_pthread_new(&io
, "BGP I/O thread");
7550 frr_pthread_new(&ka
, "BGP Keepalives thread");
7553 void bgp_pthreads_run()
7555 struct frr_pthread
*io
= frr_pthread_get(PTHREAD_IO
);
7556 struct frr_pthread
*ka
= frr_pthread_get(PTHREAD_KEEPALIVES
);
7558 frr_pthread_run(io
, NULL
);
7559 frr_pthread_run(ka
, NULL
);
7561 /* Wait until threads are ready. */
7562 frr_pthread_wait_running(io
);
7563 frr_pthread_wait_running(ka
);
7566 void bgp_pthreads_finish()
7568 frr_pthread_stop_all();
7569 frr_pthread_finish();
7575 /* allocates some vital data structures used by peer commands in
7578 /* pre-init pthreads */
7579 bgp_pthreads_init();
7582 bgp_zebra_init(bm
->master
);
7585 vnc_zebra_init(bm
->master
);
7588 /* BGP VTY commands installation. */
7596 bgp_route_map_init();
7597 bgp_scan_vty_init();
7602 bgp_ethernetvpn_init();
7604 /* Access list initialize. */
7606 access_list_add_hook(peer_distribute_update
);
7607 access_list_delete_hook(peer_distribute_update
);
7609 /* Filter list initialize. */
7611 as_list_add_hook(peer_aslist_add
);
7612 as_list_delete_hook(peer_aslist_del
);
7614 /* Prefix list initialize.*/
7616 prefix_list_add_hook(peer_prefix_list_update
);
7617 prefix_list_delete_hook(peer_prefix_list_update
);
7619 /* Community list initialize. */
7620 bgp_clist
= community_list_init();
7625 cmd_variable_handler_register(bgp_viewvrf_var_handlers
);
7628 void bgp_terminate(void)
7632 struct listnode
*node
, *nnode
;
7633 struct listnode
*mnode
, *mnnode
;
7637 /* Close the listener sockets first as this prevents peers from
7639 * to reconnect on receiving the peer unconfig message. In the presence
7640 * of a large number of peers this will ensure that no peer is left with
7641 * a dangling connection
7643 /* reverse bgp_master_init */
7646 if (bm
->listen_sockets
)
7647 list_delete_and_null(&bm
->listen_sockets
);
7649 for (ALL_LIST_ELEMENTS(bm
->bgp
, mnode
, mnnode
, bgp
))
7650 for (ALL_LIST_ELEMENTS(bgp
->peer
, node
, nnode
, peer
))
7651 if (peer
->status
== Established
7652 || peer
->status
== OpenSent
7653 || peer
->status
== OpenConfirm
)
7654 bgp_notify_send(peer
, BGP_NOTIFY_CEASE
,
7655 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7657 if (bm
->process_main_queue
)
7658 work_queue_free_and_null(&bm
->process_main_queue
);
7660 if (bm
->t_rmap_update
)
7661 BGP_TIMER_OFF(bm
->t_rmap_update
);