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
28 #include "sockunion.h"
37 #include "workqueue.h"
46 #include "bgpd/bgpd.h"
47 #include "bgpd/bgp_table.h"
48 #include "bgpd/bgp_aspath.h"
49 #include "bgpd/bgp_route.h"
50 #include "bgpd/bgp_dump.h"
51 #include "bgpd/bgp_debug.h"
52 #include "bgpd/bgp_community.h"
53 #include "bgpd/bgp_attr.h"
54 #include "bgpd/bgp_regex.h"
55 #include "bgpd/bgp_clist.h"
56 #include "bgpd/bgp_fsm.h"
57 #include "bgpd/bgp_packet.h"
58 #include "bgpd/bgp_zebra.h"
59 #include "bgpd/bgp_open.h"
60 #include "bgpd/bgp_filter.h"
61 #include "bgpd/bgp_nexthop.h"
62 #include "bgpd/bgp_damp.h"
63 #include "bgpd/bgp_mplsvpn.h"
65 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
66 #include "bgpd/rfapi/rfapi_backend.h"
68 #include "bgpd/bgp_evpn.h"
69 #include "bgpd/bgp_advertise.h"
70 #include "bgpd/bgp_network.h"
71 #include "bgpd/bgp_vty.h"
72 #include "bgpd/bgp_mpath.h"
73 #include "bgpd/bgp_nht.h"
74 #include "bgpd/bgp_updgrp.h"
75 #include "bgpd/bgp_bfd.h"
76 #include "bgpd/bgp_memory.h"
77 #include "bgpd/bgp_evpn_vty.h"
80 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
81 DEFINE_QOBJ_TYPE(bgp_master
)
83 DEFINE_QOBJ_TYPE(peer
)
85 /* BGP process wide configuration. */
86 static struct bgp_master bgp_master
;
88 /* BGP process wide configuration pointer to export. */
89 struct bgp_master
*bm
;
91 /* BGP community-list. */
92 struct community_list_handler
*bgp_clist
;
94 unsigned int multipath_num
= MULTIPATH_NUM
;
96 static void bgp_if_finish (struct bgp
*bgp
);
98 extern struct zclient
*zclient
;
101 bgp_session_reset(struct peer
*peer
)
103 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
104 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
105 peer_delete(peer
->doppelganger
);
107 BGP_EVENT_ADD (peer
, BGP_Stop
);
111 * During session reset, we may delete the doppelganger peer, which would
112 * be the next node to the current node. If the session reset was invoked
113 * during walk of peer list, we would end up accessing the freed next
114 * node. This function moves the next node along.
117 bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
122 n
= (nnode
) ? *nnode
: NULL
;
123 npeer
= (n
) ? listgetdata(n
) : NULL
;
125 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
126 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
128 if (peer
->doppelganger
== npeer
)
129 /* nnode and *nnode are confirmed to be non-NULL here */
130 *nnode
= (*nnode
)->next
;
131 peer_delete(peer
->doppelganger
);
134 BGP_EVENT_ADD (peer
, BGP_Stop
);
137 /* BGP global flag manipulation. */
139 bgp_option_set (int flag
)
144 case BGP_OPT_MULTIPLE_INSTANCE
:
145 case BGP_OPT_CONFIG_CISCO
:
146 case BGP_OPT_NO_LISTEN
:
147 SET_FLAG (bm
->options
, flag
);
150 return BGP_ERR_INVALID_FLAG
;
156 bgp_option_unset (int flag
)
160 case BGP_OPT_MULTIPLE_INSTANCE
:
161 if (listcount (bm
->bgp
) > 1)
162 return BGP_ERR_MULTIPLE_INSTANCE_USED
;
165 case BGP_OPT_CONFIG_CISCO
:
166 UNSET_FLAG (bm
->options
, flag
);
169 return BGP_ERR_INVALID_FLAG
;
175 bgp_option_check (int flag
)
177 return CHECK_FLAG (bm
->options
, flag
);
180 /* BGP flag manipulation. */
182 bgp_flag_set (struct bgp
*bgp
, int flag
)
184 SET_FLAG (bgp
->flags
, flag
);
189 bgp_flag_unset (struct bgp
*bgp
, int flag
)
191 UNSET_FLAG (bgp
->flags
, flag
);
196 bgp_flag_check (struct bgp
*bgp
, int flag
)
198 return CHECK_FLAG (bgp
->flags
, flag
);
201 /* Internal function to set BGP structure configureation flag. */
203 bgp_config_set (struct bgp
*bgp
, int config
)
205 SET_FLAG (bgp
->config
, config
);
209 bgp_config_unset (struct bgp
*bgp
, int config
)
211 UNSET_FLAG (bgp
->config
, config
);
215 bgp_config_check (struct bgp
*bgp
, int config
)
217 return CHECK_FLAG (bgp
->config
, config
);
220 /* Set BGP router identifier. */
222 bgp_router_id_set (struct bgp
*bgp
, const struct in_addr
*id
)
225 struct listnode
*node
, *nnode
;
227 if (IPV4_ADDR_SAME (&bgp
->router_id
, id
))
230 IPV4_ADDR_COPY (&bgp
->router_id
, id
);
232 /* Set all peer's local identifier with this value. */
233 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
235 IPV4_ADDR_COPY (&peer
->local_id
, id
);
237 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
239 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
240 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
241 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
248 bgp_router_id_zebra_bump (vrf_id_t vrf_id
, const struct prefix
*router_id
)
250 struct listnode
*node
, *nnode
;
253 if (vrf_id
== VRF_DEFAULT
)
255 /* Router-id change for default VRF has to also update all views. */
256 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
258 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
261 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
262 if (!bgp
->router_id_static
.s_addr
)
263 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
268 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
271 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
273 if (!bgp
->router_id_static
.s_addr
)
274 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
280 bgp_router_id_static_set (struct bgp
*bgp
, struct in_addr id
)
282 bgp
->router_id_static
= id
;
283 bgp_router_id_set (bgp
, id
.s_addr
? &id
: &bgp
->router_id_zebra
);
287 /* BGP's cluster-id control. */
289 bgp_cluster_id_set (struct bgp
*bgp
, struct in_addr
*cluster_id
)
292 struct listnode
*node
, *nnode
;
294 if (bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
)
295 && IPV4_ADDR_SAME (&bgp
->cluster_id
, cluster_id
))
298 IPV4_ADDR_COPY (&bgp
->cluster_id
, cluster_id
);
299 bgp_config_set (bgp
, BGP_CONFIG_CLUSTER_ID
);
301 /* Clear all IBGP peer. */
302 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
304 if (peer
->sort
!= BGP_PEER_IBGP
)
307 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
309 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
310 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
311 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
318 bgp_cluster_id_unset (struct bgp
*bgp
)
321 struct listnode
*node
, *nnode
;
323 if (! bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
))
326 bgp
->cluster_id
.s_addr
= 0;
327 bgp_config_unset (bgp
, BGP_CONFIG_CLUSTER_ID
);
329 /* Clear all IBGP peer. */
330 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
332 if (peer
->sort
!= BGP_PEER_IBGP
)
335 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
337 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
338 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
339 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
345 /* time_t value that is monotonicly increasing
346 * and uneffected by adjustments to system clock
348 time_t bgp_clock (void)
356 /* BGP timer configuration. */
358 bgp_timers_set (struct bgp
*bgp
, u_int32_t keepalive
, u_int32_t holdtime
)
360 bgp
->default_keepalive
= (keepalive
< holdtime
/ 3
361 ? keepalive
: holdtime
/ 3);
362 bgp
->default_holdtime
= holdtime
;
368 bgp_timers_unset (struct bgp
*bgp
)
370 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
371 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
376 /* BGP confederation configuration. */
378 bgp_confederation_id_set (struct bgp
*bgp
, as_t as
)
381 struct listnode
*node
, *nnode
;
385 return BGP_ERR_INVALID_AS
;
387 /* Remember - were we doing confederation before? */
388 already_confed
= bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
);
390 bgp_config_set (bgp
, BGP_CONFIG_CONFEDERATION
);
392 /* If we were doing confederation already, this is just an external
393 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
394 were not doing confederation before, reset all EBGP sessions. */
395 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
397 /* We're looking for peers who's AS is not local or part of our
401 if (peer_sort (peer
) == BGP_PEER_EBGP
)
404 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
406 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
407 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
408 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
411 bgp_session_reset_safe(peer
, &nnode
);
416 /* Not doign confederation before, so reset every non-local
418 if (peer_sort (peer
) != BGP_PEER_IBGP
)
420 /* Reset the local_as to be our EBGP one */
421 if (peer_sort (peer
) == BGP_PEER_EBGP
)
423 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
425 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
426 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
427 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
430 bgp_session_reset_safe(peer
, &nnode
);
438 bgp_confederation_id_unset (struct bgp
*bgp
)
441 struct listnode
*node
, *nnode
;
444 bgp_config_unset (bgp
, BGP_CONFIG_CONFEDERATION
);
446 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
448 /* We're looking for peers who's AS is not local */
449 if (peer_sort (peer
) != BGP_PEER_IBGP
)
451 peer
->local_as
= bgp
->as
;
452 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
454 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
455 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
456 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
460 bgp_session_reset_safe(peer
, &nnode
);
466 /* Is an AS part of the confed or not? */
468 bgp_confederation_peers_check (struct bgp
*bgp
, as_t as
)
475 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
476 if (bgp
->confed_peers
[i
] == as
)
482 /* Add an AS to the confederation set. */
484 bgp_confederation_peers_add (struct bgp
*bgp
, as_t as
)
487 struct listnode
*node
, *nnode
;
490 return BGP_ERR_INVALID_BGP
;
493 return BGP_ERR_INVALID_AS
;
495 if (bgp_confederation_peers_check (bgp
, as
))
498 if (bgp
->confed_peers
)
499 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
501 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
503 bgp
->confed_peers
= XMALLOC (MTYPE_BGP_CONFED_LIST
,
504 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
506 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
507 bgp
->confed_peers_cnt
++;
509 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
511 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
515 peer
->local_as
= bgp
->as
;
516 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
518 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
519 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
520 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
523 bgp_session_reset_safe(peer
, &nnode
);
530 /* Delete an AS from the confederation set. */
532 bgp_confederation_peers_remove (struct bgp
*bgp
, as_t as
)
537 struct listnode
*node
, *nnode
;
542 if (! bgp_confederation_peers_check (bgp
, as
))
545 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
546 if (bgp
->confed_peers
[i
] == as
)
547 for(j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
548 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
550 bgp
->confed_peers_cnt
--;
552 if (bgp
->confed_peers_cnt
== 0)
554 if (bgp
->confed_peers
)
555 XFREE (MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
556 bgp
->confed_peers
= NULL
;
559 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
561 bgp
->confed_peers_cnt
* sizeof (as_t
));
563 /* Now reset any peer who's remote AS has just been removed from the
565 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
567 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
571 peer
->local_as
= bgp
->confed_id
;
572 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
574 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
575 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
576 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
579 bgp_session_reset_safe(peer
, &nnode
);
587 /* Local preference configuration. */
589 bgp_default_local_preference_set (struct bgp
*bgp
, u_int32_t local_pref
)
594 bgp
->default_local_pref
= local_pref
;
600 bgp_default_local_preference_unset (struct bgp
*bgp
)
605 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
610 /* Local preference configuration. */
612 bgp_default_subgroup_pkt_queue_max_set (struct bgp
*bgp
, u_int32_t queue_size
)
617 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
623 bgp_default_subgroup_pkt_queue_max_unset (struct bgp
*bgp
)
627 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
632 /* Listen limit configuration. */
634 bgp_listen_limit_set (struct bgp
*bgp
, int listen_limit
)
639 bgp
->dynamic_neighbors_limit
= listen_limit
;
645 bgp_listen_limit_unset (struct bgp
*bgp
)
650 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
656 bgp_map_afi_safi_iana2int (iana_afi_t pkt_afi
, safi_t pkt_safi
,
657 afi_t
*afi
, safi_t
*safi
)
659 /* Map from IANA values to internal values, return error if
660 * values are unrecognized.
662 *afi
= afi_iana2int (pkt_afi
);
663 *safi
= safi_iana2int (pkt_safi
);
664 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
671 bgp_map_afi_safi_int2iana (afi_t afi
, safi_t safi
,
672 iana_afi_t
*pkt_afi
, safi_t
*pkt_safi
)
674 /* Map from internal values to IANA values, return error if
675 * internal values are bad (unexpected).
677 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
679 *pkt_afi
= afi_int2iana (afi
);
680 *pkt_safi
= safi_int2iana (safi
);
685 peer_af_create (struct peer
*peer
, afi_t afi
, safi_t safi
)
693 afid
= afindex(afi
, safi
);
694 if (afid
>= BGP_AF_MAX
)
697 assert(peer
->peer_af_array
[afid
] == NULL
);
699 /* Allocate new peer af */
700 af
= XCALLOC (MTYPE_BGP_PEER_AF
, sizeof (struct peer_af
));
704 zlog_err("Could not create af structure for peer %s", peer
->host
);
708 peer
->peer_af_array
[afid
] = af
;
718 peer_af_find (struct peer
*peer
, afi_t afi
, safi_t safi
)
725 afid
= afindex(afi
, safi
);
726 if (afid
>= BGP_AF_MAX
)
729 return peer
->peer_af_array
[afid
];
733 peer_af_delete (struct peer
*peer
, afi_t afi
, safi_t safi
)
741 afid
= afindex(afi
, safi
);
742 if (afid
>= BGP_AF_MAX
)
745 af
= peer
->peer_af_array
[afid
];
749 bgp_stop_announce_route_timer (af
);
753 if (BGP_DEBUG (update_groups
, UPDATE_GROUPS
))
754 zlog_debug ("u%" PRIu64
":s%" PRIu64
" remove peer %s",
755 af
->subgroup
->update_group
->id
, af
->subgroup
->id
, peer
->host
);
758 update_subgroup_remove_peer (af
->subgroup
, af
);
760 peer
->peer_af_array
[afid
] = NULL
;
761 XFREE(MTYPE_BGP_PEER_AF
, af
);
765 /* Peer comparison function for sorting. */
767 peer_cmp (struct peer
*p1
, struct peer
*p2
)
769 if (p1
->group
&& !p2
->group
)
772 if (!p1
->group
&& p2
->group
)
775 if (p1
->group
== p2
->group
)
777 if (p1
->conf_if
&& !p2
->conf_if
)
780 if (!p1
->conf_if
&& p2
->conf_if
)
783 if (p1
->conf_if
&& p2
->conf_if
)
784 return if_cmp_name_func (p1
->conf_if
, p2
->conf_if
);
787 return strcmp (p1
->group
->name
, p2
->group
->name
);
789 return sockunion_cmp (&p1
->su
, &p2
->su
);
793 peer_hash_key_make(void *p
)
795 struct peer
*peer
= p
;
796 return sockunion_hash(&peer
->su
);
800 peer_hash_cmp (const void *p1
, const void *p2
)
802 const struct peer
*peer1
= p1
;
803 const struct peer
*peer2
= p2
;
804 return (sockunion_same (&peer1
->su
, &peer2
->su
) &&
805 CHECK_FLAG (peer1
->flags
, PEER_FLAG_CONFIG_NODE
) == CHECK_FLAG (peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
809 peer_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
811 return CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
);
814 /* Return true if flag is set for the peer but not the peer-group */
816 peergroup_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
818 struct peer
*g_peer
= NULL
;
820 if (peer_af_flag_check (peer
, afi
, safi
, flag
))
822 if (peer_group_active (peer
))
824 g_peer
= peer
->group
->conf
;
826 /* If this flag is not set for the peer's peer-group then return true */
827 if (!peer_af_flag_check (g_peer
, afi
, safi
, flag
))
833 /* peer is not in a peer-group but the flag is set to return true */
843 /* Reset all address family specific configuration. */
845 peer_af_flag_reset (struct peer
*peer
, afi_t afi
, safi_t safi
)
848 struct bgp_filter
*filter
;
849 char orf_name
[BUFSIZ
];
851 filter
= &peer
->filter
[afi
][safi
];
853 /* Clear neighbor filter and route-map */
854 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
856 if (filter
->dlist
[i
].name
)
858 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
859 filter
->dlist
[i
].name
= NULL
;
861 if (filter
->plist
[i
].name
)
863 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
864 filter
->plist
[i
].name
= NULL
;
866 if (filter
->aslist
[i
].name
)
868 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
869 filter
->aslist
[i
].name
= NULL
;
872 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
874 if (filter
->map
[i
].name
)
876 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
877 filter
->map
[i
].name
= NULL
;
881 /* Clear unsuppress map. */
882 if (filter
->usmap
.name
)
883 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
884 filter
->usmap
.name
= NULL
;
885 filter
->usmap
.map
= NULL
;
887 /* Clear neighbor's all address family flags. */
888 peer
->af_flags
[afi
][safi
] = 0;
890 /* Clear neighbor's all address family sflags. */
891 peer
->af_sflags
[afi
][safi
] = 0;
893 /* Clear neighbor's all address family capabilities. */
894 peer
->af_cap
[afi
][safi
] = 0;
897 peer
->orf_plist
[afi
][safi
] = NULL
;
898 sprintf (orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
899 prefix_bgp_orf_remove_all (afi
, orf_name
);
901 /* Set default neighbor send-community. */
902 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
904 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
905 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
906 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_LARGE_COMMUNITY
);
909 /* Clear neighbor default_originate_rmap */
910 if (peer
->default_rmap
[afi
][safi
].name
)
911 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
912 peer
->default_rmap
[afi
][safi
].name
= NULL
;
913 peer
->default_rmap
[afi
][safi
].map
= NULL
;
915 /* Clear neighbor maximum-prefix */
916 peer
->pmax
[afi
][safi
] = 0;
917 peer
->pmax_threshold
[afi
][safi
] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT
;
920 /* peer global config reset */
922 peer_global_config_reset (struct peer
*peer
)
927 peer
->change_local_as
= 0;
928 peer
->ttl
= (peer_sort (peer
) == BGP_PEER_IBGP
? MAXTTL
: 1);
929 if (peer
->update_source
)
931 sockunion_free (peer
->update_source
);
932 peer
->update_source
= NULL
;
936 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
937 peer
->update_if
= NULL
;
940 if (peer_sort (peer
) == BGP_PEER_IBGP
)
941 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
943 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
945 /* This is a per-peer specific flag and so we must preserve it */
946 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
951 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
957 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
959 /* Reset some other configs back to defaults. */
960 peer
->v_start
= BGP_INIT_START_TIMER
;
961 peer
->password
= NULL
;
962 peer
->local_id
= peer
->bgp
->router_id
;
963 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
964 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
966 bfd_info_free(&(peer
->bfd_info
));
968 /* Set back the CONFIG_NODE flag. */
969 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
972 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
973 static bgp_peer_sort_t
974 peer_calc_sort (struct peer
*peer
)
981 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
983 if (peer
->as_type
== AS_INTERNAL
)
984 return BGP_PEER_IBGP
;
986 else if (peer
->as_type
== AS_EXTERNAL
)
987 return BGP_PEER_EBGP
;
989 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
)
990 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
995 peer1
= listnode_head (peer
->group
->peer
);
1000 return BGP_PEER_INTERNAL
;
1004 if (bgp
&& CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1006 if (peer
->local_as
== 0)
1007 return BGP_PEER_INTERNAL
;
1009 if (peer
->local_as
== peer
->as
)
1011 if (bgp
->as
== bgp
->confed_id
)
1013 if (peer
->local_as
== bgp
->as
)
1014 return BGP_PEER_IBGP
;
1016 return BGP_PEER_EBGP
;
1020 if (peer
->local_as
== bgp
->confed_id
)
1021 return BGP_PEER_EBGP
;
1023 return BGP_PEER_IBGP
;
1027 if (bgp_confederation_peers_check (bgp
, peer
->as
))
1028 return BGP_PEER_CONFED
;
1030 return BGP_PEER_EBGP
;
1034 if (peer
->as_type
!= AS_SPECIFIED
)
1035 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1037 return (peer
->local_as
== 0
1038 ? BGP_PEER_INTERNAL
: peer
->local_as
== peer
->as
1039 ? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1043 /* Calculate and cache the peer "sort" */
1045 peer_sort (struct peer
*peer
)
1047 peer
->sort
= peer_calc_sort (peer
);
1052 peer_free (struct peer
*peer
)
1054 assert (peer
->status
== Deleted
);
1058 /* this /ought/ to have been done already through bgp_stop earlier,
1059 * but just to be sure..
1061 bgp_timer_set (peer
);
1062 BGP_READ_OFF (peer
->t_read
);
1063 BGP_WRITE_OFF (peer
->t_write
);
1064 BGP_EVENT_FLUSH (peer
);
1066 /* Free connected nexthop, if present */
1067 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
) &&
1068 !peer_dynamic_neighbor (peer
))
1069 bgp_delete_connected_nexthop (family2afi(peer
->su
.sa
.sa_family
), peer
);
1071 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1075 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
1079 /* Free allocated host character. */
1082 XFREE (MTYPE_BGP_PEER_HOST
, peer
->host
);
1086 if (peer
->domainname
)
1088 XFREE (MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1089 peer
->domainname
= NULL
;
1094 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1095 peer
->ifname
= NULL
;
1098 /* Update source configuration. */
1099 if (peer
->update_source
)
1101 sockunion_free (peer
->update_source
);
1102 peer
->update_source
= NULL
;
1105 if (peer
->update_if
)
1107 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1108 peer
->update_if
= NULL
;
1111 if (peer
->notify
.data
)
1112 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1113 memset (&peer
->notify
, 0, sizeof (struct bgp_notify
));
1115 if (peer
->clear_node_queue
)
1117 work_queue_free(peer
->clear_node_queue
);
1118 peer
->clear_node_queue
= NULL
;
1121 bgp_sync_delete (peer
);
1125 XFREE (MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1126 peer
->conf_if
= NULL
;
1129 bfd_info_free(&(peer
->bfd_info
));
1131 bgp_unlock(peer
->bgp
);
1133 memset (peer
, 0, sizeof (struct peer
));
1135 XFREE (MTYPE_BGP_PEER
, peer
);
1138 /* increase reference count on a struct peer */
1140 peer_lock_with_caller (const char *name
, struct peer
*peer
)
1142 assert (peer
&& (peer
->lock
>= 0));
1145 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1153 /* decrease reference count on a struct peer
1154 * struct peer is freed and NULL returned if last reference
1157 peer_unlock_with_caller (const char *name
, struct peer
*peer
)
1159 assert (peer
&& (peer
->lock
> 0));
1162 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1167 if (peer
->lock
== 0)
1176 /* Allocate new peer object, implicitely locked. */
1178 peer_new (struct bgp
*bgp
)
1185 /* bgp argument is absolutely required */
1190 /* Allocate new peer. */
1191 peer
= XCALLOC (MTYPE_BGP_PEER
, sizeof (struct peer
));
1193 /* Set default value. */
1195 peer
->v_start
= BGP_INIT_START_TIMER
;
1196 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1197 peer
->status
= Idle
;
1198 peer
->ostatus
= Idle
;
1199 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1201 peer
= peer_lock (peer
); /* initial reference */
1203 peer
->password
= NULL
;
1205 /* Set default flags. */
1206 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1207 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1209 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
1211 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1212 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
1213 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_LARGE_COMMUNITY
);
1215 peer
->orf_plist
[afi
][safi
] = NULL
;
1217 SET_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1219 /* Create buffers. */
1220 peer
->ibuf
= stream_new (BGP_MAX_PACKET_SIZE
);
1221 peer
->obuf
= stream_fifo_new ();
1223 /* We use a larger buffer for peer->work in the event that:
1224 * - We RX a BGP_UPDATE where the attributes alone are just
1225 * under BGP_MAX_PACKET_SIZE
1226 * - The user configures an outbound route-map that does many as-path
1227 * prepends or adds many communities. At most they can have CMD_ARGC_MAX
1228 * args in a route-map so there is a finite limit on how large they can
1229 * make the attributes.
1231 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid bounds
1232 * checking for every single attribute as we construct an UPDATE.
1234 peer
->work
= stream_new (BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1235 peer
->scratch
= stream_new (BGP_MAX_PACKET_SIZE
);
1238 bgp_sync_init (peer
);
1240 /* Get service port number. */
1241 sp
= getservbyname ("bgp", "tcp");
1242 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs (sp
->s_port
);
1244 QOBJ_REG (peer
, peer
);
1249 * This function is invoked when a duplicate peer structure associated with
1250 * a neighbor is being deleted. If this about-to-be-deleted structure is
1251 * the one with all the config, then we have to copy over the info.
1254 peer_xfer_config (struct peer
*peer_dst
, struct peer
*peer_src
)
1256 struct peer_af
*paf
;
1264 /* The following function is used by both peer group config copy to
1265 * individual peer and when we transfer config
1267 if (peer_src
->change_local_as
)
1268 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1270 /* peer flags apply */
1271 peer_dst
->flags
= peer_src
->flags
;
1272 peer_dst
->cap
= peer_src
->cap
;
1273 peer_dst
->config
= peer_src
->config
;
1275 peer_dst
->local_as
= peer_src
->local_as
;
1276 peer_dst
->ifindex
= peer_src
->ifindex
;
1277 peer_dst
->port
= peer_src
->port
;
1278 peer_sort(peer_dst
);
1279 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1282 peer_dst
->holdtime
= peer_src
->holdtime
;
1283 peer_dst
->keepalive
= peer_src
->keepalive
;
1284 peer_dst
->connect
= peer_src
->connect
;
1285 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1286 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1287 peer_dst
->routeadv
= peer_src
->routeadv
;
1288 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1290 /* password apply */
1291 if (peer_src
->password
&& !peer_dst
->password
)
1292 peer_dst
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, peer_src
->password
);
1294 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1295 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1297 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1298 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1299 peer_dst
->allowas_in
[afi
][safi
] = peer_src
->allowas_in
[afi
][safi
];
1300 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1303 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++)
1305 paf
= peer_src
->peer_af_array
[afidx
];
1307 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1310 /* update-source apply */
1311 if (peer_src
->update_source
)
1313 if (peer_dst
->update_source
)
1314 sockunion_free (peer_dst
->update_source
);
1315 if (peer_dst
->update_if
)
1317 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1318 peer_dst
->update_if
= NULL
;
1320 peer_dst
->update_source
= sockunion_dup (peer_src
->update_source
);
1322 else if (peer_src
->update_if
)
1324 if (peer_dst
->update_if
)
1325 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1326 if (peer_dst
->update_source
)
1328 sockunion_free (peer_dst
->update_source
);
1329 peer_dst
->update_source
= NULL
;
1331 peer_dst
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1334 if (peer_src
->ifname
)
1336 if (peer_dst
->ifname
)
1337 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1339 peer_dst
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1344 bgp_peer_conf_if_to_su_update_v4 (struct peer
*peer
, struct interface
*ifp
)
1346 struct connected
*ifc
;
1349 struct listnode
*node
;
1351 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1352 * IPv4 address of the other end.
1354 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
))
1356 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
))
1358 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1359 if (p
.prefixlen
== 30)
1361 peer
->su
.sa
.sa_family
= AF_INET
;
1362 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1364 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1365 else if (addr
% 4 == 2)
1366 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1367 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1368 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1369 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1372 else if (p
.prefixlen
== 31)
1374 peer
->su
.sa
.sa_family
= AF_INET
;
1375 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1377 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1379 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1380 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1381 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1382 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1386 if (bgp_debug_neighbor_events(peer
))
1387 zlog_debug("%s: IPv4 interface address is not /30 or /31, v4 session not started",
1396 bgp_peer_conf_if_to_su_update_v6 (struct peer
*peer
, struct interface
*ifp
)
1398 struct nbr_connected
*ifc_nbr
;
1400 /* Have we learnt the peer's IPv6 link-local address? */
1401 if (ifp
->nbr_connected
&&
1402 (ifc_nbr
= listnode_head(ifp
->nbr_connected
)))
1404 peer
->su
.sa
.sa_family
= AF_INET6
;
1405 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1406 sizeof (struct in6_addr
));
1408 peer
->su
.sin6
.sin6_len
= sizeof (struct sockaddr_in6
);
1410 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1418 * Set or reset the peer address socketunion structure based on the
1419 * learnt/derived peer address. If the address has changed, update the
1420 * password on the listen socket, if needed.
1423 bgp_peer_conf_if_to_su_update (struct peer
*peer
)
1425 struct interface
*ifp
;
1427 int peer_addr_updated
= 0;
1432 prev_family
= peer
->su
.sa
.sa_family
;
1433 if ((ifp
= if_lookup_by_name (peer
->conf_if
, peer
->bgp
->vrf_id
)))
1436 /* If BGP unnumbered is not "v6only", we first see if we can derive the
1437 * peer's IPv4 address.
1439 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1440 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v4 (peer
, ifp
);
1442 /* If "v6only" or we can't derive peer's IPv4 address, see if we've
1443 * learnt the peer's IPv6 link-local address. This is from the source
1444 * IPv6 address in router advertisement.
1446 if (!peer_addr_updated
)
1447 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v6 (peer
, ifp
);
1449 /* If we could derive the peer address, we may need to install the password
1450 * configured for the peer, if any, on the listen socket. Otherwise, mark
1451 * that peer's address is not available and uninstall the password, if
1454 if (peer_addr_updated
)
1456 if (peer
->password
&& prev_family
== AF_UNSPEC
)
1461 if (peer
->password
&& prev_family
!= AF_UNSPEC
)
1462 bgp_md5_unset (peer
);
1463 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1464 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof (struct in6_addr
));
1467 /* Since our su changed we need to del/add peer to the peerhash */
1468 hash_release(peer
->bgp
->peerhash
, peer
);
1469 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1472 /* Force a bestpath recalculation for all prefixes. This is used
1473 * when 'bgp bestpath' commands are entered.
1476 bgp_recalculate_all_bestpaths (struct bgp
*bgp
)
1480 struct bgp_node
*rn
, *nrn
;
1482 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1484 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1486 for (rn
= bgp_table_top (bgp
->rib
[afi
][safi
]); rn
;
1487 rn
= bgp_route_next (rn
))
1489 if (rn
->info
!= NULL
)
1491 /* Special handling for 2-level routing tables. */
1492 if (safi
== SAFI_MPLS_VPN
||
1493 safi
== SAFI_ENCAP
||
1496 for (nrn
= bgp_table_top((struct bgp_table
*)(rn
->info
));
1497 nrn
; nrn
= bgp_route_next (nrn
))
1498 bgp_process (bgp
, nrn
, afi
, safi
);
1501 bgp_process (bgp
, rn
, afi
, safi
);
1508 /* Create new BGP peer. */
1510 peer_create (union sockunion
*su
, const char *conf_if
, struct bgp
*bgp
,
1511 as_t local_as
, as_t remote_as
, int as_type
, afi_t afi
, safi_t safi
, struct peer_group
*group
)
1515 char buf
[SU_ADDRSTRLEN
];
1517 peer
= peer_new (bgp
);
1520 peer
->conf_if
= XSTRDUP (MTYPE_PEER_CONF_IF
, conf_if
);
1521 bgp_peer_conf_if_to_su_update(peer
);
1523 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1524 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, conf_if
);
1529 sockunion2str (su
, buf
, SU_ADDRSTRLEN
);
1531 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1532 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, buf
);
1534 peer
->local_as
= local_as
;
1535 peer
->as
= remote_as
;
1536 peer
->as_type
= as_type
;
1537 peer
->local_id
= bgp
->router_id
;
1538 peer
->v_holdtime
= bgp
->default_holdtime
;
1539 peer
->v_keepalive
= bgp
->default_keepalive
;
1540 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1541 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1543 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1545 peer
= peer_lock (peer
); /* bgp peer list reference */
1546 peer
->group
= group
;
1547 listnode_add_sort (bgp
->peer
, peer
);
1548 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1550 active
= peer_active (peer
);
1552 /* Last read and reset time set */
1553 peer
->readtime
= peer
->resettime
= bgp_clock ();
1555 /* Default TTL set. */
1556 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: 1;
1558 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1562 peer
->afc
[afi
][safi
] = 1;
1563 peer_af_create(peer
, afi
, safi
);
1566 /* Set up peer's events and timers. */
1567 if (! active
&& peer_active (peer
))
1568 bgp_timer_set (peer
);
1573 /* Make accept BGP peer. This function is only called from the test code */
1575 peer_create_accept (struct bgp
*bgp
)
1579 peer
= peer_new (bgp
);
1581 peer
= peer_lock (peer
); /* bgp peer list reference */
1582 listnode_add_sort (bgp
->peer
, peer
);
1587 /* Change peer's AS number. */
1589 peer_as_change (struct peer
*peer
, as_t as
, int as_specified
)
1591 bgp_peer_sort_t type
;
1595 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1597 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
1599 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1600 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1601 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1604 bgp_session_reset(peer
);
1606 type
= peer_sort (peer
);
1608 peer
->as_type
= as_specified
;
1610 if (bgp_config_check (peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1611 && ! bgp_confederation_peers_check (peer
->bgp
, as
)
1612 && peer
->bgp
->as
!= as
)
1613 peer
->local_as
= peer
->bgp
->confed_id
;
1615 peer
->local_as
= peer
->bgp
->as
;
1617 /* Advertisement-interval reset */
1620 conf
= peer
->group
->conf
;
1622 if (conf
&& CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
1624 peer
->v_routeadv
= conf
->routeadv
;
1626 /* Only go back to the default advertisement-interval if the user had not
1627 * already configured it */
1628 else if (!CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
))
1630 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1631 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1633 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1636 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1638 else if (type
== BGP_PEER_IBGP
)
1641 /* reflector-client reset */
1642 if (peer_sort (peer
) != BGP_PEER_IBGP
)
1644 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1645 PEER_FLAG_REFLECTOR_CLIENT
);
1646 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1647 PEER_FLAG_REFLECTOR_CLIENT
);
1648 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1649 PEER_FLAG_REFLECTOR_CLIENT
);
1650 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1651 PEER_FLAG_REFLECTOR_CLIENT
);
1652 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1653 PEER_FLAG_REFLECTOR_CLIENT
);
1654 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1655 PEER_FLAG_REFLECTOR_CLIENT
);
1656 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1657 PEER_FLAG_REFLECTOR_CLIENT
);
1658 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1659 PEER_FLAG_REFLECTOR_CLIENT
);
1660 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1661 PEER_FLAG_REFLECTOR_CLIENT
);
1662 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1663 PEER_FLAG_REFLECTOR_CLIENT
);
1664 UNSET_FLAG (peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1665 PEER_FLAG_REFLECTOR_CLIENT
);
1668 /* local-as reset */
1669 if (peer_sort (peer
) != BGP_PEER_EBGP
)
1671 peer
->change_local_as
= 0;
1672 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1673 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1677 /* If peer does not exist, create new one. If peer already exists,
1678 set AS number to the peer. */
1680 peer_remote_as (struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1681 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1687 peer
= peer_lookup_by_conf_if (bgp
, conf_if
);
1689 peer
= peer_lookup (bgp
, su
);
1693 /* Not allowed for a dynamic peer. */
1694 if (peer_dynamic_neighbor (peer
))
1697 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1700 /* When this peer is a member of peer-group. */
1703 if (peer
->group
->conf
->as
)
1705 /* Return peer group's AS number. */
1706 *as
= peer
->group
->conf
->as
;
1707 return BGP_ERR_PEER_GROUP_MEMBER
;
1709 if (peer_sort (peer
->group
->conf
) == BGP_PEER_IBGP
)
1711 if ((as_type
!= AS_INTERNAL
) && (bgp
->as
!= *as
))
1714 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1719 if ((as_type
!= AS_EXTERNAL
) && (bgp
->as
== *as
))
1722 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1727 /* Existing peer's AS number change. */
1728 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
1729 (peer
->as_type
!= as_type
))
1730 peer_as_change (peer
, *as
, as_type
);
1735 return BGP_ERR_NO_INTERFACE_CONFIG
;
1737 /* If the peer is not part of our confederation, and its not an
1738 iBGP peer then spoof the source AS */
1739 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
)
1740 && ! bgp_confederation_peers_check (bgp
, *as
)
1742 local_as
= bgp
->confed_id
;
1746 /* If this is IPv4 unicast configuration and "no bgp default
1747 ipv4-unicast" is specified. */
1749 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1750 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1751 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0, 0, NULL
);
1753 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, afi
, safi
, NULL
);
1760 non_peergroup_activate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1764 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1766 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1770 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST */
1771 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
]) ||
1772 (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1773 return BGP_ERR_PEER_SAFI_CONFLICT
;
1775 /* Nothing to do if we've already activated this peer */
1776 if (peer
->afc
[afi
][safi
])
1779 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1782 active
= peer_active (peer
);
1783 peer
->afc
[afi
][safi
] = 1;
1785 if (!active
&& peer_active (peer
))
1787 bgp_timer_set (peer
);
1791 if (peer
->status
== Established
)
1793 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1795 peer
->afc_adv
[afi
][safi
] = 1;
1796 bgp_capability_send (peer
, afi
, safi
,
1798 CAPABILITY_ACTION_SET
);
1799 if (peer
->afc_recv
[afi
][safi
])
1801 peer
->afc_nego
[afi
][safi
] = 1;
1802 bgp_announce_route (peer
, afi
, safi
);
1807 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1808 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1809 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1817 /* Activate the peer or peer group for specified AFI and SAFI. */
1819 peer_activate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1822 struct peer_group
*group
;
1823 struct listnode
*node
, *nnode
;
1824 struct peer
*tmp_peer
;
1826 /* Nothing to do if we've already activated this peer */
1827 if (peer
->afc
[afi
][safi
])
1830 /* This is a peer-group so activate all of the members of the
1831 * peer-group as well */
1832 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1835 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST */
1836 if ((safi
== SAFI_UNICAST
&& peer
->afc
[afi
][SAFI_LABELED_UNICAST
]) ||
1837 (safi
== SAFI_LABELED_UNICAST
&& peer
->afc
[afi
][SAFI_UNICAST
]))
1838 return BGP_ERR_PEER_SAFI_CONFLICT
;
1840 peer
->afc
[afi
][safi
] = 1;
1841 group
= peer
->group
;
1843 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1845 ret
|= non_peergroup_activate_af (tmp_peer
, afi
, safi
);
1850 ret
|= non_peergroup_activate_af (peer
, afi
, safi
);
1857 non_peergroup_deactivate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1859 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1861 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1865 /* Nothing to do if we've already deactivated this peer */
1866 if (! peer
->afc
[afi
][safi
])
1869 /* De-activate the address family configuration. */
1870 peer
->afc
[afi
][safi
] = 0;
1872 if (peer_af_delete(peer
, afi
, safi
) != 0)
1874 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1878 if (peer
->status
== Established
)
1880 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1882 peer
->afc_adv
[afi
][safi
] = 0;
1883 peer
->afc_nego
[afi
][safi
] = 0;
1885 if (peer_active_nego (peer
))
1887 bgp_capability_send (peer
, afi
, safi
,
1889 CAPABILITY_ACTION_UNSET
);
1890 bgp_clear_route (peer
, afi
, safi
);
1891 peer
->pcount
[afi
][safi
] = 0;
1895 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1896 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1897 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1902 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1903 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1904 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1912 peer_deactivate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1915 struct peer_group
*group
;
1916 struct peer
*tmp_peer
;
1917 struct listnode
*node
, *nnode
;
1919 /* Nothing to do if we've already de-activated this peer */
1920 if (! peer
->afc
[afi
][safi
])
1923 /* This is a peer-group so de-activate all of the members of the
1924 * peer-group as well */
1925 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1927 peer
->afc
[afi
][safi
] = 0;
1928 group
= peer
->group
;
1930 if (peer_af_delete(peer
, afi
, safi
) != 0)
1932 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1935 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1937 ret
|= non_peergroup_deactivate_af (tmp_peer
, afi
, safi
);
1942 ret
|= non_peergroup_deactivate_af (peer
, afi
, safi
);
1949 peer_afc_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
1952 return peer_activate (peer
, afi
, safi
);
1954 return peer_deactivate (peer
, afi
, safi
);
1958 peer_nsf_stop (struct peer
*peer
)
1963 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1964 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
);
1966 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1967 for (safi
= SAFI_UNICAST
; safi
< SAFI_RESERVED_4
; safi
++)
1968 peer
->nsf
[afi
][safi
] = 0;
1970 if (peer
->t_gr_restart
)
1972 BGP_TIMER_OFF (peer
->t_gr_restart
);
1973 if (bgp_debug_neighbor_events(peer
))
1974 zlog_debug ("%s graceful restart timer stopped", peer
->host
);
1976 if (peer
->t_gr_stale
)
1978 BGP_TIMER_OFF (peer
->t_gr_stale
);
1979 if (bgp_debug_neighbor_events(peer
))
1980 zlog_debug ("%s graceful restart stalepath timer stopped", peer
->host
);
1982 bgp_clear_route_all (peer
);
1985 /* Delete peer from confguration.
1987 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
1988 * it to "cool off" and refcounts to hit 0, at which state it is freed.
1990 * This function /should/ take care to be idempotent, to guard against
1991 * it being called multiple times through stray events that come in
1992 * that happen to result in this function being called again. That
1993 * said, getting here for a "Deleted" peer is a bug in the neighbour
1997 peer_delete (struct peer
*peer
)
2003 struct bgp_filter
*filter
;
2004 struct listnode
*pn
;
2007 assert (peer
->status
!= Deleted
);
2010 accept_peer
= CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2012 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
2013 peer_nsf_stop (peer
);
2015 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2017 /* If this peer belongs to peer group, clear up the
2021 if (peer_dynamic_neighbor(peer
))
2022 peer_drop_dynamic_neighbor(peer
);
2024 if ((pn
= listnode_lookup (peer
->group
->peer
, peer
)))
2026 peer
= peer_unlock (peer
); /* group->peer list reference */
2027 list_delete_node (peer
->group
->peer
, pn
);
2032 /* Withdraw all information from routing table. We can not use
2033 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2034 * executed after peer structure is deleted.
2036 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2038 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2040 if (peer
->doppelganger
)
2042 peer
->doppelganger
->doppelganger
= NULL
;
2043 peer
->doppelganger
= NULL
;
2046 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2047 bgp_fsm_change_status (peer
, Deleted
);
2049 /* Remove from NHT */
2050 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2051 bgp_unlink_nexthop_by_peer (peer
);
2053 /* Password configuration */
2056 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
2057 peer
->password
= NULL
;
2060 ! BGP_PEER_SU_UNSPEC(peer
) &&
2061 ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
2062 bgp_md5_unset (peer
);
2065 bgp_timer_set (peer
); /* stops all timers for Deleted */
2067 /* Delete from all peer list. */
2068 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
2069 && (pn
= listnode_lookup (bgp
->peer
, peer
)))
2071 peer_unlock (peer
); /* bgp peer list reference */
2072 list_delete_node (bgp
->peer
, pn
);
2073 hash_release(bgp
->peerhash
, peer
);
2079 stream_free (peer
->ibuf
);
2085 stream_fifo_free (peer
->obuf
);
2091 stream_free (peer
->work
);
2097 stream_free(peer
->scratch
);
2098 peer
->scratch
= NULL
;
2101 /* Local and remote addresses. */
2104 sockunion_free (peer
->su_local
);
2105 peer
->su_local
= NULL
;
2108 if (peer
->su_remote
)
2110 sockunion_free (peer
->su_remote
);
2111 peer
->su_remote
= NULL
;
2114 /* Free filter related memory. */
2115 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2116 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2118 filter
= &peer
->filter
[afi
][safi
];
2120 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
2122 if (filter
->dlist
[i
].name
)
2124 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2125 filter
->dlist
[i
].name
= NULL
;
2128 if (filter
->plist
[i
].name
)
2130 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2131 filter
->plist
[i
].name
= NULL
;
2134 if (filter
->aslist
[i
].name
)
2136 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2137 filter
->aslist
[i
].name
= NULL
;
2141 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
2143 if (filter
->map
[i
].name
)
2145 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2146 filter
->map
[i
].name
= NULL
;
2150 if (filter
->usmap
.name
)
2152 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2153 filter
->usmap
.name
= NULL
;
2156 if (peer
->default_rmap
[afi
][safi
].name
)
2158 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2159 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2163 FOREACH_AFI_SAFI (afi
, safi
)
2164 peer_af_delete (peer
, afi
, safi
);
2168 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2169 peer
->hostname
= NULL
;
2172 if (peer
->domainname
)
2174 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2175 peer
->domainname
= NULL
;
2178 peer_unlock (peer
); /* initial reference */
2184 peer_group_cmp (struct peer_group
*g1
, struct peer_group
*g2
)
2186 return strcmp (g1
->name
, g2
->name
);
2189 /* Peer group cofiguration. */
2190 static struct peer_group
*
2191 peer_group_new (void)
2193 return (struct peer_group
*) XCALLOC (MTYPE_PEER_GROUP
,
2194 sizeof (struct peer_group
));
2198 peer_group_free (struct peer_group
*group
)
2200 XFREE (MTYPE_PEER_GROUP
, group
);
2204 peer_group_lookup (struct bgp
*bgp
, const char *name
)
2206 struct peer_group
*group
;
2207 struct listnode
*node
, *nnode
;
2209 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
2211 if (strcmp (group
->name
, name
) == 0)
2218 peer_group_get (struct bgp
*bgp
, const char *name
)
2220 struct peer_group
*group
;
2223 group
= peer_group_lookup (bgp
, name
);
2227 group
= peer_group_new ();
2230 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2231 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2232 group
->peer
= list_new ();
2233 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2234 group
->listen_range
[afi
] = list_new ();
2235 group
->conf
= peer_new (bgp
);
2236 if (! bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2237 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2238 if (group
->conf
->host
)
2239 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2240 group
->conf
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, name
);
2241 group
->conf
->group
= group
;
2242 group
->conf
->as
= 0;
2243 group
->conf
->ttl
= 1;
2244 group
->conf
->gtsm_hops
= 0;
2245 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2246 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_TIMER
);
2247 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_CONNECT
);
2248 group
->conf
->keepalive
= 0;
2249 group
->conf
->holdtime
= 0;
2250 group
->conf
->connect
= 0;
2251 SET_FLAG (group
->conf
->sflags
, PEER_STATUS_GROUP
);
2252 listnode_add_sort (bgp
->group
, group
);
2258 peer_group2peer_config_copy (struct peer_group
*group
, struct peer
*peer
)
2267 peer
->as
= conf
->as
;
2270 if (conf
->change_local_as
)
2271 peer
->change_local_as
= conf
->change_local_as
;
2274 peer
->ttl
= conf
->ttl
;
2277 peer
->gtsm_hops
= conf
->gtsm_hops
;
2279 /* this flag is per-neighbor and so has to be preserved */
2280 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2282 /* peer flags apply */
2283 peer
->flags
= conf
->flags
;
2286 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2288 /* peer config apply */
2289 peer
->config
= conf
->config
;
2291 /* peer timers apply */
2292 peer
->holdtime
= conf
->holdtime
;
2293 peer
->keepalive
= conf
->keepalive
;
2294 peer
->connect
= conf
->connect
;
2295 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_CONNECT
))
2296 peer
->v_connect
= conf
->connect
;
2298 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2300 /* advertisement-interval reset */
2301 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
2302 peer
->v_routeadv
= conf
->routeadv
;
2304 if (peer_sort (peer
) == BGP_PEER_IBGP
)
2305 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2307 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2309 /* password apply */
2310 if (conf
->password
&& !peer
->password
)
2311 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, conf
->password
);
2313 if (! BGP_PEER_SU_UNSPEC(peer
))
2316 /* update-source apply */
2317 if (conf
->update_source
)
2319 if (peer
->update_source
)
2320 sockunion_free (peer
->update_source
);
2321 if (peer
->update_if
)
2323 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2324 peer
->update_if
= NULL
;
2326 peer
->update_source
= sockunion_dup (conf
->update_source
);
2328 else if (conf
->update_if
)
2330 if (peer
->update_if
)
2331 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2332 if (peer
->update_source
)
2334 sockunion_free (peer
->update_source
);
2335 peer
->update_source
= NULL
;
2337 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2340 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2344 peer_group2peer_config_copy_af (struct peer_group
*group
, struct peer
*peer
,
2345 afi_t afi
, safi_t safi
)
2348 int out
= FILTER_OUT
;
2350 struct bgp_filter
*pfilter
;
2351 struct bgp_filter
*gfilter
;
2354 pfilter
= &peer
->filter
[afi
][safi
];
2355 gfilter
= &conf
->filter
[afi
][safi
];
2357 /* peer af_flags apply */
2358 peer
->af_flags
[afi
][safi
] = conf
->af_flags
[afi
][safi
];
2360 /* maximum-prefix */
2361 peer
->pmax
[afi
][safi
] = conf
->pmax
[afi
][safi
];
2362 peer
->pmax_threshold
[afi
][safi
] = conf
->pmax_threshold
[afi
][safi
];
2363 peer
->pmax_restart
[afi
][safi
] = conf
->pmax_restart
[afi
][safi
];
2366 peer
->allowas_in
[afi
][safi
] = conf
->allowas_in
[afi
][safi
];
2369 peer
->weight
[afi
][safi
] = conf
->weight
[afi
][safi
];
2371 /* default-originate route-map */
2372 if (conf
->default_rmap
[afi
][safi
].name
)
2374 if (peer
->default_rmap
[afi
][safi
].name
)
2375 XFREE(MTYPE_BGP_FILTER_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2376 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, conf
->default_rmap
[afi
][safi
].name
);
2377 peer
->default_rmap
[afi
][safi
].map
= conf
->default_rmap
[afi
][safi
].map
;
2380 /* inbound filter apply */
2381 if (gfilter
->dlist
[in
].name
&& ! pfilter
->dlist
[in
].name
)
2383 if (pfilter
->dlist
[in
].name
)
2384 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[in
].name
);
2385 pfilter
->dlist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[in
].name
);
2386 pfilter
->dlist
[in
].alist
= gfilter
->dlist
[in
].alist
;
2389 if (gfilter
->plist
[in
].name
&& ! pfilter
->plist
[in
].name
)
2391 if (pfilter
->plist
[in
].name
)
2392 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[in
].name
);
2393 pfilter
->plist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[in
].name
);
2394 pfilter
->plist
[in
].plist
= gfilter
->plist
[in
].plist
;
2397 if (gfilter
->aslist
[in
].name
&& ! pfilter
->aslist
[in
].name
)
2399 if (pfilter
->aslist
[in
].name
)
2400 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[in
].name
);
2401 pfilter
->aslist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[in
].name
);
2402 pfilter
->aslist
[in
].aslist
= gfilter
->aslist
[in
].aslist
;
2405 if (gfilter
->map
[RMAP_IN
].name
&& ! pfilter
->map
[RMAP_IN
].name
)
2407 if (pfilter
->map
[RMAP_IN
].name
)
2408 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_IN
].name
);
2409 pfilter
->map
[RMAP_IN
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_IN
].name
);
2410 pfilter
->map
[RMAP_IN
].map
= gfilter
->map
[RMAP_IN
].map
;
2413 /* outbound filter apply */
2414 if (gfilter
->dlist
[out
].name
)
2416 if (pfilter
->dlist
[out
].name
)
2417 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2418 pfilter
->dlist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[out
].name
);
2419 pfilter
->dlist
[out
].alist
= gfilter
->dlist
[out
].alist
;
2423 if (pfilter
->dlist
[out
].name
)
2424 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2425 pfilter
->dlist
[out
].name
= NULL
;
2426 pfilter
->dlist
[out
].alist
= NULL
;
2429 if (gfilter
->plist
[out
].name
)
2431 if (pfilter
->plist
[out
].name
)
2432 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2433 pfilter
->plist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[out
].name
);
2434 pfilter
->plist
[out
].plist
= gfilter
->plist
[out
].plist
;
2438 if (pfilter
->plist
[out
].name
)
2439 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2440 pfilter
->plist
[out
].name
= NULL
;
2441 pfilter
->plist
[out
].plist
= NULL
;
2444 if (gfilter
->aslist
[out
].name
)
2446 if (pfilter
->aslist
[out
].name
)
2447 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2448 pfilter
->aslist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[out
].name
);
2449 pfilter
->aslist
[out
].aslist
= gfilter
->aslist
[out
].aslist
;
2453 if (pfilter
->aslist
[out
].name
)
2454 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2455 pfilter
->aslist
[out
].name
= NULL
;
2456 pfilter
->aslist
[out
].aslist
= NULL
;
2459 if (gfilter
->map
[RMAP_OUT
].name
)
2461 if (pfilter
->map
[RMAP_OUT
].name
)
2462 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2463 pfilter
->map
[RMAP_OUT
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_OUT
].name
);
2464 pfilter
->map
[RMAP_OUT
].map
= gfilter
->map
[RMAP_OUT
].map
;
2468 if (pfilter
->map
[RMAP_OUT
].name
)
2469 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2470 pfilter
->map
[RMAP_OUT
].name
= NULL
;
2471 pfilter
->map
[RMAP_OUT
].map
= NULL
;
2474 if (gfilter
->usmap
.name
)
2476 if (pfilter
->usmap
.name
)
2477 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2478 pfilter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->usmap
.name
);
2479 pfilter
->usmap
.map
= gfilter
->usmap
.map
;
2483 if (pfilter
->usmap
.name
)
2484 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2485 pfilter
->usmap
.name
= NULL
;
2486 pfilter
->usmap
.map
= NULL
;
2490 /* Peer group's remote AS configuration. */
2492 peer_group_remote_as (struct bgp
*bgp
, const char *group_name
,
2493 as_t
*as
, int as_type
)
2495 struct peer_group
*group
;
2497 struct listnode
*node
, *nnode
;
2499 group
= peer_group_lookup (bgp
, group_name
);
2503 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2507 /* When we setup peer-group AS number all peer group member's AS
2508 number must be updated to same number. */
2509 peer_as_change (group
->conf
, *as
, as_type
);
2511 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2513 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
2514 (peer
->as_type
!= as_type
))
2515 peer_as_change (peer
, *as
, as_type
);
2522 peer_group_delete (struct peer_group
*group
)
2526 struct prefix
*prefix
;
2528 struct listnode
*node
, *nnode
;
2533 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2535 other
= peer
->doppelganger
;
2537 if (other
&& other
->status
!= Deleted
)
2539 other
->group
= NULL
;
2543 list_delete (group
->peer
);
2545 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2547 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2549 prefix_free(prefix
);
2551 list_delete (group
->listen_range
[afi
]);
2554 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2557 bfd_info_free(&(group
->conf
->bfd_info
));
2559 group
->conf
->group
= NULL
;
2560 peer_delete (group
->conf
);
2562 /* Delete from all peer_group list. */
2563 listnode_delete (bgp
->group
, group
);
2565 peer_group_free (group
);
2571 peer_group_remote_as_delete (struct peer_group
*group
)
2573 struct peer
*peer
, *other
;
2574 struct listnode
*node
, *nnode
;
2576 if ((group
->conf
->as_type
== AS_UNSPECIFIED
) ||
2577 ((! group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2580 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2582 other
= peer
->doppelganger
;
2586 if (other
&& other
->status
!= Deleted
)
2588 other
->group
= NULL
;
2592 list_delete_all_node (group
->peer
);
2594 group
->conf
->as
= 0;
2595 group
->conf
->as_type
= AS_UNSPECIFIED
;
2601 peer_group_listen_range_add (struct peer_group
*group
, struct prefix
*range
)
2603 struct prefix
*prefix
;
2604 struct listnode
*node
, *nnode
;
2607 afi
= family2afi(range
->family
);
2609 /* Group needs remote AS configured. */
2610 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2611 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2613 /* Ensure no duplicates. Currently we don't care about overlaps. */
2614 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2616 if (prefix_same(range
, prefix
))
2620 prefix
= prefix_new();
2621 prefix_copy(prefix
, range
);
2622 listnode_add(group
->listen_range
[afi
], prefix
);
2627 peer_group_listen_range_del (struct peer_group
*group
, struct prefix
*range
)
2629 struct prefix
*prefix
, prefix2
;
2630 struct listnode
*node
, *nnode
;
2633 char buf
[PREFIX2STR_BUFFER
];
2635 afi
= family2afi(range
->family
);
2637 /* Identify the listen range. */
2638 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2640 if (prefix_same(range
, prefix
))
2645 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2647 prefix2str(prefix
, buf
, sizeof(buf
));
2649 /* Dispose off any dynamic neighbors that exist due to this listen range */
2650 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2652 if (!peer_dynamic_neighbor (peer
))
2655 sockunion2hostprefix(&peer
->su
, &prefix2
);
2656 if (prefix_match(prefix
, &prefix2
))
2658 if (bgp_debug_neighbor_events(peer
))
2659 zlog_debug ("Deleting dynamic neighbor %s group %s upon "
2660 "delete of listen range %s",
2661 peer
->host
, group
->name
, buf
);
2666 /* Get rid of the listen range */
2667 listnode_delete(group
->listen_range
[afi
], prefix
);
2672 /* Bind specified peer to peer group. */
2674 peer_group_bind (struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2675 struct peer_group
*group
, as_t
*as
)
2677 int first_member
= 0;
2680 int cap_enhe_preset
= 0;
2682 /* Lookup the peer. */
2684 peer
= peer_lookup (bgp
, su
);
2686 /* The peer exist, bind it to the peer-group */
2689 /* When the peer already belongs to peer group, check the consistency. */
2690 if (peer_group_active (peer
) && strcmp (peer
->group
->name
, group
->name
) != 0)
2691 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2693 /* The peer has not specified a remote-as, inherit it from the
2695 if (peer
->as_type
== AS_UNSPECIFIED
)
2697 peer
->as_type
= group
->conf
->as_type
;
2698 peer
->as
= group
->conf
->as
;
2701 if (! group
->conf
->as
)
2703 if (peer_sort (group
->conf
) != BGP_PEER_INTERNAL
2704 && peer_sort (group
->conf
) != peer_sort (peer
))
2708 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2711 if (peer_sort (group
->conf
) == BGP_PEER_INTERNAL
)
2715 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2716 cap_enhe_preset
= 1;
2718 peer_group2peer_config_copy(group
, peer
);
2721 * Capability extended-nexthop is enabled for an interface neighbor by
2722 * default. So, fix that up here.
2724 if (peer
->conf_if
&& cap_enhe_preset
)
2725 peer_flag_set (peer
, PEER_FLAG_CAPABILITY_ENHE
);
2727 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2728 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2730 if (group
->conf
->afc
[afi
][safi
])
2732 peer
->afc
[afi
][safi
] = 1;
2734 if (peer_af_find(peer
, afi
, safi
) || peer_af_create(peer
, afi
, safi
))
2736 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2739 else if (peer
->afc
[afi
][safi
])
2740 peer_deactivate (peer
, afi
, safi
);
2745 assert (group
&& peer
->group
== group
);
2749 struct listnode
*pn
;
2750 pn
= listnode_lookup (bgp
->peer
, peer
);
2751 list_delete_node (bgp
->peer
, pn
);
2752 peer
->group
= group
;
2753 listnode_add_sort (bgp
->peer
, peer
);
2755 peer
= peer_lock (peer
); /* group->peer list reference */
2756 listnode_add (group
->peer
, peer
);
2761 /* Advertisement-interval reset */
2762 if (! CHECK_FLAG (group
->conf
->config
, PEER_CONFIG_ROUTEADV
))
2764 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2765 group
->conf
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2767 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2770 /* ebgp-multihop reset */
2771 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2772 group
->conf
->ttl
= MAXTTL
;
2774 /* local-as reset */
2775 if (peer_sort (group
->conf
) != BGP_PEER_EBGP
)
2777 group
->conf
->change_local_as
= 0;
2778 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2779 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2783 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2785 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2787 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2788 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2789 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2793 bgp_session_reset(peer
);
2797 /* Create a new peer. */
2800 if ((group
->conf
->as_type
== AS_SPECIFIED
) && (! group
->conf
->as
))
2802 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2805 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
2807 peer
= peer_lock (peer
); /* group->peer list reference */
2808 listnode_add (group
->peer
, peer
);
2810 peer_group2peer_config_copy(group
, peer
);
2812 /* If the peer-group is active for this afi/safi then activate for this peer */
2813 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2814 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2815 if (group
->conf
->afc
[afi
][safi
])
2817 peer
->afc
[afi
][safi
] = 1;
2818 peer_af_create(peer
, afi
, safi
);
2819 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2821 else if (peer
->afc
[afi
][safi
])
2822 peer_deactivate (peer
, afi
, safi
);
2824 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2826 /* Set up peer's events and timers. */
2827 if (peer_active (peer
))
2828 bgp_timer_set (peer
);
2835 peer_group_unbind (struct bgp
*bgp
, struct peer
*peer
,
2836 struct peer_group
*group
)
2842 if (group
!= peer
->group
)
2843 return BGP_ERR_PEER_GROUP_MISMATCH
;
2845 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2846 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2848 if (peer
->afc
[afi
][safi
])
2850 peer
->afc
[afi
][safi
] = 0;
2851 peer_af_flag_reset (peer
, afi
, safi
);
2853 if (peer_af_delete(peer
, afi
, safi
) != 0)
2855 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
2860 assert (listnode_lookup (group
->peer
, peer
));
2861 peer_unlock (peer
); /* peer group list reference */
2862 listnode_delete (group
->peer
, peer
);
2864 other
= peer
->doppelganger
;
2866 if (group
->conf
->as
)
2869 if (other
&& other
->status
!= Deleted
)
2874 listnode_delete(group
->peer
, other
);
2876 other
->group
= NULL
;
2882 bgp_bfd_deregister_peer(peer
);
2883 peer_global_config_reset (peer
);
2885 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2887 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2888 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2889 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2892 bgp_session_reset(peer
);
2898 bgp_startup_timer_expire (struct thread
*thread
)
2902 bgp
= THREAD_ARG (thread
);
2903 bgp
->t_startup
= NULL
;
2908 /* BGP instance creation by `router bgp' commands. */
2910 bgp_create (as_t
*as
, const char *name
, enum bgp_instance_type inst_type
)
2916 if ( (bgp
= XCALLOC (MTYPE_BGP
, sizeof (struct bgp
))) == NULL
)
2919 if (BGP_DEBUG (zebra
, ZEBRA
))
2921 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2922 zlog_debug("Creating Default VRF, AS %u", *as
);
2924 zlog_debug("Creating %s %s, AS %u",
2925 (inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
2930 bgp
->inst_type
= inst_type
;
2931 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ?
2932 VRF_DEFAULT
: VRF_UNKNOWN
;
2933 bgp
->peer_self
= peer_new (bgp
);
2934 if (bgp
->peer_self
->host
)
2935 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2936 bgp
->peer_self
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2937 bgp
->peer
= list_new ();
2938 bgp
->peer
->cmp
= (int (*)(void *, void *)) peer_cmp
;
2939 bgp
->peerhash
= hash_create (peer_hash_key_make
, peer_hash_cmp
, NULL
);
2941 bgp
->group
= list_new ();
2942 bgp
->group
->cmp
= (int (*)(void *, void *)) peer_group_cmp
;
2944 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2945 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2947 bgp
->route
[afi
][safi
] = bgp_table_init (afi
, safi
);
2948 bgp
->aggregate
[afi
][safi
] = bgp_table_init (afi
, safi
);
2949 bgp
->rib
[afi
][safi
] = bgp_table_init (afi
, safi
);
2951 /* Enable maximum-paths */
2952 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_EBGP
, multipath_num
, 0);
2953 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_IBGP
, multipath_num
, 0);
2956 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2957 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2958 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2959 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2960 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2961 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2962 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2963 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2964 bgp
->dynamic_neighbors_count
= 0;
2965 #if DFLT_BGP_IMPORT_CHECK
2966 bgp_flag_set (bgp
, BGP_FLAG_IMPORT_CHECK
);
2968 #if DFLT_BGP_SHOW_HOSTNAME
2969 bgp_flag_set (bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2971 #if DFLT_BGP_LOG_NEIGHBOR_CHANGES
2972 bgp_flag_set (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2974 #if DFLT_BGP_DETERMINISTIC_MED
2975 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2977 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2982 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
)
2984 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2986 assert(bgp
->rfapi_cfg
);
2988 #endif /* ENABLE_BGP_VNC */
2992 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2996 /* TODO - The startup timer needs to be run for the whole of BGP */
2997 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
2998 bgp
->restart_time
, &bgp
->t_startup
);
3001 bgp
->wpkt_quanta
= BGP_WRITE_PACKET_MAX
;
3002 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
3004 QOBJ_REG (bgp
, bgp
);
3006 update_bgp_group_init(bgp
);
3010 /* Return the "default VRF" instance of BGP. */
3012 bgp_get_default (void)
3015 struct listnode
*node
, *nnode
;
3017 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3018 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3023 /* Lookup BGP entry. */
3025 bgp_lookup (as_t as
, const char *name
)
3028 struct listnode
*node
, *nnode
;
3030 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3032 && ((bgp
->name
== NULL
&& name
== NULL
)
3033 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0)))
3038 /* Lookup BGP structure by view name. */
3040 bgp_lookup_by_name (const char *name
)
3043 struct listnode
*node
, *nnode
;
3045 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3046 if ((bgp
->name
== NULL
&& name
== NULL
)
3047 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0))
3052 /* Lookup BGP instance based on VRF id. */
3053 /* Note: Only to be used for incoming messages from Zebra. */
3055 bgp_lookup_by_vrf_id (vrf_id_t vrf_id
)
3059 /* Lookup VRF (in tree) and follow link. */
3060 vrf
= vrf_lookup_by_id (vrf_id
);
3063 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3066 /* Called from VTY commands. */
3068 bgp_get (struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3069 enum bgp_instance_type inst_type
)
3073 /* Multiple instance check. */
3074 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
3077 bgp
= bgp_lookup_by_name (name
);
3079 bgp
= bgp_get_default ();
3081 /* Already exists. */
3087 return BGP_ERR_INSTANCE_MISMATCH
;
3089 if (bgp
->inst_type
!= inst_type
)
3090 return BGP_ERR_INSTANCE_MISMATCH
;
3097 /* BGP instance name can not be specified for single instance. */
3099 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3101 /* Get default BGP structure if exists. */
3102 bgp
= bgp_get_default ();
3109 return BGP_ERR_AS_MISMATCH
;
3116 bgp
= bgp_create (as
, name
, inst_type
);
3117 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3118 bgp_address_init (bgp
);
3119 bgp_scan_init (bgp
);
3122 bgp
->t_rmap_def_originate_eval
= NULL
;
3124 /* Create BGP server socket, if first instance. */
3125 if (list_isempty(bm
->bgp
)
3126 && !bgp_option_check (BGP_OPT_NO_LISTEN
))
3128 if (bgp_socket (bm
->port
, bm
->address
) < 0)
3129 return BGP_ERR_INVALID_VALUE
;
3132 listnode_add (bm
->bgp
, bgp
);
3134 /* If Default instance or VRF, link to the VRF structure, if present. */
3135 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
||
3136 bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3140 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3142 bgp_vrf_link (bgp
, vrf
);
3145 /* Register with Zebra, if needed */
3146 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3147 bgp_zebra_instance_register (bgp
);
3154 * Make BGP instance "up". Applies only to VRFs (non-default) and
3155 * implies the VRF has been learnt from Zebra.
3158 bgp_instance_up (struct bgp
*bgp
)
3161 struct listnode
*node
, *next
;
3163 /* Register with zebra. */
3164 bgp_zebra_instance_register (bgp
);
3166 /* Kick off any peers that may have been configured. */
3167 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3169 if (!BGP_PEER_START_SUPPRESSED (peer
))
3170 BGP_EVENT_ADD (peer
, BGP_Start
);
3173 /* Process any networks that have been configured. */
3174 bgp_static_add (bgp
);
3178 * Make BGP instance "down". Applies only to VRFs (non-default) and
3179 * implies the VRF has been deleted by Zebra.
3182 bgp_instance_down (struct bgp
*bgp
)
3185 struct listnode
*node
;
3186 struct listnode
*next
;
3189 if (bgp
->t_rmap_def_originate_eval
)
3191 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3192 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3195 /* Bring down peers, so corresponding routes are purged. */
3196 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3198 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3199 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3201 bgp_session_reset(peer
);
3204 /* Purge network and redistributed routes. */
3205 bgp_purge_static_redist_routes (bgp
);
3208 /* Delete BGP instance. */
3210 bgp_delete (struct bgp
*bgp
)
3213 struct peer_group
*group
;
3214 struct listnode
*node
, *next
;
3219 THREAD_OFF (bgp
->t_startup
);
3221 if (BGP_DEBUG (zebra
, ZEBRA
))
3223 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3224 zlog_debug("Deleting Default VRF");
3226 zlog_debug("Deleting %s %s",
3227 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
3232 if (bgp
->t_rmap_def_originate_eval
)
3234 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3235 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3238 /* Inform peers we're going down. */
3239 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3241 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3242 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3245 /* Delete static routes (networks). */
3246 bgp_static_delete (bgp
);
3248 /* Unset redistribution. */
3249 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3250 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3251 if (i
!= ZEBRA_ROUTE_BGP
)
3252 bgp_redistribute_unset (bgp
, afi
, i
, 0);
3254 /* Free peers and peer-groups. */
3255 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, next
, group
))
3256 peer_group_delete (group
);
3258 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3261 if (bgp
->peer_self
) {
3262 peer_delete(bgp
->peer_self
);
3263 bgp
->peer_self
= NULL
;
3266 update_bgp_group_free (bgp
);
3268 /* TODO - Other memory may need to be freed - e.g., NHT */
3273 bgp_cleanup_routes(bgp
);
3275 /* Remove visibility via the master list - there may however still be
3276 * routes to be processed still referencing the struct bgp.
3278 listnode_delete (bm
->bgp
, bgp
);
3280 /* Deregister from Zebra, if needed */
3281 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3282 bgp_zebra_instance_deregister (bgp
);
3284 /* Free interfaces in this instance. */
3285 bgp_if_finish (bgp
);
3287 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3289 bgp_vrf_unlink (bgp
, vrf
);
3291 thread_master_free_unused(bm
->master
);
3292 bgp_unlock(bgp
); /* initial reference */
3297 static void bgp_free (struct bgp
*);
3300 bgp_lock (struct bgp
*bgp
)
3306 bgp_unlock(struct bgp
*bgp
)
3308 assert(bgp
->lock
> 0);
3309 if (--bgp
->lock
== 0)
3314 bgp_free (struct bgp
*bgp
)
3318 struct bgp_table
*table
;
3319 struct bgp_node
*rn
;
3323 list_delete (bgp
->group
);
3324 list_delete (bgp
->peer
);
3328 hash_free(bgp
->peerhash
);
3329 bgp
->peerhash
= NULL
;
3332 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3333 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3335 /* Special handling for 2-level routing tables. */
3336 if (safi
== SAFI_MPLS_VPN
||
3337 safi
== SAFI_ENCAP
||
3340 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
3341 rn
= bgp_route_next (rn
))
3343 table
= (struct bgp_table
*) rn
->info
;
3344 bgp_table_finish(&table
);
3347 if (bgp
->route
[afi
][safi
])
3348 bgp_table_finish (&bgp
->route
[afi
][safi
]);
3349 if (bgp
->aggregate
[afi
][safi
])
3350 bgp_table_finish (&bgp
->aggregate
[afi
][safi
]) ;
3351 if (bgp
->rib
[afi
][safi
])
3352 bgp_table_finish (&bgp
->rib
[afi
][safi
]);
3355 bgp_scan_finish (bgp
);
3356 bgp_address_destroy (bgp
);
3359 XFREE(MTYPE_BGP
, bgp
->name
);
3361 XFREE (MTYPE_BGP
, bgp
);
3365 peer_lookup_by_conf_if (struct bgp
*bgp
, const char *conf_if
)
3368 struct listnode
*node
, *nnode
;
3375 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3376 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3377 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3380 else if (bm
->bgp
!= NULL
)
3382 struct listnode
*bgpnode
, *nbgpnode
;
3384 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3385 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3386 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3387 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3394 peer_lookup_by_hostname (struct bgp
*bgp
, const char *hostname
)
3397 struct listnode
*node
, *nnode
;
3404 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3405 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3406 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3409 else if (bm
->bgp
!= NULL
)
3411 struct listnode
*bgpnode
, *nbgpnode
;
3413 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3414 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3415 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3416 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3423 peer_lookup (struct bgp
*bgp
, union sockunion
*su
)
3425 struct peer
*peer
= NULL
;
3426 struct peer tmp_peer
;
3428 memset(&tmp_peer
, 0, sizeof(struct peer
));
3431 * We do not want to find the doppelganger peer so search for the peer in
3432 * the hash that has PEER_FLAG_CONFIG_NODE
3434 SET_FLAG (tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3440 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3442 else if (bm
->bgp
!= NULL
)
3444 struct listnode
*bgpnode
, *nbgpnode
;
3446 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3448 /* Skip VRFs, this function will not be invoked without an instance
3449 * when examining VRFs.
3451 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3454 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3465 peer_create_bind_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
,
3466 struct peer_group
*group
)
3472 /* Create peer first; we've already checked group config is valid. */
3473 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
3478 peer
= peer_lock (peer
);
3479 listnode_add (group
->peer
, peer
);
3481 peer_group2peer_config_copy(group
, peer
);
3484 * Bind peer for all AFs configured for the group. We don't call
3485 * peer_group_bind as that is sub-optimal and does some stuff we don't want.
3487 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3488 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3490 if (!group
->conf
->afc
[afi
][safi
])
3492 peer
->afc
[afi
][safi
] = 1;
3494 if (!peer_af_find(peer
, afi
, safi
))
3495 peer_af_create(peer
, afi
, safi
);
3497 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
3500 /* Mark as dynamic, but also as a "config node" for other things to work. */
3501 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3502 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3508 peer_group_lookup_dynamic_neighbor_range (struct peer_group
* group
,
3509 struct prefix
* prefix
)
3511 struct listnode
*node
, *nnode
;
3512 struct prefix
*range
;
3515 afi
= family2afi(prefix
->family
);
3517 if (group
->listen_range
[afi
])
3518 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, range
))
3519 if (prefix_match(range
, prefix
))
3526 peer_group_lookup_dynamic_neighbor (struct bgp
*bgp
, struct prefix
*prefix
,
3527 struct prefix
**listen_range
)
3529 struct prefix
*range
= NULL
;
3530 struct peer_group
*group
= NULL
;
3531 struct listnode
*node
, *nnode
;
3533 *listen_range
= NULL
;
3536 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3537 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3540 else if (bm
->bgp
!= NULL
)
3542 struct listnode
*bgpnode
, *nbgpnode
;
3544 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3545 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3546 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3551 *listen_range
= range
;
3552 return (group
&& range
) ? group
: NULL
;
3556 peer_lookup_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
)
3558 struct peer_group
*group
;
3561 struct prefix prefix
;
3562 struct prefix
*listen_range
;
3564 char buf
[PREFIX2STR_BUFFER
];
3565 char buf1
[PREFIX2STR_BUFFER
];
3567 sockunion2hostprefix(su
, &prefix
);
3569 /* See if incoming connection matches a configured listen range. */
3570 group
= peer_group_lookup_dynamic_neighbor (bgp
, &prefix
, &listen_range
);
3581 prefix2str(&prefix
, buf
, sizeof(buf
));
3582 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3584 if (bgp_debug_neighbor_events(NULL
))
3585 zlog_debug ("Dynamic Neighbor %s matches group %s listen range %s",
3586 buf
, group
->name
, buf1
);
3588 /* Are we within the listen limit? */
3589 dncount
= gbgp
->dynamic_neighbors_count
;
3591 if (dncount
>= gbgp
->dynamic_neighbors_limit
)
3593 if (bgp_debug_neighbor_events(NULL
))
3594 zlog_debug ("Dynamic Neighbor %s rejected - at limit %d",
3595 inet_sutop (su
, buf
), gbgp
->dynamic_neighbors_limit
);
3599 /* Ensure group is not disabled. */
3600 if (CHECK_FLAG (group
->conf
->flags
, PEER_FLAG_SHUTDOWN
))
3602 if (bgp_debug_neighbor_events(NULL
))
3603 zlog_debug ("Dynamic Neighbor %s rejected - group %s disabled",
3608 /* Check that at least one AF is activated for the group. */
3609 if (!peer_group_af_configured (group
))
3611 if (bgp_debug_neighbor_events(NULL
))
3612 zlog_debug ("Dynamic Neighbor %s rejected - no AF activated for group %s",
3617 /* Create dynamic peer and bind to associated group. */
3618 peer
= peer_create_bind_dynamic_neighbor (gbgp
, su
, group
);
3621 gbgp
->dynamic_neighbors_count
= ++dncount
;
3623 if (bgp_debug_neighbor_events(peer
))
3624 zlog_debug ("%s Dynamic Neighbor added, group %s count %d",
3625 peer
->host
, group
->name
, dncount
);
3630 void peer_drop_dynamic_neighbor (struct peer
*peer
)
3633 if (peer
->group
&& peer
->group
->bgp
)
3635 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3637 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3639 if (bgp_debug_neighbor_events(peer
))
3640 zlog_debug ("%s dropped from group %s, count %d",
3641 peer
->host
, peer
->group
->name
, dncount
);
3645 /* If peer is configured at least one address family return 1. */
3647 peer_active (struct peer
*peer
)
3649 if (BGP_PEER_SU_UNSPEC(peer
))
3651 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
]
3652 || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3653 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3654 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
]
3655 || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3656 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3657 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3658 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3659 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3660 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
]
3661 || peer
->afc
[AFI_L2VPN
][SAFI_EVPN
])
3666 /* If peer is negotiated at least one address family return 1. */
3668 peer_active_nego (struct peer
*peer
)
3670 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3671 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3672 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3673 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3674 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3675 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3676 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3677 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3678 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3679 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
]
3680 || peer
->afc_nego
[AFI_L2VPN
][SAFI_EVPN
])
3685 /* peer_flag_change_type. */
3686 enum peer_change_type
3690 peer_change_reset_in
,
3691 peer_change_reset_out
,
3695 peer_change_action (struct peer
*peer
, afi_t afi
, safi_t safi
,
3696 enum peer_change_type type
)
3698 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3701 if (peer
->status
!= Established
)
3704 if (type
== peer_change_reset
)
3706 /* If we're resetting session, we've to delete both peer struct */
3707 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3708 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3709 PEER_FLAG_CONFIG_NODE
)))
3710 peer_delete(peer
->doppelganger
);
3712 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3713 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3715 else if (type
== peer_change_reset_in
)
3717 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3718 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3719 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
3722 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3723 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3724 PEER_FLAG_CONFIG_NODE
)))
3725 peer_delete(peer
->doppelganger
);
3727 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3728 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3731 else if (type
== peer_change_reset_out
)
3733 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3734 bgp_announce_route (peer
, afi
, safi
);
3738 struct peer_flag_action
3743 /* This flag can be set for peer-group member. */
3744 u_char not_for_member
;
3746 /* Action when the flag is changed. */
3747 enum peer_change_type type
;
3749 /* Peer down cause */
3753 static const struct peer_flag_action peer_flag_action_list
[] =
3755 { PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3756 { PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3757 { PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3758 { PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3759 { PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3760 { PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3761 { PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3762 { PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3766 static const struct peer_flag_action peer_af_flag_action_list
[] =
3768 { PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3769 { PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3770 { PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3771 { PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3772 { PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3773 { PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3774 { PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3775 { PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3776 { PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3777 { PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3778 // PEER_FLAG_DEFAULT_ORIGINATE
3779 { PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3780 { PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3781 { PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3782 { PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3783 { PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3784 // PEER_FLAG_MAX_PREFIX
3785 // PEER_FLAG_MAX_PREFIX_WARNING
3786 { PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3787 { PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3788 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3789 { PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
,1, peer_change_reset_out
},
3790 { PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3791 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
,1, peer_change_reset_out
},
3792 { PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3793 { PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3794 { PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3798 /* Proper action set. */
3800 peer_flag_action_set (const struct peer_flag_action
*action_list
, int size
,
3801 struct peer_flag_action
*action
, u_int32_t flag
)
3807 const struct peer_flag_action
*match
= NULL
;
3809 /* Check peer's frag action. */
3810 for (i
= 0; i
< size
; i
++)
3812 match
= &action_list
[i
];
3814 if (match
->flag
== 0)
3817 if (match
->flag
& flag
)
3821 if (match
->type
== peer_change_reset_in
)
3823 if (match
->type
== peer_change_reset_out
)
3825 if (match
->type
== peer_change_reset
)
3830 if (match
->not_for_member
)
3831 action
->not_for_member
= 1;
3835 /* Set peer clear type. */
3836 if (reset_in
&& reset_out
)
3837 action
->type
= peer_change_reset
;
3839 action
->type
= peer_change_reset_in
;
3841 action
->type
= peer_change_reset_out
;
3843 action
->type
= peer_change_none
;
3849 peer_flag_modify_action (struct peer
*peer
, u_int32_t flag
)
3851 if (flag
== PEER_FLAG_SHUTDOWN
)
3853 if (CHECK_FLAG (peer
->flags
, flag
))
3855 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3856 peer_nsf_stop (peer
);
3858 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3859 if (peer
->t_pmax_restart
)
3861 BGP_TIMER_OFF (peer
->t_pmax_restart
);
3862 if (bgp_debug_neighbor_events(peer
))
3863 zlog_debug ("%s Maximum-prefix restart timer canceled",
3867 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3868 peer_nsf_stop (peer
);
3870 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3872 char *msg
= peer
->tx_shutdown_message
;
3875 if (!msg
&& peer_group_active (peer
))
3876 msg
= peer
->group
->conf
->tx_shutdown_message
;
3877 msglen
= msg
? strlen(msg
) : 0;
3886 memcpy(msgbuf
+ 1, msg
, msglen
);
3888 bgp_notify_send_with_data (peer
, BGP_NOTIFY_CEASE
,
3889 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3890 msgbuf
, msglen
+ 1);
3893 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3894 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3897 bgp_session_reset(peer
);
3901 peer
->v_start
= BGP_INIT_START_TIMER
;
3902 BGP_EVENT_ADD (peer
, BGP_Stop
);
3905 else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3907 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3908 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3909 else if (flag
== PEER_FLAG_PASSIVE
)
3910 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3911 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3912 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3914 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3915 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3918 bgp_session_reset(peer
);
3921 /* Change specified peer flag. */
3923 peer_flag_modify (struct peer
*peer
, u_int32_t flag
, int set
)
3927 struct peer_group
*group
;
3928 struct peer
*tmp_peer
;
3929 struct listnode
*node
, *nnode
;
3930 struct peer_flag_action action
;
3932 memset (&action
, 0, sizeof (struct peer_flag_action
));
3933 size
= sizeof peer_flag_action_list
/ sizeof (struct peer_flag_action
);
3935 found
= peer_flag_action_set (peer_flag_action_list
, size
, &action
, flag
);
3937 /* No flag action is found. */
3939 return BGP_ERR_INVALID_FLAG
;
3941 /* When unset the peer-group member's flag we have to check
3942 peer-group configuration. */
3943 if (! set
&& peer_group_active (peer
))
3944 if (CHECK_FLAG (peer
->group
->conf
->flags
, flag
))
3946 if (flag
== PEER_FLAG_SHUTDOWN
)
3947 return BGP_ERR_PEER_GROUP_SHUTDOWN
;
3950 /* Flag conflict check. */
3952 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
3953 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
3954 return BGP_ERR_PEER_FLAG_CONFLICT
;
3956 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3958 if (set
&& CHECK_FLAG (peer
->flags
, flag
) == flag
)
3960 if (! set
&& ! CHECK_FLAG (peer
->flags
, flag
))
3965 SET_FLAG (peer
->flags
, flag
);
3967 UNSET_FLAG (peer
->flags
, flag
);
3969 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3971 if (action
.type
== peer_change_reset
)
3972 peer_flag_modify_action (peer
, flag
);
3977 /* peer-group member updates. */
3978 group
= peer
->group
;
3980 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
3983 if (set
&& CHECK_FLAG (tmp_peer
->flags
, flag
) == flag
)
3986 if (! set
&& ! CHECK_FLAG (tmp_peer
->flags
, flag
))
3990 SET_FLAG (tmp_peer
->flags
, flag
);
3992 UNSET_FLAG (tmp_peer
->flags
, flag
);
3994 if (action
.type
== peer_change_reset
)
3995 peer_flag_modify_action (tmp_peer
, flag
);
4001 peer_flag_set (struct peer
*peer
, u_int32_t flag
)
4003 return peer_flag_modify (peer
, flag
, 1);
4007 peer_flag_unset (struct peer
*peer
, u_int32_t flag
)
4009 return peer_flag_modify (peer
, flag
, 0);
4013 peer_af_flag_modify (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
,
4018 struct listnode
*node
, *nnode
;
4019 struct peer_group
*group
;
4020 struct peer_flag_action action
;
4021 struct peer
*tmp_peer
;
4023 int addpath_tx_used
;
4025 memset (&action
, 0, sizeof (struct peer_flag_action
));
4026 size
= sizeof peer_af_flag_action_list
/ sizeof (struct peer_flag_action
);
4028 found
= peer_flag_action_set (peer_af_flag_action_list
, size
, &action
, flag
);
4030 /* No flag action is found. */
4032 return BGP_ERR_INVALID_FLAG
;
4034 /* Special check for reflector client. */
4035 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
4036 && peer_sort (peer
) != BGP_PEER_IBGP
)
4037 return BGP_ERR_NOT_INTERNAL_PEER
;
4039 /* Special check for remove-private-AS. */
4040 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
4041 && peer_sort (peer
) == BGP_PEER_IBGP
)
4042 return BGP_ERR_REMOVE_PRIVATE_AS
;
4044 /* as-override is not allowed for IBGP peers */
4045 if (flag
& PEER_FLAG_AS_OVERRIDE
4046 && peer_sort (peer
) == BGP_PEER_IBGP
)
4047 return BGP_ERR_AS_OVERRIDE
;
4049 /* When current flag configuration is same as requested one. */
4050 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4052 if (set
&& CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
) == flag
)
4054 if (! set
&& ! CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
))
4059 SET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4061 UNSET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4063 /* Execute action when peer is established. */
4064 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4065 && peer
->status
== Established
)
4067 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4068 bgp_clear_adj_in (peer
, afi
, safi
);
4071 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4072 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4073 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4074 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4075 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4076 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4077 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4078 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4080 peer_change_action (peer
, afi
, safi
, action
.type
);
4085 /* Peer group member updates. */
4086 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4088 group
= peer
->group
;
4090 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
4092 if (set
&& CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
) == flag
)
4095 if (! set
&& ! CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
))
4099 SET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4101 UNSET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4103 if (tmp_peer
->status
== Established
)
4105 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4106 bgp_clear_adj_in (tmp_peer
, afi
, safi
);
4109 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4110 tmp_peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4111 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4112 tmp_peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4113 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4114 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4115 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4116 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4118 peer_change_action (tmp_peer
, afi
, safi
, action
.type
);
4124 /* Track if addpath TX is in use */
4125 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
|PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4128 addpath_tx_used
= 0;
4132 addpath_tx_used
= 1;
4134 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)
4136 if (!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
))
4138 zlog_warn("%s: enabling bgp deterministic-med, this is required"\
4139 " for addpath-tx-bestpath-per-AS",
4141 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
4142 bgp_recalculate_all_bestpaths (bgp
);
4148 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, tmp_peer
))
4150 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
4151 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4153 addpath_tx_used
= 1;
4159 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4166 peer_af_flag_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4168 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 1);
4172 peer_af_flag_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4174 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 0);
4178 int peer_tx_shutdown_message_set (struct peer
*peer
, const char *msg
)
4180 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4181 peer
->tx_shutdown_message
= msg
? XSTRDUP (MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4185 int peer_tx_shutdown_message_unset (struct peer
*peer
)
4187 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4192 /* EBGP multihop configuration. */
4194 peer_ebgp_multihop_set (struct peer
*peer
, int ttl
)
4196 struct peer_group
*group
;
4197 struct listnode
*node
, *nnode
;
4200 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4203 /* see comment in peer_ttl_security_hops_set() */
4206 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4208 group
= peer
->group
;
4209 if (group
->conf
->gtsm_hops
!= 0)
4210 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4212 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
4214 if (peer1
->sort
== BGP_PEER_IBGP
)
4217 if (peer1
->gtsm_hops
!= 0)
4218 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4223 if (peer
->gtsm_hops
!= 0)
4224 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4230 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4232 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
)
4234 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4235 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4236 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4238 bgp_session_reset(peer
);
4243 group
= peer
->group
;
4244 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4246 if (peer
->sort
== BGP_PEER_IBGP
)
4249 peer
->ttl
= group
->conf
->ttl
;
4251 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4252 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4253 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4255 bgp_session_reset(peer
);
4262 peer_ebgp_multihop_unset (struct peer
*peer
)
4264 struct peer_group
*group
;
4265 struct listnode
*node
, *nnode
;
4267 if (peer
->sort
== BGP_PEER_IBGP
)
4270 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4271 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4273 if (peer_group_active (peer
))
4274 peer
->ttl
= peer
->group
->conf
->ttl
;
4278 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4280 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4281 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4282 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4284 bgp_session_reset(peer
);
4288 group
= peer
->group
;
4289 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4291 if (peer
->sort
== BGP_PEER_IBGP
)
4298 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4299 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4300 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4302 bgp_session_reset(peer
);
4309 /* Neighbor description. */
4311 peer_description_set (struct peer
*peer
, const char *desc
)
4314 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4316 peer
->desc
= XSTRDUP (MTYPE_PEER_DESC
, desc
);
4322 peer_description_unset (struct peer
*peer
)
4325 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4332 /* Neighbor update-source. */
4334 peer_update_source_if_set (struct peer
*peer
, const char *ifname
)
4336 struct peer_group
*group
;
4337 struct listnode
*node
, *nnode
;
4339 if (peer
->update_if
)
4341 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4342 && strcmp (peer
->update_if
, ifname
) == 0)
4345 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4346 peer
->update_if
= NULL
;
4349 if (peer
->update_source
)
4351 sockunion_free (peer
->update_source
);
4352 peer
->update_source
= NULL
;
4355 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4357 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4359 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4361 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4362 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4363 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4366 bgp_session_reset(peer
);
4370 /* peer-group member updates. */
4371 group
= peer
->group
;
4372 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4374 if (peer
->update_if
)
4376 if (strcmp (peer
->update_if
, ifname
) == 0)
4379 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4380 peer
->update_if
= NULL
;
4383 if (peer
->update_source
)
4385 sockunion_free (peer
->update_source
);
4386 peer
->update_source
= NULL
;
4389 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4391 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4393 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4394 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4395 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4398 bgp_session_reset(peer
);
4404 peer_update_source_addr_set (struct peer
*peer
, const union sockunion
*su
)
4406 struct peer_group
*group
;
4407 struct listnode
*node
, *nnode
;
4409 if (peer
->update_source
)
4411 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4412 && sockunion_cmp (peer
->update_source
, su
) == 0)
4414 sockunion_free (peer
->update_source
);
4415 peer
->update_source
= NULL
;
4418 if (peer
->update_if
)
4420 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4421 peer
->update_if
= NULL
;
4425 peer
->update_source
= sockunion_dup (su
);
4427 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4429 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4431 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4432 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4433 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4436 bgp_session_reset(peer
);
4440 /* peer-group member updates. */
4441 group
= peer
->group
;
4442 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4444 if (peer
->update_source
)
4446 if (sockunion_cmp (peer
->update_source
, su
) == 0)
4448 sockunion_free (peer
->update_source
);
4449 peer
->update_source
= NULL
;
4452 if (peer
->update_if
)
4454 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4455 peer
->update_if
= NULL
;
4458 peer
->update_source
= sockunion_dup (su
);
4460 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4462 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4463 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4464 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4467 bgp_session_reset(peer
);
4473 peer_update_source_unset (struct peer
*peer
)
4475 union sockunion
*su
;
4476 struct peer_group
*group
;
4477 struct listnode
*node
, *nnode
;
4479 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4480 && ! peer
->update_source
4481 && ! peer
->update_if
)
4484 if (peer
->update_source
)
4486 sockunion_free (peer
->update_source
);
4487 peer
->update_source
= NULL
;
4489 if (peer
->update_if
)
4491 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4492 peer
->update_if
= NULL
;
4495 if (peer_group_active (peer
))
4497 group
= peer
->group
;
4499 if (group
->conf
->update_source
)
4501 su
= sockunion_dup (group
->conf
->update_source
);
4502 peer
->update_source
= su
;
4504 else if (group
->conf
->update_if
)
4506 XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, group
->conf
->update_if
);
4509 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4511 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4513 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4514 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4515 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4518 bgp_session_reset(peer
);
4522 /* peer-group member updates. */
4523 group
= peer
->group
;
4524 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4526 if (! peer
->update_source
&& ! peer
->update_if
)
4529 if (peer
->update_source
)
4531 sockunion_free (peer
->update_source
);
4532 peer
->update_source
= NULL
;
4535 if (peer
->update_if
)
4537 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4538 peer
->update_if
= NULL
;
4541 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4543 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4544 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4545 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4548 bgp_session_reset(peer
);
4554 peer_default_originate_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
4557 struct peer_group
*group
;
4558 struct listnode
*node
, *nnode
;
4560 if (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
)
4561 || (rmap
&& ! peer
->default_rmap
[afi
][safi
].name
)
4562 || (rmap
&& strcmp (rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0))
4564 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4568 if (peer
->default_rmap
[afi
][safi
].name
)
4569 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4570 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4571 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4575 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4577 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4578 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4579 bgp_default_originate (peer
, afi
, safi
, 0);
4580 bgp_announce_route (peer
, afi
, safi
);
4585 /* peer-group member updates. */
4586 group
= peer
->group
;
4587 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4589 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4593 if (peer
->default_rmap
[afi
][safi
].name
)
4594 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4595 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4596 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4599 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4600 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4601 bgp_default_originate (peer
, afi
, safi
, 0);
4602 bgp_announce_route (peer
, afi
, safi
);
4609 peer_default_originate_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4611 struct peer_group
*group
;
4612 struct listnode
*node
, *nnode
;
4614 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
))
4616 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4618 if (peer
->default_rmap
[afi
][safi
].name
)
4619 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4620 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4621 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4624 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4626 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4627 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4628 bgp_default_originate (peer
, afi
, safi
, 1);
4629 bgp_announce_route (peer
, afi
, safi
);
4634 /* peer-group member updates. */
4635 group
= peer
->group
;
4636 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4638 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4640 if (peer
->default_rmap
[afi
][safi
].name
)
4641 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4642 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4643 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4645 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4646 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4647 bgp_default_originate (peer
, afi
, safi
, 1);
4648 bgp_announce_route (peer
, afi
, safi
);
4655 peer_port_set (struct peer
*peer
, u_int16_t port
)
4662 peer_port_unset (struct peer
*peer
)
4664 peer
->port
= BGP_PORT_DEFAULT
;
4669 * Helper function that is called after the name of the policy
4670 * being used by a peer has changed (AF specific). Automatically
4671 * initiates inbound or outbound processing as needed.
4674 peer_on_policy_change (struct peer
*peer
, afi_t afi
, safi_t safi
, int outbound
)
4678 update_group_adjust_peer (peer_af_find (peer
, afi
, safi
));
4679 if (peer
->status
== Established
)
4680 bgp_announce_route(peer
, afi
, safi
);
4684 if (peer
->status
!= Established
)
4687 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
4688 bgp_soft_reconfig_in (peer
, afi
, safi
);
4689 else if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4690 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4691 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
4696 /* neighbor weight. */
4698 peer_weight_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int16_t weight
)
4700 struct peer_group
*group
;
4701 struct listnode
*node
, *nnode
;
4703 if (peer
->weight
[afi
][safi
] != weight
)
4705 peer
->weight
[afi
][safi
] = weight
;
4706 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4707 peer_on_policy_change (peer
, afi
, safi
, 0);
4710 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4713 /* peer-group member updates. */
4714 group
= peer
->group
;
4715 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4717 if (peer
->weight
[afi
][safi
] != weight
)
4719 peer
->weight
[afi
][safi
] = weight
;
4720 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4721 peer_on_policy_change (peer
, afi
, safi
, 0);
4728 peer_weight_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4730 struct peer_group
*group
;
4731 struct listnode
*node
, *nnode
;
4733 /* not the peer-group itself but a peer in a peer-group */
4734 if (peer_group_active (peer
))
4736 group
= peer
->group
;
4738 /* inherit weight from the peer-group */
4739 if (CHECK_FLAG (group
->conf
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4741 peer
->weight
[afi
][safi
] = group
->conf
->weight
[afi
][safi
];
4742 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4743 peer_on_policy_change (peer
, afi
, safi
, 0);
4747 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4749 peer
->weight
[afi
][safi
] = 0;
4750 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4751 peer_on_policy_change (peer
, afi
, safi
, 0);
4758 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4760 peer
->weight
[afi
][safi
] = 0;
4761 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4762 peer_on_policy_change (peer
, afi
, safi
, 0);
4765 /* peer-group member updates. */
4766 group
= peer
->group
;
4770 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4772 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4774 peer
->weight
[afi
][safi
] = 0;
4775 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4776 peer_on_policy_change (peer
, afi
, safi
, 0);
4785 peer_timers_set (struct peer
*peer
, u_int32_t keepalive
, u_int32_t holdtime
)
4787 struct peer_group
*group
;
4788 struct listnode
*node
, *nnode
;
4790 /* keepalive value check. */
4791 if (keepalive
> 65535)
4792 return BGP_ERR_INVALID_VALUE
;
4794 /* Holdtime value check. */
4795 if (holdtime
> 65535)
4796 return BGP_ERR_INVALID_VALUE
;
4798 /* Holdtime value must be either 0 or greater than 3. */
4799 if (holdtime
< 3 && holdtime
!= 0)
4800 return BGP_ERR_INVALID_VALUE
;
4802 /* Set value to the configuration. */
4803 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4804 peer
->holdtime
= holdtime
;
4805 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4807 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4810 /* peer-group member updates. */
4811 group
= peer
->group
;
4812 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4814 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4815 peer
->holdtime
= group
->conf
->holdtime
;
4816 peer
->keepalive
= group
->conf
->keepalive
;
4822 peer_timers_unset (struct peer
*peer
)
4824 struct peer_group
*group
;
4825 struct listnode
*node
, *nnode
;
4827 /* Clear configuration. */
4828 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4829 peer
->keepalive
= 0;
4832 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4835 /* peer-group member updates. */
4836 group
= peer
->group
;
4837 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4839 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4841 peer
->keepalive
= 0;
4848 peer_timers_connect_set (struct peer
*peer
, u_int32_t connect
)
4850 struct peer_group
*group
;
4851 struct listnode
*node
, *nnode
;
4853 if (connect
> 65535)
4854 return BGP_ERR_INVALID_VALUE
;
4856 /* Set value to the configuration. */
4857 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4858 peer
->connect
= connect
;
4860 /* Set value to timer setting. */
4861 peer
->v_connect
= connect
;
4863 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4866 /* peer-group member updates. */
4867 group
= peer
->group
;
4868 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4870 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4871 peer
->connect
= connect
;
4872 peer
->v_connect
= connect
;
4878 peer_timers_connect_unset (struct peer
*peer
)
4880 struct peer_group
*group
;
4881 struct listnode
*node
, *nnode
;
4883 /* Clear configuration. */
4884 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4887 /* Set timer setting to default value. */
4888 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4890 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4893 /* peer-group member updates. */
4894 group
= peer
->group
;
4895 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4897 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4899 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4905 peer_advertise_interval_set (struct peer
*peer
, u_int32_t routeadv
)
4907 struct peer_group
*group
;
4908 struct listnode
*node
, *nnode
;
4911 return BGP_ERR_INVALID_VALUE
;
4913 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4914 peer
->routeadv
= routeadv
;
4915 peer
->v_routeadv
= routeadv
;
4917 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4918 update_group_adjust_peer_afs (peer
);
4919 if (peer
->status
== Established
)
4920 bgp_announce_route_all (peer
);
4924 /* peer-group member updates. */
4925 group
= peer
->group
;
4926 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4928 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4929 peer
->routeadv
= routeadv
;
4930 peer
->v_routeadv
= routeadv
;
4931 update_group_adjust_peer_afs (peer
);
4932 if (peer
->status
== Established
)
4933 bgp_announce_route_all (peer
);
4940 peer_advertise_interval_unset (struct peer
*peer
)
4942 struct peer_group
*group
;
4943 struct listnode
*node
, *nnode
;
4945 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4948 if (peer
->sort
== BGP_PEER_IBGP
)
4949 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4951 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4953 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4954 update_group_adjust_peer_afs (peer
);
4955 if (peer
->status
== Established
)
4956 bgp_announce_route_all (peer
);
4960 /* peer-group member updates. */
4961 group
= peer
->group
;
4962 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4964 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4967 if (peer
->sort
== BGP_PEER_IBGP
)
4968 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4970 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4972 update_group_adjust_peer_afs (peer
);
4973 if (peer
->status
== Established
)
4974 bgp_announce_route_all (peer
);
4980 /* neighbor interface */
4982 peer_interface_set (struct peer
*peer
, const char *str
)
4985 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4986 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
4990 peer_interface_unset (struct peer
*peer
)
4993 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4994 peer
->ifname
= NULL
;
4999 peer_allowas_in_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int allow_num
,
5002 struct peer_group
*group
;
5003 struct listnode
*node
, *nnode
;
5007 if (peer
->allowas_in
[afi
][safi
] ||
5008 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5009 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5011 peer
->allowas_in
[afi
][safi
] = 0;
5012 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5013 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5014 peer_on_policy_change (peer
, afi
, safi
, 0);
5017 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5020 group
= peer
->group
;
5021 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5023 if (peer
->allowas_in
[afi
][safi
] ||
5024 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5025 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5027 peer
->allowas_in
[afi
][safi
] = 0;
5028 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5029 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5030 peer_on_policy_change (peer
, afi
, safi
, 0);
5036 if (allow_num
< 1 || allow_num
> 10)
5037 return BGP_ERR_INVALID_VALUE
;
5039 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
5040 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5042 peer
->allowas_in
[afi
][safi
] = allow_num
;
5043 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5044 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5045 peer_on_policy_change (peer
, afi
, safi
, 0);
5048 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5051 group
= peer
->group
;
5052 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5054 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
5055 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5057 peer
->allowas_in
[afi
][safi
] = allow_num
;
5058 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5059 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5060 peer_on_policy_change (peer
, afi
, safi
, 0);
5069 peer_allowas_in_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5071 struct peer_group
*group
;
5072 struct peer
*tmp_peer
;
5073 struct listnode
*node
, *nnode
;
5075 /* If this is a peer-group we must first clear the flags for all of the
5076 * peer-group members
5078 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5080 group
= peer
->group
;
5081 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
5083 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5084 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5086 tmp_peer
->allowas_in
[afi
][safi
] = 0;
5087 peer_af_flag_unset (tmp_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5088 peer_af_flag_unset (tmp_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5089 peer_on_policy_change (tmp_peer
, afi
, safi
, 0);
5094 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5095 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5097 peer
->allowas_in
[afi
][safi
] = 0;
5098 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5099 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5100 peer_on_policy_change (peer
, afi
, safi
, 0);
5107 peer_local_as_set (struct peer
*peer
, as_t as
, int no_prepend
, int replace_as
)
5109 struct bgp
*bgp
= peer
->bgp
;
5110 struct peer_group
*group
;
5111 struct listnode
*node
, *nnode
;
5113 if (peer_sort (peer
) != BGP_PEER_EBGP
5114 && peer_sort (peer
) != BGP_PEER_INTERNAL
)
5115 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5118 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5121 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5123 if (peer
->change_local_as
== as
&&
5124 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && no_prepend
)
5125 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && ! no_prepend
)) &&
5126 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && replace_as
)
5127 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && ! replace_as
)))
5130 peer
->change_local_as
= as
;
5132 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5134 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5137 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5139 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5141 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5143 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5145 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5146 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5147 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5150 bgp_session_reset(peer
);
5154 group
= peer
->group
;
5155 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5157 peer
->change_local_as
= as
;
5159 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5161 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5164 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5166 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5168 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5170 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5171 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5172 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5175 BGP_EVENT_ADD (peer
, BGP_Stop
);
5182 peer_local_as_unset (struct peer
*peer
)
5184 struct peer_group
*group
;
5185 struct listnode
*node
, *nnode
;
5187 if (! peer
->change_local_as
)
5190 peer
->change_local_as
= 0;
5191 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5192 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5194 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5196 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5198 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5199 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5200 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5203 BGP_EVENT_ADD (peer
, BGP_Stop
);
5208 group
= peer
->group
;
5209 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5211 peer
->change_local_as
= 0;
5212 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5213 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5215 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5217 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5218 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5219 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5222 bgp_session_reset(peer
);
5227 /* Set password for authenticating with the peer. */
5229 peer_password_set (struct peer
*peer
, const char *password
)
5231 struct listnode
*nn
, *nnode
;
5232 int len
= password
? strlen(password
) : 0;
5233 int ret
= BGP_SUCCESS
;
5235 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5236 return BGP_ERR_INVALID_VALUE
;
5238 if (peer
->password
&& strcmp (peer
->password
, password
) == 0
5239 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5243 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5245 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, password
);
5247 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5249 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5250 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5252 bgp_session_reset(peer
);
5254 if (BGP_PEER_SU_UNSPEC(peer
))
5257 return (bgp_md5_set (peer
) >= 0) ? BGP_SUCCESS
: BGP_ERR_TCPSIG_FAILED
;
5260 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5262 if (peer
->password
&& strcmp (peer
->password
, password
) == 0)
5266 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5268 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5270 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5271 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5273 bgp_session_reset(peer
);
5275 if (! BGP_PEER_SU_UNSPEC(peer
))
5277 if (bgp_md5_set (peer
) < 0)
5278 ret
= BGP_ERR_TCPSIG_FAILED
;
5286 peer_password_unset (struct peer
*peer
)
5288 struct listnode
*nn
, *nnode
;
5291 && !CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5294 if (!CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5296 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5297 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5299 bgp_session_reset(peer
);
5302 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5304 peer
->password
= NULL
;
5306 if (! BGP_PEER_SU_UNSPEC(peer
))
5307 bgp_md5_unset (peer
);
5312 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5313 peer
->password
= NULL
;
5315 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5317 if (!peer
->password
)
5320 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5321 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5323 bgp_session_reset(peer
);
5325 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5326 peer
->password
= NULL
;
5328 if (! BGP_PEER_SU_UNSPEC(peer
))
5329 bgp_md5_unset (peer
);
5336 /* Set distribute list to the peer. */
5338 peer_distribute_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5341 struct bgp_filter
*filter
;
5342 struct peer_group
*group
;
5343 struct listnode
*node
, *nnode
;
5345 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5346 return BGP_ERR_INVALID_VALUE
;
5348 filter
= &peer
->filter
[afi
][safi
];
5350 if (filter
->plist
[direct
].name
)
5351 return BGP_ERR_PEER_FILTER_CONFLICT
;
5353 if (filter
->dlist
[direct
].name
)
5354 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5355 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5356 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5358 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5360 peer_on_policy_change(peer
, afi
, safi
,
5361 (direct
== FILTER_OUT
) ? 1 : 0);
5365 group
= peer
->group
;
5366 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5368 filter
= &peer
->filter
[afi
][safi
];
5370 if (filter
->dlist
[direct
].name
)
5371 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5372 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5373 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5374 peer_on_policy_change(peer
, afi
, safi
,
5375 (direct
== FILTER_OUT
) ? 1 : 0);
5382 peer_distribute_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5384 struct bgp_filter
*filter
;
5385 struct bgp_filter
*gfilter
;
5386 struct peer_group
*group
;
5387 struct listnode
*node
, *nnode
;
5389 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5390 return BGP_ERR_INVALID_VALUE
;
5392 filter
= &peer
->filter
[afi
][safi
];
5394 /* apply peer-group filter */
5395 if (peer_group_active(peer
))
5397 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5399 if (gfilter
->dlist
[direct
].name
)
5401 if (filter
->dlist
[direct
].name
)
5402 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5403 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[direct
].name
);
5404 filter
->dlist
[direct
].alist
= gfilter
->dlist
[direct
].alist
;
5405 peer_on_policy_change(peer
, afi
, safi
,
5406 (direct
== FILTER_OUT
) ? 1 : 0);
5411 if (filter
->dlist
[direct
].name
)
5412 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5413 filter
->dlist
[direct
].name
= NULL
;
5414 filter
->dlist
[direct
].alist
= NULL
;
5416 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5418 peer_on_policy_change(peer
, afi
, safi
,
5419 (direct
== FILTER_OUT
) ? 1 : 0);
5423 group
= peer
->group
;
5424 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5426 filter
= &peer
->filter
[afi
][safi
];
5428 if (filter
->dlist
[direct
].name
)
5429 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5430 filter
->dlist
[direct
].name
= NULL
;
5431 filter
->dlist
[direct
].alist
= NULL
;
5432 peer_on_policy_change(peer
, afi
, safi
,
5433 (direct
== FILTER_OUT
) ? 1 : 0);
5439 /* Update distribute list. */
5441 peer_distribute_update (struct access_list
*access
)
5446 struct listnode
*mnode
, *mnnode
;
5447 struct listnode
*node
, *nnode
;
5450 struct peer_group
*group
;
5451 struct bgp_filter
*filter
;
5453 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5456 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, access
->name
,
5458 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5460 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5461 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5463 filter
= &peer
->filter
[afi
][safi
];
5465 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5467 if (filter
->dlist
[direct
].name
)
5468 filter
->dlist
[direct
].alist
=
5469 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5471 filter
->dlist
[direct
].alist
= NULL
;
5475 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5477 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5478 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5480 filter
= &group
->conf
->filter
[afi
][safi
];
5482 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5484 if (filter
->dlist
[direct
].name
)
5485 filter
->dlist
[direct
].alist
=
5486 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5488 filter
->dlist
[direct
].alist
= NULL
;
5493 vnc_prefix_list_update(bgp
);
5498 /* Set prefix list to the peer. */
5500 peer_prefix_list_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5503 struct bgp_filter
*filter
;
5504 struct peer_group
*group
;
5505 struct listnode
*node
, *nnode
;
5507 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5508 return BGP_ERR_INVALID_VALUE
;
5510 filter
= &peer
->filter
[afi
][safi
];
5512 if (filter
->dlist
[direct
].name
)
5513 return BGP_ERR_PEER_FILTER_CONFLICT
;
5515 if (filter
->plist
[direct
].name
)
5516 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5517 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5518 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5520 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5522 peer_on_policy_change(peer
, afi
, safi
,
5523 (direct
== FILTER_OUT
) ? 1 : 0);
5527 group
= peer
->group
;
5528 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5530 filter
= &peer
->filter
[afi
][safi
];
5532 if (filter
->plist
[direct
].name
)
5533 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5534 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5535 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5536 peer_on_policy_change(peer
, afi
, safi
,
5537 (direct
== FILTER_OUT
) ? 1 : 0);
5543 peer_prefix_list_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5545 struct bgp_filter
*filter
;
5546 struct bgp_filter
*gfilter
;
5547 struct peer_group
*group
;
5548 struct listnode
*node
, *nnode
;
5550 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5551 return BGP_ERR_INVALID_VALUE
;
5553 filter
= &peer
->filter
[afi
][safi
];
5555 /* apply peer-group filter */
5556 if (peer_group_active(peer
))
5558 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5560 if (gfilter
->plist
[direct
].name
)
5562 if (filter
->plist
[direct
].name
)
5563 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5564 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[direct
].name
);
5565 filter
->plist
[direct
].plist
= gfilter
->plist
[direct
].plist
;
5566 peer_on_policy_change(peer
, afi
, safi
,
5567 (direct
== FILTER_OUT
) ? 1 : 0);
5572 if (filter
->plist
[direct
].name
)
5573 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5574 filter
->plist
[direct
].name
= NULL
;
5575 filter
->plist
[direct
].plist
= NULL
;
5577 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5579 peer_on_policy_change(peer
, afi
, safi
,
5580 (direct
== FILTER_OUT
) ? 1 : 0);
5584 group
= peer
->group
;
5585 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5587 filter
= &peer
->filter
[afi
][safi
];
5589 if (filter
->plist
[direct
].name
)
5590 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5591 filter
->plist
[direct
].name
= NULL
;
5592 filter
->plist
[direct
].plist
= NULL
;
5593 peer_on_policy_change(peer
, afi
, safi
,
5594 (direct
== FILTER_OUT
) ? 1 : 0);
5600 /* Update prefix-list list. */
5602 peer_prefix_list_update (struct prefix_list
*plist
)
5604 struct listnode
*mnode
, *mnnode
;
5605 struct listnode
*node
, *nnode
;
5608 struct peer_group
*group
;
5609 struct bgp_filter
*filter
;
5614 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5618 * Update the prefix-list on update groups.
5620 update_group_policy_update(bgp
, BGP_POLICY_PREFIX_LIST
,
5621 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5623 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5625 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5626 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5628 filter
= &peer
->filter
[afi
][safi
];
5630 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5632 if (filter
->plist
[direct
].name
)
5633 filter
->plist
[direct
].plist
=
5634 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5636 filter
->plist
[direct
].plist
= NULL
;
5640 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5642 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5643 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5645 filter
= &group
->conf
->filter
[afi
][safi
];
5647 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5649 if (filter
->plist
[direct
].name
)
5650 filter
->plist
[direct
].plist
=
5651 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5653 filter
->plist
[direct
].plist
= NULL
;
5661 peer_aslist_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5664 struct bgp_filter
*filter
;
5665 struct peer_group
*group
;
5666 struct listnode
*node
, *nnode
;
5668 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5669 return BGP_ERR_INVALID_VALUE
;
5671 filter
= &peer
->filter
[afi
][safi
];
5673 if (filter
->aslist
[direct
].name
)
5674 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5675 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5676 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5678 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5680 peer_on_policy_change(peer
, afi
, safi
,
5681 (direct
== FILTER_OUT
) ? 1 : 0);
5685 group
= peer
->group
;
5686 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5688 filter
= &peer
->filter
[afi
][safi
];
5690 if (filter
->aslist
[direct
].name
)
5691 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5692 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5693 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5694 peer_on_policy_change(peer
, afi
, safi
,
5695 (direct
== FILTER_OUT
) ? 1 : 0);
5701 peer_aslist_unset (struct peer
*peer
,afi_t afi
, safi_t safi
, int direct
)
5703 struct bgp_filter
*filter
;
5704 struct bgp_filter
*gfilter
;
5705 struct peer_group
*group
;
5706 struct listnode
*node
, *nnode
;
5708 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5709 return BGP_ERR_INVALID_VALUE
;
5711 filter
= &peer
->filter
[afi
][safi
];
5713 /* apply peer-group filter */
5714 if (peer_group_active(peer
))
5716 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5718 if (gfilter
->aslist
[direct
].name
)
5720 if (filter
->aslist
[direct
].name
)
5721 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5722 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[direct
].name
);
5723 filter
->aslist
[direct
].aslist
= gfilter
->aslist
[direct
].aslist
;
5724 peer_on_policy_change(peer
, afi
, safi
,
5725 (direct
== FILTER_OUT
) ? 1 : 0);
5730 if (filter
->aslist
[direct
].name
)
5731 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5732 filter
->aslist
[direct
].name
= NULL
;
5733 filter
->aslist
[direct
].aslist
= NULL
;
5735 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5737 peer_on_policy_change(peer
, afi
, safi
,
5738 (direct
== FILTER_OUT
) ? 1 : 0);
5742 group
= peer
->group
;
5743 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5745 filter
= &peer
->filter
[afi
][safi
];
5747 if (filter
->aslist
[direct
].name
)
5748 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5749 filter
->aslist
[direct
].name
= NULL
;
5750 filter
->aslist
[direct
].aslist
= NULL
;
5751 peer_on_policy_change(peer
, afi
, safi
,
5752 (direct
== FILTER_OUT
) ? 1 : 0);
5759 peer_aslist_update (const char *aslist_name
)
5764 struct listnode
*mnode
, *mnnode
;
5765 struct listnode
*node
, *nnode
;
5768 struct peer_group
*group
;
5769 struct bgp_filter
*filter
;
5771 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5773 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, aslist_name
,
5776 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5778 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5779 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5781 filter
= &peer
->filter
[afi
][safi
];
5783 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5785 if (filter
->aslist
[direct
].name
)
5786 filter
->aslist
[direct
].aslist
=
5787 as_list_lookup (filter
->aslist
[direct
].name
);
5789 filter
->aslist
[direct
].aslist
= NULL
;
5793 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5795 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5796 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5798 filter
= &group
->conf
->filter
[afi
][safi
];
5800 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5802 if (filter
->aslist
[direct
].name
)
5803 filter
->aslist
[direct
].aslist
=
5804 as_list_lookup (filter
->aslist
[direct
].name
);
5806 filter
->aslist
[direct
].aslist
= NULL
;
5814 peer_aslist_add (char *aslist_name
)
5816 peer_aslist_update (aslist_name
);
5817 route_map_notify_dependencies((char *)aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
5821 peer_aslist_del (const char *aslist_name
)
5823 peer_aslist_update (aslist_name
);
5824 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
5829 peer_route_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5832 struct bgp_filter
*filter
;
5833 struct peer_group
*group
;
5834 struct listnode
*node
, *nnode
;
5836 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5837 return BGP_ERR_INVALID_VALUE
;
5839 filter
= &peer
->filter
[afi
][safi
];
5841 if (filter
->map
[direct
].name
)
5842 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5844 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5845 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5847 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5849 peer_on_policy_change(peer
, afi
, safi
,
5850 (direct
== RMAP_OUT
) ? 1 : 0);
5854 group
= peer
->group
;
5855 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5857 filter
= &peer
->filter
[afi
][safi
];
5859 if (filter
->map
[direct
].name
)
5860 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5861 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5862 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5863 peer_on_policy_change(peer
, afi
, safi
,
5864 (direct
== RMAP_OUT
) ? 1 : 0);
5869 /* Unset route-map from the peer. */
5871 peer_route_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5873 struct bgp_filter
*filter
;
5874 struct bgp_filter
*gfilter
;
5875 struct peer_group
*group
;
5876 struct listnode
*node
, *nnode
;
5878 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5879 return BGP_ERR_INVALID_VALUE
;
5881 filter
= &peer
->filter
[afi
][safi
];
5883 /* apply peer-group filter */
5884 if (peer_group_active(peer
))
5886 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5888 if (gfilter
->map
[direct
].name
)
5890 if (filter
->map
[direct
].name
)
5891 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5892 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[direct
].name
);
5893 filter
->map
[direct
].map
= gfilter
->map
[direct
].map
;
5894 peer_on_policy_change(peer
, afi
, safi
,
5895 (direct
== RMAP_OUT
) ? 1 : 0);
5900 if (filter
->map
[direct
].name
)
5901 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5902 filter
->map
[direct
].name
= NULL
;
5903 filter
->map
[direct
].map
= NULL
;
5905 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5907 peer_on_policy_change(peer
, afi
, safi
,
5908 (direct
== RMAP_OUT
) ? 1 : 0);
5912 group
= peer
->group
;
5913 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5915 filter
= &peer
->filter
[afi
][safi
];
5917 if (filter
->map
[direct
].name
)
5918 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5919 filter
->map
[direct
].name
= NULL
;
5920 filter
->map
[direct
].map
= NULL
;
5921 peer_on_policy_change(peer
, afi
, safi
,
5922 (direct
== RMAP_OUT
) ? 1 : 0);
5927 /* Set unsuppress-map to the peer. */
5929 peer_unsuppress_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5932 struct bgp_filter
*filter
;
5933 struct peer_group
*group
;
5934 struct listnode
*node
, *nnode
;
5936 filter
= &peer
->filter
[afi
][safi
];
5938 if (filter
->usmap
.name
)
5939 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5941 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5942 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5944 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5946 peer_on_policy_change(peer
, afi
, safi
, 1);
5950 group
= peer
->group
;
5951 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5953 filter
= &peer
->filter
[afi
][safi
];
5955 if (filter
->usmap
.name
)
5956 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5957 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5958 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5959 peer_on_policy_change(peer
, afi
, safi
, 1);
5964 /* Unset route-map from the peer. */
5966 peer_unsuppress_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5968 struct bgp_filter
*filter
;
5969 struct peer_group
*group
;
5970 struct listnode
*node
, *nnode
;
5972 filter
= &peer
->filter
[afi
][safi
];
5974 if (filter
->usmap
.name
)
5975 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5976 filter
->usmap
.name
= NULL
;
5977 filter
->usmap
.map
= NULL
;
5979 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5981 peer_on_policy_change(peer
, afi
, safi
, 1);
5985 group
= peer
->group
;
5986 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5988 filter
= &peer
->filter
[afi
][safi
];
5990 if (filter
->usmap
.name
)
5991 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5992 filter
->usmap
.name
= NULL
;
5993 filter
->usmap
.map
= NULL
;
5994 peer_on_policy_change(peer
, afi
, safi
, 1);
6000 peer_maximum_prefix_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
6001 u_int32_t max
, u_char threshold
,
6002 int warning
, u_int16_t restart
)
6004 struct peer_group
*group
;
6005 struct listnode
*node
, *nnode
;
6007 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6008 peer
->pmax
[afi
][safi
] = max
;
6009 peer
->pmax_threshold
[afi
][safi
] = threshold
;
6010 peer
->pmax_restart
[afi
][safi
] = restart
;
6012 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6014 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6016 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6018 group
= peer
->group
;
6019 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6021 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6022 peer
->pmax
[afi
][safi
] = max
;
6023 peer
->pmax_threshold
[afi
][safi
] = threshold
;
6024 peer
->pmax_restart
[afi
][safi
] = restart
;
6026 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6028 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6030 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6031 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
6036 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6037 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
6044 peer_maximum_prefix_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
6046 struct peer_group
*group
;
6047 struct listnode
*node
, *nnode
;
6049 /* apply peer-group config */
6050 if (peer_group_active(peer
))
6052 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6053 PEER_FLAG_MAX_PREFIX
))
6054 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6056 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6058 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6059 PEER_FLAG_MAX_PREFIX_WARNING
))
6060 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6062 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6064 peer
->pmax
[afi
][safi
] = peer
->group
->conf
->pmax
[afi
][safi
];
6065 peer
->pmax_threshold
[afi
][safi
] = peer
->group
->conf
->pmax_threshold
[afi
][safi
];
6066 peer
->pmax_restart
[afi
][safi
] = peer
->group
->conf
->pmax_restart
[afi
][safi
];
6070 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6071 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6072 peer
->pmax
[afi
][safi
] = 0;
6073 peer
->pmax_threshold
[afi
][safi
] = 0;
6074 peer
->pmax_restart
[afi
][safi
] = 0;
6076 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6079 group
= peer
->group
;
6080 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6082 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6083 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6084 peer
->pmax
[afi
][safi
] = 0;
6085 peer
->pmax_threshold
[afi
][safi
] = 0;
6086 peer
->pmax_restart
[afi
][safi
] = 0;
6091 int is_ebgp_multihop_configured (struct peer
*peer
)
6093 struct peer_group
*group
;
6094 struct listnode
*node
, *nnode
;
6097 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6099 group
= peer
->group
;
6100 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6101 (group
->conf
->ttl
!= 1))
6104 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
6106 if ((peer_sort (peer1
) != BGP_PEER_IBGP
) &&
6113 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6120 /* Set # of hops between us and BGP peer. */
6122 peer_ttl_security_hops_set (struct peer
*peer
, int gtsm_hops
)
6124 struct peer_group
*group
;
6125 struct listnode
*node
, *nnode
;
6128 zlog_debug ("peer_ttl_security_hops_set: set gtsm_hops to %d for %s", gtsm_hops
, peer
->host
);
6130 /* We cannot configure ttl-security hops when ebgp-multihop is already
6131 set. For non peer-groups, the check is simple. For peer-groups, it's
6132 slightly messy, because we need to check both the peer-group structure
6133 and all peer-group members for any trace of ebgp-multihop configuration
6134 before actually applying the ttl-security rules. Cisco really made a
6135 mess of this configuration parameter, and OpenBGPD got it right.
6138 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
))
6140 if (is_ebgp_multihop_configured (peer
))
6141 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6143 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6145 peer
->gtsm_hops
= gtsm_hops
;
6147 /* Calling ebgp multihop also resets the session.
6148 * On restart, NHT will get setup correctly as will the
6149 * min & max ttls on the socket. The return value is
6152 ret
= peer_ebgp_multihop_set (peer
, MAXTTL
);
6159 group
= peer
->group
;
6160 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6162 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6164 /* Calling ebgp multihop also resets the session.
6165 * On restart, NHT will get setup correctly as will the
6166 * min & max ttls on the socket. The return value is
6169 peer_ebgp_multihop_set (peer
, MAXTTL
);
6175 /* Post the first gtsm setup or if its ibgp, maxttl setting isn't
6176 * necessary, just set the minttl.
6178 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6180 peer
->gtsm_hops
= gtsm_hops
;
6183 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6184 MAXTTL
+ 1 - gtsm_hops
);
6185 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6186 (peer
->doppelganger
->fd
>= 0))
6187 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6188 MAXTTL
+ 1 - gtsm_hops
);
6192 group
= peer
->group
;
6193 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6195 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6197 /* Change setting of existing peer
6198 * established then change value (may break connectivity)
6199 * not established yet (teardown session and restart)
6200 * no session then do nothing (will get handled by next connection)
6202 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6203 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6204 MAXTTL
+ 1 - peer
->gtsm_hops
);
6205 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6206 (peer
->doppelganger
->fd
>= 0))
6207 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6208 MAXTTL
+ 1 - gtsm_hops
);
6218 peer_ttl_security_hops_unset (struct peer
*peer
)
6220 struct peer_group
*group
;
6221 struct listnode
*node
, *nnode
;
6224 zlog_debug ("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s", peer
->host
);
6226 /* if a peer-group member, then reset to peer-group default rather than 0 */
6227 if (peer_group_active (peer
))
6228 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6230 peer
->gtsm_hops
= 0;
6232 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6234 /* Invoking ebgp_multihop_set will set the TTL back to the original
6235 * value as well as restting the NHT and such. The session is reset.
6237 if (peer
->sort
== BGP_PEER_EBGP
)
6238 ret
= peer_ebgp_multihop_unset (peer
);
6242 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6244 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6245 (peer
->doppelganger
->fd
>= 0))
6246 sockopt_minttl (peer
->su
.sa
.sa_family
,
6247 peer
->doppelganger
->fd
, 0);
6252 group
= peer
->group
;
6253 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6255 peer
->gtsm_hops
= 0;
6256 if (peer
->sort
== BGP_PEER_EBGP
)
6257 ret
= peer_ebgp_multihop_unset (peer
);
6261 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6263 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6264 (peer
->doppelganger
->fd
>= 0))
6265 sockopt_minttl (peer
->su
.sa
.sa_family
,
6266 peer
->doppelganger
->fd
, 0);
6275 * If peer clear is invoked in a loop for all peers on the BGP instance,
6276 * it may end up freeing the doppelganger, and if this was the next node
6277 * to the current node, we would end up accessing the freed next node.
6278 * Pass along additional parameter which can be updated if next node
6279 * is freed; only required when walking the peer list on BGP instance.
6282 peer_clear (struct peer
*peer
, struct listnode
**nnode
)
6284 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6286 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
6288 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6289 if (peer
->t_pmax_restart
)
6291 BGP_TIMER_OFF (peer
->t_pmax_restart
);
6292 if (bgp_debug_neighbor_events(peer
))
6293 zlog_debug ("%s Maximum-prefix restart timer canceled",
6296 BGP_EVENT_ADD (peer
, BGP_Start
);
6300 peer
->v_start
= BGP_INIT_START_TIMER
;
6301 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6302 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
6303 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6305 bgp_session_reset_safe(peer
, nnode
);
6311 peer_clear_soft (struct peer
*peer
, afi_t afi
, safi_t safi
,
6312 enum bgp_clear_type stype
)
6314 struct peer_af
*paf
;
6316 if (peer
->status
!= Established
)
6319 if (! peer
->afc
[afi
][safi
])
6320 return BGP_ERR_AF_UNCONFIGURED
;
6322 peer
->rtt
= sockopt_tcp_rtt (peer
->fd
);
6324 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
)
6326 /* Clear the "neighbor x.x.x.x default-originate" flag */
6327 paf
= peer_af_find (peer
, afi
, safi
);
6328 if (paf
&& paf
->subgroup
&&
6329 CHECK_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6330 UNSET_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6332 bgp_announce_route (peer
, afi
, safi
);
6335 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6337 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
)
6338 && (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
)
6339 || CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
6341 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6344 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
))
6345 prefix_type
= ORF_TYPE_PREFIX
;
6347 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6349 if (filter
->plist
[FILTER_IN
].plist
)
6351 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6352 bgp_route_refresh_send (peer
, afi
, safi
,
6353 prefix_type
, REFRESH_DEFER
, 1);
6354 bgp_route_refresh_send (peer
, afi
, safi
, prefix_type
,
6355 REFRESH_IMMEDIATE
, 0);
6359 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6360 bgp_route_refresh_send (peer
, afi
, safi
,
6361 prefix_type
, REFRESH_IMMEDIATE
, 1);
6363 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6369 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6370 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6372 /* If neighbor has soft reconfiguration inbound flag.
6373 Use Adj-RIB-In database. */
6374 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
6375 bgp_soft_reconfig_in (peer
, afi
, safi
);
6378 /* If neighbor has route refresh capability, send route refresh
6379 message to the peer. */
6380 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6381 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6382 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6384 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6390 /* Display peer uptime.*/
6392 peer_uptime (time_t uptime2
, char *buf
, size_t len
, u_char use_json
, json_object
*json
)
6394 time_t uptime1
, epoch_tbuf
;
6397 /* Check buffer length. */
6398 if (len
< BGP_UPTIME_LEN
)
6402 zlog_warn ("peer_uptime (): buffer shortage %lu", (u_long
)len
);
6403 /* XXX: should return status instead of buf... */
6404 snprintf (buf
, len
, "<error> ");
6409 /* If there is no connection has been done before print `never'. */
6414 json_object_string_add(json
, "peerUptime", "never");
6415 json_object_int_add(json
, "peerUptimeMsec", 0);
6418 snprintf (buf
, len
, "never");
6422 /* Get current time. */
6423 uptime1
= bgp_clock ();
6425 tm
= gmtime (&uptime1
);
6427 /* Making formatted timer strings. */
6428 #define ONE_DAY_SECOND 60*60*24
6429 #define ONE_WEEK_SECOND ONE_DAY_SECOND*7
6430 #define ONE_YEAR_SECOND ONE_DAY_SECOND*365
6432 if (uptime1
< ONE_DAY_SECOND
)
6433 snprintf (buf
, len
, "%02d:%02d:%02d",
6434 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6435 else if (uptime1
< ONE_WEEK_SECOND
)
6436 snprintf (buf
, len
, "%dd%02dh%02dm",
6437 tm
->tm_yday
, tm
->tm_hour
, tm
->tm_min
);
6438 else if (uptime1
< ONE_YEAR_SECOND
)
6439 snprintf (buf
, len
, "%02dw%dd%02dh",
6440 tm
->tm_yday
/7, tm
->tm_yday
- ((tm
->tm_yday
/7) * 7), tm
->tm_hour
);
6442 snprintf (buf
, len
, "%02dy%02dw%dd",
6443 tm
->tm_year
- 70, tm
->tm_yday
/7,
6444 tm
->tm_yday
- ((tm
->tm_yday
/7) * 7));
6448 epoch_tbuf
= time(NULL
) - uptime1
;
6449 json_object_string_add(json
, "peerUptime", buf
);
6450 json_object_int_add(json
, "peerUptimeMsec", uptime1
* 1000);
6451 json_object_int_add(json
, "peerUptimeEstablishedEpoch", epoch_tbuf
);
6458 afi_header_vty_out (struct vty
*vty
, afi_t afi
, safi_t safi
,
6459 int *write
, const char *format
, ...)
6465 bgp_config_write_family_header (vty
, afi
, safi
, write
);
6467 if (vty_shell (vty
))
6469 va_start (args
, format
);
6470 vprintf (format
, args
);
6475 va_start (args
, format
);
6476 len
= vsnprintf (buf
, sizeof(buf
), format
, args
);
6479 buffer_put (vty
->obuf
, (u_char
*) buf
, len
);
6484 bgp_config_write_filter (struct vty
*vty
, struct peer
*peer
,
6485 afi_t afi
, safi_t safi
, int *write
)
6487 struct bgp_filter
*filter
;
6488 struct bgp_filter
*gfilter
= NULL
;
6491 int out
= FILTER_OUT
;
6494 filter
= &peer
->filter
[afi
][safi
];
6496 if (peer_group_active(peer
))
6497 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
6499 /* distribute-list. */
6500 if (filter
->dlist
[in
].name
)
6501 if (! gfilter
|| ! gfilter
->dlist
[in
].name
6502 || strcmp (filter
->dlist
[in
].name
, gfilter
->dlist
[in
].name
) != 0)
6504 afi_header_vty_out (vty
, afi
, safi
, write
,
6505 " neighbor %s distribute-list %s in%s",
6506 addr
, filter
->dlist
[in
].name
, VTYNL
);
6509 if (filter
->dlist
[out
].name
&& ! gfilter
)
6511 afi_header_vty_out (vty
, afi
, safi
, write
,
6512 " neighbor %s distribute-list %s out%s",
6513 addr
, filter
->dlist
[out
].name
, VTYNL
);
6517 if (filter
->plist
[in
].name
)
6518 if (! gfilter
|| ! gfilter
->plist
[in
].name
6519 || strcmp (filter
->plist
[in
].name
, gfilter
->plist
[in
].name
) != 0)
6521 afi_header_vty_out (vty
, afi
, safi
, write
,
6522 " neighbor %s prefix-list %s in%s",
6523 addr
, filter
->plist
[in
].name
, VTYNL
);
6526 if (filter
->plist
[out
].name
&& ! gfilter
)
6528 afi_header_vty_out (vty
, afi
, safi
, write
,
6529 " neighbor %s prefix-list %s out%s",
6530 addr
, filter
->plist
[out
].name
, VTYNL
);
6534 if (filter
->map
[RMAP_IN
].name
)
6535 if (! gfilter
|| ! gfilter
->map
[RMAP_IN
].name
6536 || strcmp (filter
->map
[RMAP_IN
].name
, gfilter
->map
[RMAP_IN
].name
) != 0)
6538 afi_header_vty_out (vty
, afi
, safi
, write
,
6539 " neighbor %s route-map %s in%s",
6540 addr
, filter
->map
[RMAP_IN
].name
, VTYNL
);
6543 if (filter
->map
[RMAP_OUT
].name
)
6544 if (! gfilter
|| ! gfilter
->map
[RMAP_OUT
].name
6545 || strcmp (filter
->map
[RMAP_OUT
].name
, gfilter
->map
[RMAP_OUT
].name
) != 0)
6547 afi_header_vty_out (vty
, afi
, safi
, write
,
6548 " neighbor %s route-map %s out%s",
6549 addr
, filter
->map
[RMAP_OUT
].name
, VTYNL
);
6552 /* unsuppress-map */
6553 if (filter
->usmap
.name
&& ! gfilter
)
6555 afi_header_vty_out (vty
, afi
, safi
, write
,
6556 " neighbor %s unsuppress-map %s%s",
6557 addr
, filter
->usmap
.name
, VTYNL
);
6561 if (filter
->aslist
[in
].name
)
6562 if (! gfilter
|| ! gfilter
->aslist
[in
].name
6563 || strcmp (filter
->aslist
[in
].name
, gfilter
->aslist
[in
].name
) != 0)
6565 afi_header_vty_out (vty
, afi
, safi
, write
,
6566 " neighbor %s filter-list %s in%s",
6567 addr
, filter
->aslist
[in
].name
, VTYNL
);
6570 if (filter
->aslist
[out
].name
&& ! gfilter
)
6572 afi_header_vty_out (vty
, afi
, safi
, write
,
6573 " neighbor %s filter-list %s out%s",
6574 addr
, filter
->aslist
[out
].name
, VTYNL
);
6578 /* BGP peer configuration display function. */
6580 bgp_config_write_peer_global (struct vty
*vty
, struct bgp
*bgp
,
6583 struct peer
*g_peer
= NULL
;
6584 char buf
[SU_ADDRSTRLEN
];
6586 int if_pg_printed
= FALSE
;
6587 int if_ras_printed
= FALSE
;
6589 /* Skip dynamic neighbors. */
6590 if (peer_dynamic_neighbor (peer
))
6594 addr
= peer
->conf_if
;
6598 /************************************
6599 ****** Global to the neighbor ******
6600 ************************************/
6603 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6604 vty_out (vty
, " neighbor %s interface v6only", addr
);
6606 vty_out (vty
, " neighbor %s interface", addr
);
6608 if (peer_group_active (peer
))
6610 vty_out (vty
, " peer-group %s", peer
->group
->name
);
6611 if_pg_printed
= TRUE
;
6613 else if (peer
->as_type
== AS_SPECIFIED
)
6615 vty_out (vty
, " remote-as %u", peer
->as
);
6616 if_ras_printed
= TRUE
;
6618 else if (peer
->as_type
== AS_INTERNAL
)
6620 vty_out (vty
, " remote-as internal");
6621 if_ras_printed
= TRUE
;
6623 else if (peer
->as_type
== AS_EXTERNAL
)
6625 vty_out (vty
, " remote-as external");
6626 if_ras_printed
= TRUE
;
6629 vty_out (vty
, VTYNL
);
6632 /* remote-as and peer-group */
6633 /* peer is a member of a peer-group */
6634 if (peer_group_active (peer
))
6636 g_peer
= peer
->group
->conf
;
6638 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
)
6640 if (peer
->as_type
== AS_SPECIFIED
)
6642 vty_outln (vty
, " neighbor %s remote-as %u", addr
,peer
->as
);
6644 else if (peer
->as_type
== AS_INTERNAL
)
6646 vty_outln (vty
, " neighbor %s remote-as internal", addr
);
6648 else if (peer
->as_type
== AS_EXTERNAL
)
6650 vty_outln (vty
, " neighbor %s remote-as external", addr
);
6654 /* For swpX peers we displayed the peer-group
6655 * via 'neighbor swpX interface peer-group WORD' */
6657 vty_outln (vty
, " neighbor %s peer-group %s", addr
,
6661 /* peer is NOT a member of a peer-group */
6664 /* peer is a peer-group, declare the peer-group */
6665 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6667 vty_outln (vty
, " neighbor %s peer-group",addr
);
6670 if (!if_ras_printed
)
6672 if (peer
->as_type
== AS_SPECIFIED
)
6674 vty_outln (vty
, " neighbor %s remote-as %u", addr
,peer
->as
);
6676 else if (peer
->as_type
== AS_INTERNAL
)
6678 vty_outln (vty
, " neighbor %s remote-as internal", addr
);
6680 else if (peer
->as_type
== AS_EXTERNAL
)
6682 vty_outln (vty
, " neighbor %s remote-as external", addr
);
6688 if (peer
->change_local_as
)
6690 if (! peer_group_active (peer
)
6691 || peer
->change_local_as
!= g_peer
->change_local_as
6692 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) !=
6693 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6694 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) !=
6695 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)))
6697 vty_outln (vty
, " neighbor %s local-as %u%s%s", addr
,
6698 peer
->change_local_as
,
6699 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) ?
6701 CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) ? " replace-as" : "");
6708 vty_outln (vty
, " neighbor %s description %s", addr
,peer
->desc
);
6712 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6714 if (! peer_group_active (peer
) ||
6715 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_SHUTDOWN
) ||
6716 peer
->tx_shutdown_message
)
6718 if (peer
->tx_shutdown_message
)
6719 vty_outln (vty
, " neighbor %s shutdown message %s", addr
,
6720 peer
->tx_shutdown_message
);
6722 vty_outln (vty
, " neighbor %s shutdown", addr
);
6729 if (! peer_group_active (peer
) || ! g_peer
->bfd_info
)
6731 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6738 if (!peer_group_active (peer
)
6739 || ! g_peer
->password
6740 || strcmp (peer
->password
, g_peer
->password
) != 0)
6742 vty_outln (vty
, " neighbor %s password %s", addr
,peer
->password
);
6747 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
))
6749 if (!peer_group_active (peer
))
6751 vty_outln (vty
, " neighbor %s solo", addr
);
6756 if (peer
->port
!= BGP_PORT_DEFAULT
)
6758 vty_outln (vty
, " neighbor %s port %d", addr
,peer
->port
);
6761 /* Local interface name */
6764 vty_outln (vty
, " neighbor %s interface %s", addr
,peer
->ifname
);
6768 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_PASSIVE
))
6770 if (! peer_group_active (peer
) ||
6771 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_PASSIVE
))
6773 vty_outln (vty
, " neighbor %s passive", addr
);
6778 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1 &&
6779 !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
))
6781 if (! peer_group_active (peer
) || g_peer
->ttl
!= peer
->ttl
)
6783 vty_outln (vty
, " neighbor %s ebgp-multihop %d", addr
,peer
->ttl
);
6787 /* ttl-security hops */
6788 if (peer
->gtsm_hops
!= 0)
6790 if (! peer_group_active (peer
) || g_peer
->gtsm_hops
!= peer
->gtsm_hops
)
6792 vty_outln (vty
, " neighbor %s ttl-security hops %d", addr
,
6797 /* disable-connected-check */
6798 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6800 if (! peer_group_active (peer
) ||
6801 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6803 vty_outln (vty
, " neighbor %s disable-connected-check", addr
);
6808 if (peer
->update_if
)
6810 if (! peer_group_active (peer
) || ! g_peer
->update_if
6811 || strcmp (g_peer
->update_if
, peer
->update_if
) != 0)
6813 vty_outln (vty
, " neighbor %s update-source %s", addr
,
6817 if (peer
->update_source
)
6819 if (! peer_group_active (peer
) || ! g_peer
->update_source
6820 || sockunion_cmp (g_peer
->update_source
,
6821 peer
->update_source
) != 0)
6823 vty_outln (vty
, " neighbor %s update-source %s", addr
,
6824 sockunion2str(peer
->update_source
, buf
, SU_ADDRSTRLEN
));
6828 /* advertisement-interval */
6829 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
) &&
6830 ((! peer_group_active (peer
) && peer
->v_routeadv
!= BGP_DEFAULT_EBGP_ROUTEADV
) ||
6831 (peer_group_active (peer
) && peer
->v_routeadv
!= g_peer
->v_routeadv
)))
6833 vty_outln (vty
, " neighbor %s advertisement-interval %u",
6834 addr
, peer
->v_routeadv
);
6838 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
) &&
6839 ((! peer_group_active (peer
) && (peer
->keepalive
!= BGP_DEFAULT_KEEPALIVE
|| peer
->holdtime
!= BGP_DEFAULT_HOLDTIME
)) ||
6840 (peer_group_active (peer
) && (peer
->keepalive
!= g_peer
->keepalive
|| peer
->holdtime
!= g_peer
->holdtime
))))
6842 vty_outln (vty
, " neighbor %s timers %u %u", addr
,
6843 peer
->keepalive
, peer
->holdtime
);
6846 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_CONNECT
) &&
6847 ((! peer_group_active (peer
) && peer
->connect
!= BGP_DEFAULT_CONNECT_RETRY
) ||
6848 (peer_group_active (peer
) && peer
->connect
!= g_peer
->connect
)))
6851 vty_outln (vty
, " neighbor %s timers connect %u", addr
,
6855 /* capability dynamic */
6856 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6858 if (! peer_group_active (peer
) ||
6859 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6861 vty_outln (vty
, " neighbor %s capability dynamic",addr
);
6865 /* capability extended-nexthop */
6866 if (peer
->ifp
&& !CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6868 if (! peer_group_active (peer
) ||
6869 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6871 vty_outln (vty
, " no neighbor %s capability extended-nexthop",
6876 if (!peer
->ifp
&& CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6878 if (! peer_group_active (peer
) ||
6879 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6881 vty_outln (vty
, " neighbor %s capability extended-nexthop",addr
);
6885 /* dont-capability-negotiation */
6886 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6888 if (! peer_group_active (peer
) ||
6889 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6891 vty_outln (vty
, " neighbor %s dont-capability-negotiate",addr
);
6895 /* override-capability */
6896 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6898 if (! peer_group_active (peer
) ||
6899 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6901 vty_outln (vty
, " neighbor %s override-capability",addr
);
6905 /* strict-capability-match */
6906 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6908 if (! peer_group_active (peer
) ||
6909 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6911 vty_outln (vty
, " neighbor %s strict-capability-match",addr
);
6916 /* BGP peer configuration display function. */
6918 bgp_config_write_peer_af (struct vty
*vty
, struct bgp
*bgp
,
6919 struct peer
*peer
, afi_t afi
, safi_t safi
,
6922 struct peer
*g_peer
= NULL
;
6925 /* Skip dynamic neighbors. */
6926 if (peer_dynamic_neighbor (peer
))
6930 addr
= peer
->conf_if
;
6934 /************************************
6935 ****** Per AF to the neighbor ******
6936 ************************************/
6937 if (peer_group_active (peer
))
6939 g_peer
= peer
->group
->conf
;
6941 /* If the peer-group is active but peer is not, print a 'no activate' */
6942 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
])
6944 afi_header_vty_out (vty
, afi
, safi
, write
,
6945 " no neighbor %s activate%s",
6949 /* If the peer-group is not active but peer is, print an 'activate' */
6950 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
])
6952 afi_header_vty_out (vty
, afi
, safi
, write
,
6953 " neighbor %s activate%s",
6959 if (peer
->afc
[afi
][safi
])
6961 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6963 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6965 afi_header_vty_out(vty
, afi
, safi
, write
,
6966 " neighbor %s activate%s",
6971 afi_header_vty_out (vty
, afi
, safi
, write
,
6972 " neighbor %s activate%s",
6977 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6979 if (!bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6981 afi_header_vty_out (vty
, afi
, safi
, write
,
6982 " no neighbor %s activate%s",
6989 /* addpath TX knobs */
6990 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
6992 afi_header_vty_out (vty
, afi
, safi
, write
,
6993 " neighbor %s addpath-tx-all-paths%s",
6997 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
6999 afi_header_vty_out (vty
, afi
, safi
, write
,
7000 " neighbor %s addpath-tx-bestpath-per-AS%s",
7004 /* ORF capability. */
7005 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) ||
7006 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
7008 afi_header_vty_out (vty
, afi
, safi
, write
,
7009 " neighbor %s capability orf prefix-list",
7012 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) &&
7013 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
7014 vty_out (vty
, " both");
7015 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
))
7016 vty_out (vty
, " send");
7018 vty_out (vty
, " receive");
7019 vty_out (vty
, VTYNL
);
7022 /* Route reflector client. */
7023 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REFLECTOR_CLIENT
))
7025 afi_header_vty_out (vty
, afi
, safi
, write
,
7026 " neighbor %s route-reflector-client%s",
7030 /* next-hop-self force */
7031 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
7033 afi_header_vty_out (vty
, afi
, safi
, write
,
7034 " neighbor %s next-hop-self force%s",
7039 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
))
7041 afi_header_vty_out (vty
, afi
, safi
, write
,
7042 " neighbor %s next-hop-self%s",
7046 /* remove-private-AS */
7047 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
))
7049 afi_header_vty_out (vty
, afi
, safi
, write
,
7050 " neighbor %s remove-private-AS all replace-AS%s",
7054 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
))
7056 afi_header_vty_out (vty
, afi
, safi
, write
,
7057 " neighbor %s remove-private-AS replace-AS%s",
7061 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL
))
7063 afi_header_vty_out (vty
, afi
, safi
, write
,
7064 " neighbor %s remove-private-AS all%s",
7068 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS
))
7070 afi_header_vty_out (vty
, afi
, safi
, write
,
7071 " neighbor %s remove-private-AS%s",
7076 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
))
7078 afi_header_vty_out (vty
, afi
, safi
, write
,
7079 " neighbor %s as-override%s",
7083 /* send-community print. */
7084 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7086 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)
7087 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)
7088 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7090 afi_header_vty_out (vty
, afi
, safi
, write
,
7091 " neighbor %s send-community all%s",
7094 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7096 afi_header_vty_out (vty
, afi
, safi
, write
,
7097 " neighbor %s send-community large%s",
7100 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
))
7102 afi_header_vty_out (vty
, afi
, safi
, write
,
7103 " neighbor %s send-community extended%s",
7106 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
))
7108 afi_header_vty_out (vty
, afi
, safi
, write
,
7109 " neighbor %s send-community%s",
7115 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7116 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)) &&
7117 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7118 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)) &&
7119 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7120 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7122 afi_header_vty_out (vty
, afi
, safi
, write
,
7123 " no neighbor %s send-community all%s",
7128 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7129 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7131 afi_header_vty_out (vty
, afi
, safi
, write
,
7132 " no neighbor %s send-community large%s",
7136 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7137 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)))
7139 afi_header_vty_out (vty
, afi
, safi
, write
,
7140 " no neighbor %s send-community extended%s",
7144 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7145 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)))
7147 afi_header_vty_out (vty
, afi
, safi
, write
,
7148 " no neighbor %s send-community%s",
7154 /* Default information */
7155 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
) ||
7157 ((peer
->default_rmap
[afi
][safi
].name
&& !g_peer
->default_rmap
[afi
][safi
].name
) ||
7158 (!peer
->default_rmap
[afi
][safi
].name
&& g_peer
->default_rmap
[afi
][safi
].name
) ||
7159 (peer
->default_rmap
[afi
][safi
].name
&&
7160 strcmp(peer
->default_rmap
[afi
][safi
].name
, g_peer
->default_rmap
[afi
][safi
].name
)))))
7162 afi_header_vty_out (vty
, afi
, safi
, write
,
7163 " neighbor %s default-originate", addr
);
7164 if (peer
->default_rmap
[afi
][safi
].name
)
7165 vty_out (vty
, " route-map %s", peer
->default_rmap
[afi
][safi
].name
);
7166 vty_out (vty
, VTYNL
);
7169 /* Soft reconfiguration inbound. */
7170 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
))
7172 afi_header_vty_out (vty
, afi
, safi
, write
,
7173 " neighbor %s soft-reconfiguration inbound%s",
7177 /* maximum-prefix. */
7178 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
7179 if (! peer_group_active(peer
)
7180 || g_peer
->pmax
[afi
][safi
] != peer
->pmax
[afi
][safi
]
7181 || g_peer
->pmax_threshold
[afi
][safi
] != peer
->pmax_threshold
[afi
][safi
]
7182 || CHECK_FLAG (g_peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
)
7183 != CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7185 afi_header_vty_out (vty
, afi
, safi
, write
,
7186 " neighbor %s maximum-prefix %lu",
7187 addr
, peer
->pmax
[afi
][safi
]);
7188 if (peer
->pmax_threshold
[afi
][safi
] != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
7189 vty_out (vty
, " %u", peer
->pmax_threshold
[afi
][safi
]);
7190 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7191 vty_out (vty
, " warning-only");
7192 if (peer
->pmax_restart
[afi
][safi
])
7193 vty_out (vty
, " restart %u", peer
->pmax_restart
[afi
][safi
]);
7194 vty_out (vty
, VTYNL
);
7197 /* Route server client. */
7198 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_RSERVER_CLIENT
))
7200 afi_header_vty_out (vty
, afi
, safi
, write
,
7201 " neighbor %s route-server-client%s",
7205 /* Nexthop-local unchanged. */
7206 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
))
7208 afi_header_vty_out (vty
, afi
, safi
, write
,
7209 " neighbor %s nexthop-local unchanged%s",
7213 /* allowas-in <1-10> */
7214 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
))
7216 if (! peer_group_active (peer
)
7217 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)
7218 || peer
->allowas_in
[afi
][safi
] != g_peer
->allowas_in
[afi
][safi
])
7220 if (peer
->allowas_in
[afi
][safi
] == 3)
7222 afi_header_vty_out (vty
, afi
, safi
, write
,
7223 " neighbor %s allowas-in%s",
7228 afi_header_vty_out (vty
, afi
, safi
, write
,
7229 " neighbor %s allowas-in %d%s",
7230 addr
, peer
->allowas_in
[afi
][safi
], VTYNL
);
7235 /* allowas-in origin */
7236 else if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7238 if (! peer_group_active (peer
)
7239 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7241 afi_header_vty_out (vty
, afi
, safi
, write
,
7242 " neighbor %s allowas-in origin%s",
7248 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7249 if (! peer_group_active (peer
)
7250 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_WEIGHT
)
7251 || peer
->weight
[afi
][safi
] != g_peer
->weight
[afi
][safi
])
7253 if (peer
->weight
[afi
][safi
])
7255 afi_header_vty_out (vty
, afi
, safi
, write
,
7256 " neighbor %s weight %lu%s",
7257 addr
, peer
->weight
[afi
][safi
], VTYNL
);
7262 bgp_config_write_filter (vty
, peer
, afi
, safi
, write
);
7264 /* atribute-unchanged. */
7265 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_AS_PATH_UNCHANGED
)
7266 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_NEXTHOP_UNCHANGED
)
7267 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MED_UNCHANGED
))
7269 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7270 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
)
7271 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
))
7273 afi_header_vty_out (vty
, afi
, safi
, write
,
7274 " neighbor %s attribute-unchanged%s",
7279 afi_header_vty_out (vty
, afi
, safi
, write
,
7280 " neighbor %s attribute-unchanged%s%s%s%s", addr
,
7281 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
) ?
7283 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
) ?
7285 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
) ?
7286 " med" : "", VTYNL
);
7291 /* Display "address-family" configuration header. */
7293 bgp_config_write_family_header (struct vty
*vty
, afi_t afi
, safi_t safi
,
7299 vty_out (vty
, " !%s address-family ", VTYNL
);
7303 if (safi
== SAFI_UNICAST
)
7304 vty_out (vty
, "ipv4 unicast");
7305 else if (safi
== SAFI_LABELED_UNICAST
)
7306 vty_out (vty
, "ipv4 labeled-unicast");
7307 else if (safi
== SAFI_MULTICAST
)
7308 vty_out (vty
, "ipv4 multicast");
7309 else if (safi
== SAFI_MPLS_VPN
)
7310 vty_out (vty
, "ipv4 vpn");
7311 else if (safi
== SAFI_ENCAP
)
7312 vty_out (vty
, "ipv4 encap");
7314 else if (afi
== AFI_IP6
)
7316 if (safi
== SAFI_UNICAST
)
7317 vty_out (vty
, "ipv6 unicast");
7318 else if (safi
== SAFI_LABELED_UNICAST
)
7319 vty_out (vty
, "ipv6 labeled-unicast");
7320 else if (safi
== SAFI_MULTICAST
)
7321 vty_out (vty
, "ipv6 multicast");
7322 else if (safi
== SAFI_MPLS_VPN
)
7323 vty_out (vty
, "ipv6 vpn");
7324 else if (safi
== SAFI_ENCAP
)
7325 vty_out (vty
, "ipv6 encap");
7327 else if (afi
== AFI_L2VPN
)
7329 if (safi
== SAFI_EVPN
)
7330 vty_out (vty
, "l2vpn evpn");
7332 vty_out (vty
, VTYNL
);
7337 /* Address family based peer configuration display. */
7339 bgp_config_write_family (struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7344 struct peer_group
*group
;
7345 struct listnode
*node
, *nnode
;
7347 bgp_config_write_distance (vty
, bgp
, afi
, safi
, &write
);
7349 bgp_config_write_network (vty
, bgp
, afi
, safi
, &write
);
7351 bgp_config_write_redistribute (vty
, bgp
, afi
, safi
, &write
);
7353 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7354 bgp_config_write_peer_af (vty
, bgp
, group
->conf
, afi
, safi
, &write
);
7356 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7358 /* Skip dynamic neighbors. */
7359 if (peer_dynamic_neighbor (peer
))
7362 /* Do not display doppelganger peers */
7363 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7364 bgp_config_write_peer_af (vty
, bgp
, peer
, afi
, safi
, &write
);
7367 bgp_config_write_maxpaths (vty
, bgp
, afi
, safi
, &write
);
7368 bgp_config_write_table_map (vty
, bgp
, afi
, safi
, &write
);
7371 vty_outln (vty
, " exit-address-family");
7377 bgp_config_write (struct vty
*vty
)
7381 struct peer_group
*group
;
7383 struct listnode
*node
, *nnode
;
7384 struct listnode
*mnode
, *mnnode
;
7386 /* BGP Multiple instance. */
7387 if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7389 vty_outln (vty
, "no bgp multiple-instance");
7393 /* BGP Config type. */
7394 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7396 vty_outln (vty
, "bgp config-type cisco");
7400 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7401 vty_outln (vty
, "bgp route-map delay-timer %u",bm
->rmap_update_timer
);
7403 /* BGP configuration. */
7404 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7407 vty_outln (vty
, "!");
7409 /* Router bgp ASN */
7410 vty_out (vty
, "router bgp %u", bgp
->as
);
7412 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7415 vty_out (vty
, " %s %s",
7416 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
) ?
7417 "view" : "vrf", bgp
->name
);
7419 vty_out (vty
, VTYNL
);
7421 /* No Synchronization */
7422 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7423 vty_outln (vty
, " no synchronization");
7425 /* BGP fast-external-failover. */
7426 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7427 vty_outln (vty
, " no bgp fast-external-failover");
7429 /* BGP router ID. */
7430 if (bgp
->router_id_static
.s_addr
!= 0)
7431 vty_outln (vty
, " bgp router-id %s",
7432 inet_ntoa(bgp
->router_id_static
));
7434 /* BGP log-neighbor-changes. */
7435 if (!!bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7436 != DFLT_BGP_LOG_NEIGHBOR_CHANGES
)
7437 vty_outln (vty
, " %sbgp log-neighbor-changes",
7438 bgp_flag_check(bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
) ? "" : "no ");
7440 /* BGP configuration. */
7441 if (bgp_flag_check (bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7442 vty_outln (vty
, " bgp always-compare-med");
7444 /* BGP default ipv4-unicast. */
7445 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7446 vty_outln (vty
, " no bgp default ipv4-unicast");
7448 /* BGP default local-preference. */
7449 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7450 vty_outln (vty
, " bgp default local-preference %u",
7451 bgp
->default_local_pref
);
7453 /* BGP default show-hostname */
7454 if (!!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7455 != DFLT_BGP_SHOW_HOSTNAME
)
7456 vty_outln (vty
, " %sbgp default show-hostname",
7457 bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
) ? "" : "no ");
7459 /* BGP default subgroup-pkt-queue-max. */
7460 if (bgp
->default_subgroup_pkt_queue_max
!= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7461 vty_outln (vty
, " bgp default subgroup-pkt-queue-max %u",
7462 bgp
->default_subgroup_pkt_queue_max
);
7464 /* BGP client-to-client reflection. */
7465 if (bgp_flag_check (bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7466 vty_outln (vty
, " no bgp client-to-client reflection");
7468 /* BGP cluster ID. */
7469 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7470 vty_outln (vty
, " bgp cluster-id %s",inet_ntoa(bgp
->cluster_id
));
7472 /* Disable ebgp connected nexthop check */
7473 if (bgp_flag_check (bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7474 vty_outln (vty
, " bgp disable-ebgp-connected-route-check");
7476 /* Confederation identifier*/
7477 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7478 vty_outln (vty
, " bgp confederation identifier %i",bgp
->confed_id
);
7480 /* Confederation peer */
7481 if (bgp
->confed_peers_cnt
> 0)
7485 vty_out (vty
, " bgp confederation peers");
7487 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7488 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7490 vty_out (vty
, VTYNL
);
7493 /* BGP enforce-first-as. */
7494 if (bgp_flag_check (bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
7495 vty_outln (vty
, " bgp enforce-first-as");
7497 /* BGP deterministic-med. */
7498 if (!!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7499 != DFLT_BGP_DETERMINISTIC_MED
)
7500 vty_outln (vty
, " %sbgp deterministic-med",
7501 bgp_flag_check(bgp
, BGP_FLAG_DETERMINISTIC_MED
) ? "" : "no ");
7503 /* BGP update-delay. */
7504 bgp_config_write_update_delay (vty
, bgp
);
7506 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
7508 vty_out (vty
, " bgp max-med on-startup %u", bgp
->v_maxmed_onstartup
);
7509 if (bgp
->maxmed_onstartup_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7510 vty_out (vty
, " %u", bgp
->maxmed_onstartup_value
);
7511 vty_out (vty
, VTYNL
);
7513 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
)
7515 vty_out (vty
, " bgp max-med administrative");
7516 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7517 vty_out (vty
, " %u", bgp
->maxmed_admin_value
);
7518 vty_out (vty
, VTYNL
);
7522 bgp_config_write_wpkt_quanta (vty
, bgp
);
7525 bgp_config_write_coalesce_time(vty
, bgp
);
7527 /* BGP graceful-restart. */
7528 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7529 vty_outln (vty
, " bgp graceful-restart stalepath-time %u",
7530 bgp
->stalepath_time
);
7531 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7532 vty_outln (vty
, " bgp graceful-restart restart-time %u",
7534 if (bgp_flag_check (bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7535 vty_outln (vty
, " bgp graceful-restart");
7537 /* BGP graceful-restart Preserve State F bit. */
7538 if (bgp_flag_check (bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
7539 vty_outln (vty
, " bgp graceful-restart preserve-fw-state");
7541 /* BGP bestpath method. */
7542 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_IGNORE
))
7543 vty_outln (vty
, " bgp bestpath as-path ignore");
7544 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_CONFED
))
7545 vty_outln (vty
, " bgp bestpath as-path confed");
7547 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
))
7549 if (bgp_flag_check (bgp
, BGP_FLAG_MULTIPATH_RELAX_AS_SET
))
7552 " bgp bestpath as-path multipath-relax as-set");
7556 vty_outln (vty
, " bgp bestpath as-path multipath-relax");
7560 if (bgp_flag_check (bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7561 vty_outln (vty
," bgp route-reflector allow-outbound-policy");
7563 if (bgp_flag_check (bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7564 vty_outln (vty
, " bgp bestpath compare-routerid");
7565 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
)
7566 || bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7568 vty_out (vty
, " bgp bestpath med");
7569 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
))
7570 vty_out (vty
, " confed");
7571 if (bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7572 vty_out (vty
, " missing-as-worst");
7573 vty_out (vty
, VTYNL
);
7576 /* BGP network import check. */
7577 if (!!bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
)
7578 != DFLT_BGP_IMPORT_CHECK
)
7579 vty_outln (vty
, " %sbgp network import-check",
7580 bgp_flag_check(bgp
, BGP_FLAG_IMPORT_CHECK
) ? "" : "no ");
7582 /* BGP flag dampening. */
7583 if (CHECK_FLAG (bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7584 BGP_CONFIG_DAMPENING
))
7585 bgp_config_write_damp (vty
);
7587 /* BGP timers configuration. */
7588 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7589 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7590 vty_outln (vty
, " timers bgp %u %u", bgp
->default_keepalive
,
7591 bgp
->default_holdtime
);
7594 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7596 bgp_config_write_peer_global (vty
, bgp
, group
->conf
);
7599 /* Normal neighbor configuration. */
7600 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7602 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7603 bgp_config_write_peer_global (vty
, bgp
, peer
);
7606 /* listen range and limit for dynamic BGP neighbors */
7607 bgp_config_write_listen (vty
, bgp
);
7609 /* No auto-summary */
7610 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7611 vty_outln (vty
, " no auto-summary");
7613 /* IPv4 unicast configuration. */
7614 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7616 /* IPv4 multicast configuration. */
7617 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7619 /* IPv4 labeled-unicast configuration. */
7620 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_LABELED_UNICAST
);
7622 /* IPv4 VPN configuration. */
7623 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7625 /* ENCAPv4 configuration. */
7626 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7628 /* IPv6 unicast configuration. */
7629 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7631 /* IPv6 multicast configuration. */
7632 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7634 /* IPv6 labeled-unicast configuration. */
7635 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_LABELED_UNICAST
);
7637 /* IPv6 VPN configuration. */
7638 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7640 /* ENCAPv6 configuration. */
7641 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7643 /* EVPN configuration. */
7644 write
+= bgp_config_write_family (vty
, bgp
, AFI_L2VPN
, SAFI_EVPN
);
7647 write
+= bgp_rfapi_cfg_write(vty
, bgp
);
7656 bgp_master_init (struct thread_master
*master
)
7660 memset (&bgp_master
, 0, sizeof (struct bgp_master
));
7663 bm
->bgp
= list_new ();
7664 bm
->listen_sockets
= list_new ();
7665 bm
->port
= BGP_PORT_DEFAULT
;
7666 bm
->master
= master
;
7667 bm
->start_time
= bgp_clock ();
7668 bm
->t_rmap_update
= NULL
;
7669 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7671 bgp_process_queue_init();
7673 /* Enable multiple instances by default. */
7674 bgp_option_set (BGP_OPT_MULTIPLE_INSTANCE
);
7676 QOBJ_REG (bm
, bgp_master
);
7680 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7681 * instance delete (non-default only) or BGP exit.
7684 bgp_if_finish (struct bgp
*bgp
)
7686 struct listnode
*ifnode
, *ifnnode
;
7687 struct interface
*ifp
;
7689 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7692 for (ALL_LIST_ELEMENTS (vrf_iflist(bgp
->vrf_id
), ifnode
, ifnnode
, ifp
))
7694 struct listnode
*c_node
, *c_nnode
;
7695 struct connected
*c
;
7697 for (ALL_LIST_ELEMENTS (ifp
->connected
, c_node
, c_nnode
, c
))
7698 bgp_connected_delete (bgp
, c
);
7702 extern void bgp_snmp_init (void);
7705 bgp_viewvrf_autocomplete (vector comps
, struct cmd_token
*token
)
7707 struct vrf
*vrf
= NULL
;
7708 struct listnode
*next
;
7711 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
7713 if (vrf
->vrf_id
!= VRF_DEFAULT
)
7714 vector_set (comps
, XSTRDUP (MTYPE_COMPLETION
, vrf
->name
));
7717 for (ALL_LIST_ELEMENTS_RO (bm
->bgp
, next
, bgp
))
7719 if (bgp
->inst_type
!= BGP_INSTANCE_TYPE_VIEW
)
7722 vector_set (comps
, XSTRDUP (MTYPE_COMPLETION
, bgp
->name
));
7726 static const struct cmd_variable_handler bgp_viewvrf_var_handlers
[] = {
7728 .tokenname
= "VIEWVRFNAME",
7729 .completions
= bgp_viewvrf_autocomplete
7740 /* allocates some vital data structures used by peer commands in vty_init */
7743 bgp_zebra_init(bm
->master
);
7746 vnc_zebra_init (bm
->master
);
7749 /* BGP VTY commands installation. */
7757 bgp_route_map_init ();
7758 bgp_scan_vty_init();
7759 bgp_mplsvpn_init ();
7763 bgp_ethernetvpn_init ();
7765 /* Access list initialize. */
7766 access_list_init ();
7767 access_list_add_hook (peer_distribute_update
);
7768 access_list_delete_hook (peer_distribute_update
);
7770 /* Filter list initialize. */
7772 as_list_add_hook (peer_aslist_add
);
7773 as_list_delete_hook (peer_aslist_del
);
7775 /* Prefix list initialize.*/
7776 prefix_list_init ();
7777 prefix_list_add_hook (peer_prefix_list_update
);
7778 prefix_list_delete_hook (peer_prefix_list_update
);
7780 /* Community list initialize. */
7781 bgp_clist
= community_list_init ();
7786 cmd_variable_handler_register (bgp_viewvrf_var_handlers
);
7790 bgp_terminate (void)
7794 struct listnode
*node
, *nnode
;
7795 struct listnode
*mnode
, *mnnode
;
7799 /* Close the listener sockets first as this prevents peers from attempting
7800 * to reconnect on receiving the peer unconfig message. In the presence
7801 * of a large number of peers this will ensure that no peer is left with
7802 * a dangling connection
7804 /* reverse bgp_master_init */
7806 if (bm
->listen_sockets
)
7807 list_free(bm
->listen_sockets
);
7808 bm
->listen_sockets
= NULL
;
7810 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7811 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7812 if (peer
->status
== Established
||
7813 peer
->status
== OpenSent
||
7814 peer
->status
== OpenConfirm
)
7815 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
7816 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7818 if (bm
->process_main_queue
)
7820 work_queue_free (bm
->process_main_queue
);
7821 bm
->process_main_queue
= NULL
;
7824 if (bm
->t_rmap_update
)
7825 BGP_TIMER_OFF(bm
->t_rmap_update
);