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"
64 #include "bgpd/bgp_encap.h"
66 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
67 #include "bgpd/rfapi/rfapi_backend.h"
69 #include "bgpd/bgp_evpn.h"
70 #include "bgpd/bgp_advertise.h"
71 #include "bgpd/bgp_network.h"
72 #include "bgpd/bgp_vty.h"
73 #include "bgpd/bgp_mpath.h"
74 #include "bgpd/bgp_nht.h"
75 #include "bgpd/bgp_updgrp.h"
76 #include "bgpd/bgp_bfd.h"
77 #include "bgpd/bgp_memory.h"
78 #include "bgpd/bgp_evpn_vty.h"
81 DEFINE_MTYPE_STATIC(BGPD
, PEER_TX_SHUTDOWN_MSG
, "Peer shutdown message (TX)");
82 DEFINE_QOBJ_TYPE(bgp_master
)
84 DEFINE_QOBJ_TYPE(peer
)
86 /* BGP process wide configuration. */
87 static struct bgp_master bgp_master
;
89 /* BGP process wide configuration pointer to export. */
90 struct bgp_master
*bm
;
92 /* BGP community-list. */
93 struct community_list_handler
*bgp_clist
;
95 unsigned int multipath_num
= MULTIPATH_NUM
;
97 static void bgp_if_init (struct bgp
*bgp
);
98 static void bgp_if_finish (struct bgp
*bgp
);
100 extern struct zclient
*zclient
;
103 bgp_session_reset(struct peer
*peer
)
105 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
106 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
107 peer_delete(peer
->doppelganger
);
109 BGP_EVENT_ADD (peer
, BGP_Stop
);
113 * During session reset, we may delete the doppelganger peer, which would
114 * be the next node to the current node. If the session reset was invoked
115 * during walk of peer list, we would end up accessing the freed next
116 * node. This function moves the next node along.
119 bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
124 n
= (nnode
) ? *nnode
: NULL
;
125 npeer
= (n
) ? listgetdata(n
) : NULL
;
127 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
128 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
130 if (peer
->doppelganger
== npeer
)
131 /* nnode and *nnode are confirmed to be non-NULL here */
132 *nnode
= (*nnode
)->next
;
133 peer_delete(peer
->doppelganger
);
136 BGP_EVENT_ADD (peer
, BGP_Stop
);
139 /* BGP global flag manipulation. */
141 bgp_option_set (int flag
)
146 case BGP_OPT_MULTIPLE_INSTANCE
:
147 case BGP_OPT_CONFIG_CISCO
:
148 case BGP_OPT_NO_LISTEN
:
149 SET_FLAG (bm
->options
, flag
);
152 return BGP_ERR_INVALID_FLAG
;
158 bgp_option_unset (int flag
)
162 case BGP_OPT_MULTIPLE_INSTANCE
:
163 if (listcount (bm
->bgp
) > 1)
164 return BGP_ERR_MULTIPLE_INSTANCE_USED
;
167 case BGP_OPT_CONFIG_CISCO
:
168 UNSET_FLAG (bm
->options
, flag
);
171 return BGP_ERR_INVALID_FLAG
;
177 bgp_option_check (int flag
)
179 return CHECK_FLAG (bm
->options
, flag
);
182 /* BGP flag manipulation. */
184 bgp_flag_set (struct bgp
*bgp
, int flag
)
186 SET_FLAG (bgp
->flags
, flag
);
191 bgp_flag_unset (struct bgp
*bgp
, int flag
)
193 UNSET_FLAG (bgp
->flags
, flag
);
198 bgp_flag_check (struct bgp
*bgp
, int flag
)
200 return CHECK_FLAG (bgp
->flags
, flag
);
203 /* Internal function to set BGP structure configureation flag. */
205 bgp_config_set (struct bgp
*bgp
, int config
)
207 SET_FLAG (bgp
->config
, config
);
211 bgp_config_unset (struct bgp
*bgp
, int config
)
213 UNSET_FLAG (bgp
->config
, config
);
217 bgp_config_check (struct bgp
*bgp
, int config
)
219 return CHECK_FLAG (bgp
->config
, config
);
222 /* Set BGP router identifier. */
224 bgp_router_id_set (struct bgp
*bgp
, const struct in_addr
*id
)
227 struct listnode
*node
, *nnode
;
229 if (IPV4_ADDR_SAME (&bgp
->router_id
, id
))
232 IPV4_ADDR_COPY (&bgp
->router_id
, id
);
234 /* Set all peer's local identifier with this value. */
235 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
237 IPV4_ADDR_COPY (&peer
->local_id
, id
);
239 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
241 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
242 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
243 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
250 bgp_router_id_zebra_bump (vrf_id_t vrf_id
, const struct prefix
*router_id
)
252 struct listnode
*node
, *nnode
;
255 if (vrf_id
== VRF_DEFAULT
)
257 /* Router-id change for default VRF has to also update all views. */
258 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
260 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
263 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
264 if (!bgp
->router_id_static
.s_addr
)
265 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
270 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
273 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
275 if (!bgp
->router_id_static
.s_addr
)
276 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
282 bgp_router_id_static_set (struct bgp
*bgp
, struct in_addr id
)
284 bgp
->router_id_static
= id
;
285 bgp_router_id_set (bgp
, id
.s_addr
? &id
: &bgp
->router_id_zebra
);
289 /* BGP's cluster-id control. */
291 bgp_cluster_id_set (struct bgp
*bgp
, struct in_addr
*cluster_id
)
294 struct listnode
*node
, *nnode
;
296 if (bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
)
297 && IPV4_ADDR_SAME (&bgp
->cluster_id
, cluster_id
))
300 IPV4_ADDR_COPY (&bgp
->cluster_id
, cluster_id
);
301 bgp_config_set (bgp
, BGP_CONFIG_CLUSTER_ID
);
303 /* Clear all IBGP peer. */
304 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
306 if (peer
->sort
!= BGP_PEER_IBGP
)
309 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
311 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
312 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
313 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
320 bgp_cluster_id_unset (struct bgp
*bgp
)
323 struct listnode
*node
, *nnode
;
325 if (! bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
))
328 bgp
->cluster_id
.s_addr
= 0;
329 bgp_config_unset (bgp
, BGP_CONFIG_CLUSTER_ID
);
331 /* Clear all IBGP peer. */
332 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
334 if (peer
->sort
!= BGP_PEER_IBGP
)
337 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
339 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
340 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
341 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
347 /* time_t value that is monotonicly increasing
348 * and uneffected by adjustments to system clock
350 time_t bgp_clock (void)
358 /* BGP timer configuration. */
360 bgp_timers_set (struct bgp
*bgp
, u_int32_t keepalive
, u_int32_t holdtime
)
362 bgp
->default_keepalive
= (keepalive
< holdtime
/ 3
363 ? keepalive
: holdtime
/ 3);
364 bgp
->default_holdtime
= holdtime
;
370 bgp_timers_unset (struct bgp
*bgp
)
372 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
373 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
378 /* BGP confederation configuration. */
380 bgp_confederation_id_set (struct bgp
*bgp
, as_t as
)
383 struct listnode
*node
, *nnode
;
387 return BGP_ERR_INVALID_AS
;
389 /* Remember - were we doing confederation before? */
390 already_confed
= bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
);
392 bgp_config_set (bgp
, BGP_CONFIG_CONFEDERATION
);
394 /* If we were doing confederation already, this is just an external
395 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
396 were not doing confederation before, reset all EBGP sessions. */
397 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
399 /* We're looking for peers who's AS is not local or part of our
403 if (peer_sort (peer
) == BGP_PEER_EBGP
)
406 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
408 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
409 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
410 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
413 bgp_session_reset_safe(peer
, &nnode
);
418 /* Not doign confederation before, so reset every non-local
420 if (peer_sort (peer
) != BGP_PEER_IBGP
)
422 /* Reset the local_as to be our EBGP one */
423 if (peer_sort (peer
) == BGP_PEER_EBGP
)
425 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
427 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
428 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
429 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
432 bgp_session_reset_safe(peer
, &nnode
);
440 bgp_confederation_id_unset (struct bgp
*bgp
)
443 struct listnode
*node
, *nnode
;
446 bgp_config_unset (bgp
, BGP_CONFIG_CONFEDERATION
);
448 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
450 /* We're looking for peers who's AS is not local */
451 if (peer_sort (peer
) != BGP_PEER_IBGP
)
453 peer
->local_as
= bgp
->as
;
454 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
456 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
457 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
458 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
462 bgp_session_reset_safe(peer
, &nnode
);
468 /* Is an AS part of the confed or not? */
470 bgp_confederation_peers_check (struct bgp
*bgp
, as_t as
)
477 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
478 if (bgp
->confed_peers
[i
] == as
)
484 /* Add an AS to the confederation set. */
486 bgp_confederation_peers_add (struct bgp
*bgp
, as_t as
)
489 struct listnode
*node
, *nnode
;
492 return BGP_ERR_INVALID_BGP
;
495 return BGP_ERR_INVALID_AS
;
497 if (bgp_confederation_peers_check (bgp
, as
))
500 if (bgp
->confed_peers
)
501 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
503 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
505 bgp
->confed_peers
= XMALLOC (MTYPE_BGP_CONFED_LIST
,
506 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
508 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
509 bgp
->confed_peers_cnt
++;
511 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
513 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
517 peer
->local_as
= bgp
->as
;
518 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
520 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
521 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
522 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
525 bgp_session_reset_safe(peer
, &nnode
);
532 /* Delete an AS from the confederation set. */
534 bgp_confederation_peers_remove (struct bgp
*bgp
, as_t as
)
539 struct listnode
*node
, *nnode
;
544 if (! bgp_confederation_peers_check (bgp
, as
))
547 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
548 if (bgp
->confed_peers
[i
] == as
)
549 for(j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
550 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
552 bgp
->confed_peers_cnt
--;
554 if (bgp
->confed_peers_cnt
== 0)
556 if (bgp
->confed_peers
)
557 XFREE (MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
558 bgp
->confed_peers
= NULL
;
561 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
563 bgp
->confed_peers_cnt
* sizeof (as_t
));
565 /* Now reset any peer who's remote AS has just been removed from the
567 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
569 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
573 peer
->local_as
= bgp
->confed_id
;
574 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
576 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
577 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
578 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
581 bgp_session_reset_safe(peer
, &nnode
);
589 /* Local preference configuration. */
591 bgp_default_local_preference_set (struct bgp
*bgp
, u_int32_t local_pref
)
596 bgp
->default_local_pref
= local_pref
;
602 bgp_default_local_preference_unset (struct bgp
*bgp
)
607 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
612 /* Local preference configuration. */
614 bgp_default_subgroup_pkt_queue_max_set (struct bgp
*bgp
, u_int32_t queue_size
)
619 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
625 bgp_default_subgroup_pkt_queue_max_unset (struct bgp
*bgp
)
629 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
634 /* Listen limit configuration. */
636 bgp_listen_limit_set (struct bgp
*bgp
, int listen_limit
)
641 bgp
->dynamic_neighbors_limit
= listen_limit
;
647 bgp_listen_limit_unset (struct bgp
*bgp
)
652 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
658 bgp_map_afi_safi_iana2int (iana_afi_t pkt_afi
, safi_t pkt_safi
,
659 afi_t
*afi
, safi_t
*safi
)
661 /* Map from IANA values to internal values, return error if
662 * values are unrecognized.
664 *afi
= afi_iana2int (pkt_afi
);
665 *safi
= safi_iana2int (pkt_safi
);
666 if (*afi
== AFI_MAX
|| *safi
== SAFI_MAX
)
673 bgp_map_afi_safi_int2iana (afi_t afi
, safi_t safi
,
674 iana_afi_t
*pkt_afi
, safi_t
*pkt_safi
)
676 /* Map from internal values to IANA values, return error if
677 * internal values are bad (unexpected).
679 if (afi
== AFI_MAX
|| safi
== SAFI_MAX
)
681 *pkt_afi
= afi_int2iana (afi
);
682 *pkt_safi
= safi_int2iana (safi
);
687 peer_af_create (struct peer
*peer
, afi_t afi
, safi_t safi
)
695 afid
= afindex(afi
, safi
);
696 if (afid
>= BGP_AF_MAX
)
699 assert(peer
->peer_af_array
[afid
] == NULL
);
701 /* Allocate new peer af */
702 af
= XCALLOC (MTYPE_BGP_PEER_AF
, sizeof (struct peer_af
));
706 zlog_err("Could not create af structure for peer %s", peer
->host
);
710 peer
->peer_af_array
[afid
] = af
;
720 peer_af_find (struct peer
*peer
, afi_t afi
, safi_t safi
)
727 afid
= afindex(afi
, safi
);
728 if (afid
>= BGP_AF_MAX
)
731 return peer
->peer_af_array
[afid
];
735 peer_af_delete (struct peer
*peer
, afi_t afi
, safi_t safi
)
743 afid
= afindex(afi
, safi
);
744 if (afid
>= BGP_AF_MAX
)
747 af
= peer
->peer_af_array
[afid
];
751 bgp_stop_announce_route_timer (af
);
755 if (BGP_DEBUG (update_groups
, UPDATE_GROUPS
))
756 zlog_debug ("u%" PRIu64
":s%" PRIu64
" remove peer %s",
757 af
->subgroup
->update_group
->id
, af
->subgroup
->id
, peer
->host
);
760 update_subgroup_remove_peer (af
->subgroup
, af
);
762 peer
->peer_af_array
[afid
] = NULL
;
763 XFREE(MTYPE_BGP_PEER_AF
, af
);
767 /* Peer comparison function for sorting. */
769 peer_cmp (struct peer
*p1
, struct peer
*p2
)
771 if (p1
->group
&& !p2
->group
)
774 if (!p1
->group
&& p2
->group
)
777 if (p1
->group
== p2
->group
)
779 if (p1
->conf_if
&& !p2
->conf_if
)
782 if (!p1
->conf_if
&& p2
->conf_if
)
785 if (p1
->conf_if
&& p2
->conf_if
)
786 return if_cmp_name_func (p1
->conf_if
, p2
->conf_if
);
789 return strcmp (p1
->group
->name
, p2
->group
->name
);
791 return sockunion_cmp (&p1
->su
, &p2
->su
);
795 peer_hash_key_make(void *p
)
797 struct peer
*peer
= p
;
798 return sockunion_hash(&peer
->su
);
802 peer_hash_cmp (const void *p1
, const void *p2
)
804 const struct peer
*peer1
= p1
;
805 const struct peer
*peer2
= p2
;
806 return (sockunion_same (&peer1
->su
, &peer2
->su
) &&
807 CHECK_FLAG (peer1
->flags
, PEER_FLAG_CONFIG_NODE
) == CHECK_FLAG (peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
811 peer_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
813 return CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
);
816 /* Return true if flag is set for the peer but not the peer-group */
818 peergroup_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
820 struct peer
*g_peer
= NULL
;
822 if (peer_af_flag_check (peer
, afi
, safi
, flag
))
824 if (peer_group_active (peer
))
826 g_peer
= peer
->group
->conf
;
828 /* If this flag is not set for the peer's peer-group then return true */
829 if (!peer_af_flag_check (g_peer
, afi
, safi
, flag
))
835 /* peer is not in a peer-group but the flag is set to return true */
845 /* Reset all address family specific configuration. */
847 peer_af_flag_reset (struct peer
*peer
, afi_t afi
, safi_t safi
)
850 struct bgp_filter
*filter
;
851 char orf_name
[BUFSIZ
];
853 filter
= &peer
->filter
[afi
][safi
];
855 /* Clear neighbor filter and route-map */
856 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
858 if (filter
->dlist
[i
].name
)
860 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
861 filter
->dlist
[i
].name
= NULL
;
863 if (filter
->plist
[i
].name
)
865 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
866 filter
->plist
[i
].name
= NULL
;
868 if (filter
->aslist
[i
].name
)
870 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
871 filter
->aslist
[i
].name
= NULL
;
874 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
876 if (filter
->map
[i
].name
)
878 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
879 filter
->map
[i
].name
= NULL
;
883 /* Clear unsuppress map. */
884 if (filter
->usmap
.name
)
885 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
886 filter
->usmap
.name
= NULL
;
887 filter
->usmap
.map
= NULL
;
889 /* Clear neighbor's all address family flags. */
890 peer
->af_flags
[afi
][safi
] = 0;
892 /* Clear neighbor's all address family sflags. */
893 peer
->af_sflags
[afi
][safi
] = 0;
895 /* Clear neighbor's all address family capabilities. */
896 peer
->af_cap
[afi
][safi
] = 0;
899 peer
->orf_plist
[afi
][safi
] = NULL
;
900 sprintf (orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
901 prefix_bgp_orf_remove_all (afi
, orf_name
);
903 /* Set default neighbor send-community. */
904 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
906 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
907 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
908 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_LARGE_COMMUNITY
);
911 /* Clear neighbor default_originate_rmap */
912 if (peer
->default_rmap
[afi
][safi
].name
)
913 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
914 peer
->default_rmap
[afi
][safi
].name
= NULL
;
915 peer
->default_rmap
[afi
][safi
].map
= NULL
;
917 /* Clear neighbor maximum-prefix */
918 peer
->pmax
[afi
][safi
] = 0;
919 peer
->pmax_threshold
[afi
][safi
] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT
;
922 /* peer global config reset */
924 peer_global_config_reset (struct peer
*peer
)
929 peer
->change_local_as
= 0;
930 peer
->ttl
= (peer_sort (peer
) == BGP_PEER_IBGP
? MAXTTL
: 1);
931 if (peer
->update_source
)
933 sockunion_free (peer
->update_source
);
934 peer
->update_source
= NULL
;
938 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
939 peer
->update_if
= NULL
;
942 if (peer_sort (peer
) == BGP_PEER_IBGP
)
943 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
945 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
947 /* This is a per-peer specific flag and so we must preserve it */
948 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
953 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
959 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
961 /* Reset some other configs back to defaults. */
962 peer
->v_start
= BGP_INIT_START_TIMER
;
963 peer
->password
= NULL
;
964 peer
->local_id
= peer
->bgp
->router_id
;
965 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
966 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
968 bfd_info_free(&(peer
->bfd_info
));
970 /* Set back the CONFIG_NODE flag. */
971 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
974 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
975 static bgp_peer_sort_t
976 peer_calc_sort (struct peer
*peer
)
983 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
985 if (peer
->as_type
== AS_INTERNAL
)
986 return BGP_PEER_IBGP
;
988 else if (peer
->as_type
== AS_EXTERNAL
)
989 return BGP_PEER_EBGP
;
991 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
)
992 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
997 peer1
= listnode_head (peer
->group
->peer
);
1002 return BGP_PEER_INTERNAL
;
1006 if (bgp
&& CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1008 if (peer
->local_as
== 0)
1009 return BGP_PEER_INTERNAL
;
1011 if (peer
->local_as
== peer
->as
)
1013 if (bgp
->as
== bgp
->confed_id
)
1015 if (peer
->local_as
== bgp
->as
)
1016 return BGP_PEER_IBGP
;
1018 return BGP_PEER_EBGP
;
1022 if (peer
->local_as
== bgp
->confed_id
)
1023 return BGP_PEER_EBGP
;
1025 return BGP_PEER_IBGP
;
1029 if (bgp_confederation_peers_check (bgp
, peer
->as
))
1030 return BGP_PEER_CONFED
;
1032 return BGP_PEER_EBGP
;
1036 if (peer
->as_type
!= AS_SPECIFIED
)
1037 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1039 return (peer
->local_as
== 0
1040 ? BGP_PEER_INTERNAL
: peer
->local_as
== peer
->as
1041 ? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1045 /* Calculate and cache the peer "sort" */
1047 peer_sort (struct peer
*peer
)
1049 peer
->sort
= peer_calc_sort (peer
);
1054 peer_free (struct peer
*peer
)
1056 assert (peer
->status
== Deleted
);
1060 /* this /ought/ to have been done already through bgp_stop earlier,
1061 * but just to be sure..
1063 bgp_timer_set (peer
);
1064 BGP_READ_OFF (peer
->t_read
);
1065 BGP_WRITE_OFF (peer
->t_write
);
1066 BGP_EVENT_FLUSH (peer
);
1068 /* Free connected nexthop, if present */
1069 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
) &&
1070 !peer_dynamic_neighbor (peer
))
1071 bgp_delete_connected_nexthop (family2afi(peer
->su
.sa
.sa_family
), peer
);
1073 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
1077 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
1081 /* Free allocated host character. */
1084 XFREE (MTYPE_BGP_PEER_HOST
, peer
->host
);
1088 if (peer
->domainname
)
1090 XFREE (MTYPE_BGP_PEER_HOST
, peer
->domainname
);
1091 peer
->domainname
= NULL
;
1096 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1097 peer
->ifname
= NULL
;
1100 /* Update source configuration. */
1101 if (peer
->update_source
)
1103 sockunion_free (peer
->update_source
);
1104 peer
->update_source
= NULL
;
1107 if (peer
->update_if
)
1109 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1110 peer
->update_if
= NULL
;
1113 if (peer
->notify
.data
)
1114 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1115 memset (&peer
->notify
, 0, sizeof (struct bgp_notify
));
1117 if (peer
->clear_node_queue
)
1119 work_queue_free(peer
->clear_node_queue
);
1120 peer
->clear_node_queue
= NULL
;
1123 bgp_sync_delete (peer
);
1127 XFREE (MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1128 peer
->conf_if
= NULL
;
1131 bfd_info_free(&(peer
->bfd_info
));
1133 bgp_unlock(peer
->bgp
);
1135 memset (peer
, 0, sizeof (struct peer
));
1137 XFREE (MTYPE_BGP_PEER
, peer
);
1140 /* increase reference count on a struct peer */
1142 peer_lock_with_caller (const char *name
, struct peer
*peer
)
1144 assert (peer
&& (peer
->lock
>= 0));
1147 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1155 /* decrease reference count on a struct peer
1156 * struct peer is freed and NULL returned if last reference
1159 peer_unlock_with_caller (const char *name
, struct peer
*peer
)
1161 assert (peer
&& (peer
->lock
> 0));
1164 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1169 if (peer
->lock
== 0)
1178 /* Allocate new peer object, implicitely locked. */
1180 peer_new (struct bgp
*bgp
)
1187 /* bgp argument is absolutely required */
1192 /* Allocate new peer. */
1193 peer
= XCALLOC (MTYPE_BGP_PEER
, sizeof (struct peer
));
1195 /* Set default value. */
1197 peer
->v_start
= BGP_INIT_START_TIMER
;
1198 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1199 peer
->status
= Idle
;
1200 peer
->ostatus
= Idle
;
1201 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1203 peer
= peer_lock (peer
); /* initial reference */
1205 peer
->password
= NULL
;
1207 /* Set default flags. */
1208 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1209 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1211 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
1213 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1214 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
1215 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_LARGE_COMMUNITY
);
1217 peer
->orf_plist
[afi
][safi
] = NULL
;
1219 SET_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1221 /* Create buffers. */
1222 peer
->ibuf
= stream_new (BGP_MAX_PACKET_SIZE
);
1223 peer
->obuf
= stream_fifo_new ();
1225 /* We use a larger buffer for peer->work in the event that:
1226 * - We RX a BGP_UPDATE where the attributes alone are just
1227 * under BGP_MAX_PACKET_SIZE
1228 * - The user configures an outbound route-map that does many as-path
1229 * prepends or adds many communities. At most they can have CMD_ARGC_MAX
1230 * args in a route-map so there is a finite limit on how large they can
1231 * make the attributes.
1233 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid bounds
1234 * checking for every single attribute as we construct an UPDATE.
1236 peer
->work
= stream_new (BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1237 peer
->scratch
= stream_new (BGP_MAX_PACKET_SIZE
);
1240 bgp_sync_init (peer
);
1242 /* Get service port number. */
1243 sp
= getservbyname ("bgp", "tcp");
1244 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs (sp
->s_port
);
1246 QOBJ_REG (peer
, peer
);
1251 * This function is invoked when a duplicate peer structure associated with
1252 * a neighbor is being deleted. If this about-to-be-deleted structure is
1253 * the one with all the config, then we have to copy over the info.
1256 peer_xfer_config (struct peer
*peer_dst
, struct peer
*peer_src
)
1258 struct peer_af
*paf
;
1266 /* The following function is used by both peer group config copy to
1267 * individual peer and when we transfer config
1269 if (peer_src
->change_local_as
)
1270 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1272 /* peer flags apply */
1273 peer_dst
->flags
= peer_src
->flags
;
1274 peer_dst
->cap
= peer_src
->cap
;
1275 peer_dst
->config
= peer_src
->config
;
1277 peer_dst
->local_as
= peer_src
->local_as
;
1278 peer_dst
->ifindex
= peer_src
->ifindex
;
1279 peer_dst
->port
= peer_src
->port
;
1280 peer_sort(peer_dst
);
1281 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1284 peer_dst
->holdtime
= peer_src
->holdtime
;
1285 peer_dst
->keepalive
= peer_src
->keepalive
;
1286 peer_dst
->connect
= peer_src
->connect
;
1287 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1288 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1289 peer_dst
->routeadv
= peer_src
->routeadv
;
1290 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1292 /* password apply */
1293 if (peer_src
->password
&& !peer_dst
->password
)
1294 peer_dst
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, peer_src
->password
);
1296 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1297 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1299 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1300 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1301 peer_dst
->allowas_in
[afi
][safi
] = peer_src
->allowas_in
[afi
][safi
];
1302 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1305 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++)
1307 paf
= peer_src
->peer_af_array
[afidx
];
1309 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1312 /* update-source apply */
1313 if (peer_src
->update_source
)
1315 if (peer_dst
->update_source
)
1316 sockunion_free (peer_dst
->update_source
);
1317 if (peer_dst
->update_if
)
1319 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1320 peer_dst
->update_if
= NULL
;
1322 peer_dst
->update_source
= sockunion_dup (peer_src
->update_source
);
1324 else if (peer_src
->update_if
)
1326 if (peer_dst
->update_if
)
1327 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1328 if (peer_dst
->update_source
)
1330 sockunion_free (peer_dst
->update_source
);
1331 peer_dst
->update_source
= NULL
;
1333 peer_dst
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1336 if (peer_src
->ifname
)
1338 if (peer_dst
->ifname
)
1339 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1341 peer_dst
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1346 bgp_peer_conf_if_to_su_update_v4 (struct peer
*peer
, struct interface
*ifp
)
1348 struct connected
*ifc
;
1351 struct listnode
*node
;
1353 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1354 * IPv4 address of the other end.
1356 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
))
1358 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
))
1360 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1361 if (p
.prefixlen
== 30)
1363 peer
->su
.sa
.sa_family
= AF_INET
;
1364 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1366 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1367 else if (addr
% 4 == 2)
1368 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1369 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1370 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1371 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1374 else if (p
.prefixlen
== 31)
1376 peer
->su
.sa
.sa_family
= AF_INET
;
1377 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1379 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1381 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1382 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1383 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1384 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1388 if (bgp_debug_neighbor_events(peer
))
1389 zlog_debug("%s: IPv4 interface address is not /30 or /31, v4 session not started",
1398 bgp_peer_conf_if_to_su_update_v6 (struct peer
*peer
, struct interface
*ifp
)
1400 struct nbr_connected
*ifc_nbr
;
1402 /* Have we learnt the peer's IPv6 link-local address? */
1403 if (ifp
->nbr_connected
&&
1404 (ifc_nbr
= listnode_head(ifp
->nbr_connected
)))
1406 peer
->su
.sa
.sa_family
= AF_INET6
;
1407 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1408 sizeof (struct in6_addr
));
1410 peer
->su
.sin6
.sin6_len
= sizeof (struct sockaddr_in6
);
1412 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1420 * Set or reset the peer address socketunion structure based on the
1421 * learnt/derived peer address. If the address has changed, update the
1422 * password on the listen socket, if needed.
1425 bgp_peer_conf_if_to_su_update (struct peer
*peer
)
1427 struct interface
*ifp
;
1429 int peer_addr_updated
= 0;
1434 prev_family
= peer
->su
.sa
.sa_family
;
1435 if ((ifp
= if_lookup_by_name (peer
->conf_if
, peer
->bgp
->vrf_id
)))
1438 /* If BGP unnumbered is not "v6only", we first see if we can derive the
1439 * peer's IPv4 address.
1441 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1442 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v4 (peer
, ifp
);
1444 /* If "v6only" or we can't derive peer's IPv4 address, see if we've
1445 * learnt the peer's IPv6 link-local address. This is from the source
1446 * IPv6 address in router advertisement.
1448 if (!peer_addr_updated
)
1449 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v6 (peer
, ifp
);
1451 /* If we could derive the peer address, we may need to install the password
1452 * configured for the peer, if any, on the listen socket. Otherwise, mark
1453 * that peer's address is not available and uninstall the password, if
1456 if (peer_addr_updated
)
1458 if (peer
->password
&& prev_family
== AF_UNSPEC
)
1463 if (peer
->password
&& prev_family
!= AF_UNSPEC
)
1464 bgp_md5_unset (peer
);
1465 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1466 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof (struct in6_addr
));
1469 /* Since our su changed we need to del/add peer to the peerhash */
1470 hash_release(peer
->bgp
->peerhash
, peer
);
1471 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1474 /* Force a bestpath recalculation for all prefixes. This is used
1475 * when 'bgp bestpath' commands are entered.
1478 bgp_recalculate_all_bestpaths (struct bgp
*bgp
)
1482 struct bgp_node
*rn
;
1484 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1486 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1488 for (rn
= bgp_table_top (bgp
->rib
[afi
][safi
]); rn
; rn
= bgp_route_next (rn
))
1490 if (rn
->info
!= NULL
)
1492 bgp_process (bgp
, rn
, afi
, safi
);
1499 /* Create new BGP peer. */
1501 peer_create (union sockunion
*su
, const char *conf_if
, struct bgp
*bgp
,
1502 as_t local_as
, as_t remote_as
, int as_type
, afi_t afi
, safi_t safi
, struct peer_group
*group
)
1506 char buf
[SU_ADDRSTRLEN
];
1508 peer
= peer_new (bgp
);
1511 peer
->conf_if
= XSTRDUP (MTYPE_PEER_CONF_IF
, conf_if
);
1512 bgp_peer_conf_if_to_su_update(peer
);
1514 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1515 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, conf_if
);
1520 sockunion2str (su
, buf
, SU_ADDRSTRLEN
);
1522 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1523 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, buf
);
1525 peer
->local_as
= local_as
;
1526 peer
->as
= remote_as
;
1527 peer
->as_type
= as_type
;
1528 peer
->local_id
= bgp
->router_id
;
1529 peer
->v_holdtime
= bgp
->default_holdtime
;
1530 peer
->v_keepalive
= bgp
->default_keepalive
;
1531 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1532 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1534 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1536 peer
= peer_lock (peer
); /* bgp peer list reference */
1537 peer
->group
= group
;
1538 listnode_add_sort (bgp
->peer
, peer
);
1539 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1541 active
= peer_active (peer
);
1543 /* Last read and reset time set */
1544 peer
->readtime
= peer
->resettime
= bgp_clock ();
1546 /* Default TTL set. */
1547 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: 1;
1549 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1553 peer
->afc
[afi
][safi
] = 1;
1554 peer_af_create(peer
, afi
, safi
);
1557 /* Set up peer's events and timers. */
1558 if (! active
&& peer_active (peer
))
1559 bgp_timer_set (peer
);
1564 /* Make accept BGP peer. This function is only called from the test code */
1566 peer_create_accept (struct bgp
*bgp
)
1570 peer
= peer_new (bgp
);
1572 peer
= peer_lock (peer
); /* bgp peer list reference */
1573 listnode_add_sort (bgp
->peer
, peer
);
1578 /* Change peer's AS number. */
1580 peer_as_change (struct peer
*peer
, as_t as
, int as_specified
)
1582 bgp_peer_sort_t type
;
1586 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1588 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
1590 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1591 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1592 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1595 bgp_session_reset(peer
);
1597 type
= peer_sort (peer
);
1599 peer
->as_type
= as_specified
;
1601 if (bgp_config_check (peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1602 && ! bgp_confederation_peers_check (peer
->bgp
, as
)
1603 && peer
->bgp
->as
!= as
)
1604 peer
->local_as
= peer
->bgp
->confed_id
;
1606 peer
->local_as
= peer
->bgp
->as
;
1608 /* Advertisement-interval reset */
1611 conf
= peer
->group
->conf
;
1613 if (conf
&& CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
1615 peer
->v_routeadv
= conf
->routeadv
;
1617 /* Only go back to the default advertisement-interval if the user had not
1618 * already configured it */
1619 else if (!CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
))
1621 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1622 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1624 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1627 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1629 else if (type
== BGP_PEER_IBGP
)
1632 /* reflector-client reset */
1633 if (peer_sort (peer
) != BGP_PEER_IBGP
)
1635 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1636 PEER_FLAG_REFLECTOR_CLIENT
);
1637 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1638 PEER_FLAG_REFLECTOR_CLIENT
);
1639 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_LABELED_UNICAST
],
1640 PEER_FLAG_REFLECTOR_CLIENT
);
1641 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1642 PEER_FLAG_REFLECTOR_CLIENT
);
1643 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1644 PEER_FLAG_REFLECTOR_CLIENT
);
1645 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1646 PEER_FLAG_REFLECTOR_CLIENT
);
1647 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1648 PEER_FLAG_REFLECTOR_CLIENT
);
1649 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_LABELED_UNICAST
],
1650 PEER_FLAG_REFLECTOR_CLIENT
);
1651 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1652 PEER_FLAG_REFLECTOR_CLIENT
);
1653 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1654 PEER_FLAG_REFLECTOR_CLIENT
);
1655 UNSET_FLAG (peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1656 PEER_FLAG_REFLECTOR_CLIENT
);
1659 /* local-as reset */
1660 if (peer_sort (peer
) != BGP_PEER_EBGP
)
1662 peer
->change_local_as
= 0;
1663 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1664 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1668 /* If peer does not exist, create new one. If peer already exists,
1669 set AS number to the peer. */
1671 peer_remote_as (struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1672 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1678 peer
= peer_lookup_by_conf_if (bgp
, conf_if
);
1680 peer
= peer_lookup (bgp
, su
);
1684 /* Not allowed for a dynamic peer. */
1685 if (peer_dynamic_neighbor (peer
))
1688 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1691 /* When this peer is a member of peer-group. */
1694 if (peer
->group
->conf
->as
)
1696 /* Return peer group's AS number. */
1697 *as
= peer
->group
->conf
->as
;
1698 return BGP_ERR_PEER_GROUP_MEMBER
;
1700 if (peer_sort (peer
->group
->conf
) == BGP_PEER_IBGP
)
1702 if ((as_type
!= AS_INTERNAL
) && (bgp
->as
!= *as
))
1705 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1710 if ((as_type
!= AS_EXTERNAL
) && (bgp
->as
== *as
))
1713 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1718 /* Existing peer's AS number change. */
1719 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
1720 (peer
->as_type
!= as_type
))
1721 peer_as_change (peer
, *as
, as_type
);
1726 return BGP_ERR_NO_INTERFACE_CONFIG
;
1728 /* If the peer is not part of our confederation, and its not an
1729 iBGP peer then spoof the source AS */
1730 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
)
1731 && ! bgp_confederation_peers_check (bgp
, *as
)
1733 local_as
= bgp
->confed_id
;
1737 /* If this is IPv4 unicast configuration and "no bgp default
1738 ipv4-unicast" is specified. */
1740 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1741 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1742 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0, 0, NULL
);
1744 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, afi
, safi
, NULL
);
1751 non_peergroup_activate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1755 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1757 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1761 /* Nothing to do if we've already activated this peer */
1762 if (peer
->afc
[afi
][safi
])
1765 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1768 active
= peer_active (peer
);
1769 peer
->afc
[afi
][safi
] = 1;
1771 if (!active
&& peer_active (peer
))
1773 bgp_timer_set (peer
);
1777 if (peer
->status
== Established
)
1779 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1781 peer
->afc_adv
[afi
][safi
] = 1;
1782 bgp_capability_send (peer
, afi
, safi
,
1784 CAPABILITY_ACTION_SET
);
1785 if (peer
->afc_recv
[afi
][safi
])
1787 peer
->afc_nego
[afi
][safi
] = 1;
1788 bgp_announce_route (peer
, afi
, safi
);
1793 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1794 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1795 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1803 /* Activate the peer or peer group for specified AFI and SAFI. */
1805 peer_activate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1808 struct peer_group
*group
;
1809 struct listnode
*node
, *nnode
;
1810 struct peer
*tmp_peer
;
1812 /* Nothing to do if we've already activated this peer */
1813 if (peer
->afc
[afi
][safi
])
1816 /* This is a peer-group so activate all of the members of the
1817 * peer-group as well */
1818 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1820 peer
->afc
[afi
][safi
] = 1;
1821 group
= peer
->group
;
1823 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1825 ret
|= non_peergroup_activate_af (tmp_peer
, afi
, safi
);
1830 ret
|= non_peergroup_activate_af (peer
, afi
, safi
);
1837 non_peergroup_deactivate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1839 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1841 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1845 /* Nothing to do if we've already deactivated this peer */
1846 if (! peer
->afc
[afi
][safi
])
1849 /* De-activate the address family configuration. */
1850 peer
->afc
[afi
][safi
] = 0;
1852 if (peer_af_delete(peer
, afi
, safi
) != 0)
1854 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1858 if (peer
->status
== Established
)
1860 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1862 peer
->afc_adv
[afi
][safi
] = 0;
1863 peer
->afc_nego
[afi
][safi
] = 0;
1865 if (peer_active_nego (peer
))
1867 bgp_capability_send (peer
, afi
, safi
,
1869 CAPABILITY_ACTION_UNSET
);
1870 bgp_clear_route (peer
, afi
, safi
);
1871 peer
->pcount
[afi
][safi
] = 0;
1875 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1876 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1877 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1882 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1883 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1884 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1892 peer_deactivate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1895 struct peer_group
*group
;
1896 struct peer
*tmp_peer
;
1897 struct listnode
*node
, *nnode
;
1899 /* Nothing to do if we've already de-activated this peer */
1900 if (! peer
->afc
[afi
][safi
])
1903 /* This is a peer-group so de-activate all of the members of the
1904 * peer-group as well */
1905 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1907 peer
->afc
[afi
][safi
] = 0;
1908 group
= peer
->group
;
1910 if (peer_af_delete(peer
, afi
, safi
) != 0)
1912 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1915 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1917 ret
|= non_peergroup_deactivate_af (tmp_peer
, afi
, safi
);
1922 ret
|= non_peergroup_deactivate_af (peer
, afi
, safi
);
1929 peer_afc_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
1932 return peer_activate (peer
, afi
, safi
);
1934 return peer_deactivate (peer
, afi
, safi
);
1938 peer_nsf_stop (struct peer
*peer
)
1943 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1944 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
);
1946 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1947 for (safi
= SAFI_UNICAST
; safi
< SAFI_RESERVED_4
; safi
++)
1948 peer
->nsf
[afi
][safi
] = 0;
1950 if (peer
->t_gr_restart
)
1952 BGP_TIMER_OFF (peer
->t_gr_restart
);
1953 if (bgp_debug_neighbor_events(peer
))
1954 zlog_debug ("%s graceful restart timer stopped", peer
->host
);
1956 if (peer
->t_gr_stale
)
1958 BGP_TIMER_OFF (peer
->t_gr_stale
);
1959 if (bgp_debug_neighbor_events(peer
))
1960 zlog_debug ("%s graceful restart stalepath timer stopped", peer
->host
);
1962 bgp_clear_route_all (peer
);
1965 /* Delete peer from confguration.
1967 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
1968 * it to "cool off" and refcounts to hit 0, at which state it is freed.
1970 * This function /should/ take care to be idempotent, to guard against
1971 * it being called multiple times through stray events that come in
1972 * that happen to result in this function being called again. That
1973 * said, getting here for a "Deleted" peer is a bug in the neighbour
1977 peer_delete (struct peer
*peer
)
1983 struct bgp_filter
*filter
;
1984 struct listnode
*pn
;
1987 assert (peer
->status
!= Deleted
);
1990 accept_peer
= CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1992 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
1993 peer_nsf_stop (peer
);
1995 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
1997 /* If this peer belongs to peer group, clear up the
2001 if (peer_dynamic_neighbor(peer
))
2002 peer_drop_dynamic_neighbor(peer
);
2004 if ((pn
= listnode_lookup (peer
->group
->peer
, peer
)))
2006 peer
= peer_unlock (peer
); /* group->peer list reference */
2007 list_delete_node (peer
->group
->peer
, pn
);
2012 /* Withdraw all information from routing table. We can not use
2013 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2014 * executed after peer structure is deleted.
2016 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2018 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2020 if (peer
->doppelganger
)
2022 peer
->doppelganger
->doppelganger
= NULL
;
2023 peer
->doppelganger
= NULL
;
2026 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2027 bgp_fsm_change_status (peer
, Deleted
);
2029 /* Remove from NHT */
2030 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2031 bgp_unlink_nexthop_by_peer (peer
);
2033 /* Password configuration */
2036 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
2037 peer
->password
= NULL
;
2040 ! BGP_PEER_SU_UNSPEC(peer
) &&
2041 ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
2042 bgp_md5_unset (peer
);
2045 bgp_timer_set (peer
); /* stops all timers for Deleted */
2047 /* Delete from all peer list. */
2048 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
2049 && (pn
= listnode_lookup (bgp
->peer
, peer
)))
2051 peer_unlock (peer
); /* bgp peer list reference */
2052 list_delete_node (bgp
->peer
, pn
);
2053 hash_release(bgp
->peerhash
, peer
);
2059 stream_free (peer
->ibuf
);
2065 stream_fifo_free (peer
->obuf
);
2071 stream_free (peer
->work
);
2077 stream_free(peer
->scratch
);
2078 peer
->scratch
= NULL
;
2081 /* Local and remote addresses. */
2084 sockunion_free (peer
->su_local
);
2085 peer
->su_local
= NULL
;
2088 if (peer
->su_remote
)
2090 sockunion_free (peer
->su_remote
);
2091 peer
->su_remote
= NULL
;
2094 /* Free filter related memory. */
2095 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2096 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2098 filter
= &peer
->filter
[afi
][safi
];
2100 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
2102 if (filter
->dlist
[i
].name
)
2104 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2105 filter
->dlist
[i
].name
= NULL
;
2108 if (filter
->plist
[i
].name
)
2110 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2111 filter
->plist
[i
].name
= NULL
;
2114 if (filter
->aslist
[i
].name
)
2116 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2117 filter
->aslist
[i
].name
= NULL
;
2121 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
2123 if (filter
->map
[i
].name
)
2125 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2126 filter
->map
[i
].name
= NULL
;
2130 if (filter
->usmap
.name
)
2132 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2133 filter
->usmap
.name
= NULL
;
2136 if (peer
->default_rmap
[afi
][safi
].name
)
2138 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2139 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2143 FOREACH_AFI_SAFI (afi
, safi
)
2144 peer_af_delete (peer
, afi
, safi
);
2148 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2149 peer
->hostname
= NULL
;
2152 if (peer
->domainname
)
2154 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2155 peer
->domainname
= NULL
;
2158 peer_unlock (peer
); /* initial reference */
2164 peer_group_cmp (struct peer_group
*g1
, struct peer_group
*g2
)
2166 return strcmp (g1
->name
, g2
->name
);
2169 /* Peer group cofiguration. */
2170 static struct peer_group
*
2171 peer_group_new (void)
2173 return (struct peer_group
*) XCALLOC (MTYPE_PEER_GROUP
,
2174 sizeof (struct peer_group
));
2178 peer_group_free (struct peer_group
*group
)
2180 XFREE (MTYPE_PEER_GROUP
, group
);
2184 peer_group_lookup (struct bgp
*bgp
, const char *name
)
2186 struct peer_group
*group
;
2187 struct listnode
*node
, *nnode
;
2189 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
2191 if (strcmp (group
->name
, name
) == 0)
2198 peer_group_get (struct bgp
*bgp
, const char *name
)
2200 struct peer_group
*group
;
2203 group
= peer_group_lookup (bgp
, name
);
2207 group
= peer_group_new ();
2210 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2211 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2212 group
->peer
= list_new ();
2213 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2214 group
->listen_range
[afi
] = list_new ();
2215 group
->conf
= peer_new (bgp
);
2216 if (! bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2217 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2218 if (group
->conf
->host
)
2219 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2220 group
->conf
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, name
);
2221 group
->conf
->group
= group
;
2222 group
->conf
->as
= 0;
2223 group
->conf
->ttl
= 1;
2224 group
->conf
->gtsm_hops
= 0;
2225 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2226 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_TIMER
);
2227 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_CONNECT
);
2228 group
->conf
->keepalive
= 0;
2229 group
->conf
->holdtime
= 0;
2230 group
->conf
->connect
= 0;
2231 SET_FLAG (group
->conf
->sflags
, PEER_STATUS_GROUP
);
2232 listnode_add_sort (bgp
->group
, group
);
2238 peer_group2peer_config_copy (struct peer_group
*group
, struct peer
*peer
)
2247 peer
->as
= conf
->as
;
2250 if (conf
->change_local_as
)
2251 peer
->change_local_as
= conf
->change_local_as
;
2254 peer
->ttl
= conf
->ttl
;
2257 peer
->gtsm_hops
= conf
->gtsm_hops
;
2259 /* this flag is per-neighbor and so has to be preserved */
2260 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2262 /* peer flags apply */
2263 peer
->flags
= conf
->flags
;
2266 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2268 /* peer config apply */
2269 peer
->config
= conf
->config
;
2271 /* peer timers apply */
2272 peer
->holdtime
= conf
->holdtime
;
2273 peer
->keepalive
= conf
->keepalive
;
2274 peer
->connect
= conf
->connect
;
2275 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_CONNECT
))
2276 peer
->v_connect
= conf
->connect
;
2278 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2280 /* advertisement-interval reset */
2281 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
2282 peer
->v_routeadv
= conf
->routeadv
;
2284 if (peer_sort (peer
) == BGP_PEER_IBGP
)
2285 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2287 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2289 /* password apply */
2290 if (conf
->password
&& !peer
->password
)
2291 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, conf
->password
);
2293 if (! BGP_PEER_SU_UNSPEC(peer
))
2296 /* update-source apply */
2297 if (conf
->update_source
)
2299 if (peer
->update_source
)
2300 sockunion_free (peer
->update_source
);
2301 if (peer
->update_if
)
2303 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2304 peer
->update_if
= NULL
;
2306 peer
->update_source
= sockunion_dup (conf
->update_source
);
2308 else if (conf
->update_if
)
2310 if (peer
->update_if
)
2311 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2312 if (peer
->update_source
)
2314 sockunion_free (peer
->update_source
);
2315 peer
->update_source
= NULL
;
2317 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2320 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2324 peer_group2peer_config_copy_af (struct peer_group
*group
, struct peer
*peer
,
2325 afi_t afi
, safi_t safi
)
2328 int out
= FILTER_OUT
;
2330 struct bgp_filter
*pfilter
;
2331 struct bgp_filter
*gfilter
;
2334 pfilter
= &peer
->filter
[afi
][safi
];
2335 gfilter
= &conf
->filter
[afi
][safi
];
2337 /* peer af_flags apply */
2338 peer
->af_flags
[afi
][safi
] = conf
->af_flags
[afi
][safi
];
2340 /* maximum-prefix */
2341 peer
->pmax
[afi
][safi
] = conf
->pmax
[afi
][safi
];
2342 peer
->pmax_threshold
[afi
][safi
] = conf
->pmax_threshold
[afi
][safi
];
2343 peer
->pmax_restart
[afi
][safi
] = conf
->pmax_restart
[afi
][safi
];
2346 peer
->allowas_in
[afi
][safi
] = conf
->allowas_in
[afi
][safi
];
2349 peer
->weight
[afi
][safi
] = conf
->weight
[afi
][safi
];
2351 /* default-originate route-map */
2352 if (conf
->default_rmap
[afi
][safi
].name
)
2354 if (peer
->default_rmap
[afi
][safi
].name
)
2355 XFREE(MTYPE_BGP_FILTER_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2356 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, conf
->default_rmap
[afi
][safi
].name
);
2357 peer
->default_rmap
[afi
][safi
].map
= conf
->default_rmap
[afi
][safi
].map
;
2360 /* inbound filter apply */
2361 if (gfilter
->dlist
[in
].name
&& ! pfilter
->dlist
[in
].name
)
2363 if (pfilter
->dlist
[in
].name
)
2364 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[in
].name
);
2365 pfilter
->dlist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[in
].name
);
2366 pfilter
->dlist
[in
].alist
= gfilter
->dlist
[in
].alist
;
2369 if (gfilter
->plist
[in
].name
&& ! pfilter
->plist
[in
].name
)
2371 if (pfilter
->plist
[in
].name
)
2372 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[in
].name
);
2373 pfilter
->plist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[in
].name
);
2374 pfilter
->plist
[in
].plist
= gfilter
->plist
[in
].plist
;
2377 if (gfilter
->aslist
[in
].name
&& ! pfilter
->aslist
[in
].name
)
2379 if (pfilter
->aslist
[in
].name
)
2380 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[in
].name
);
2381 pfilter
->aslist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[in
].name
);
2382 pfilter
->aslist
[in
].aslist
= gfilter
->aslist
[in
].aslist
;
2385 if (gfilter
->map
[RMAP_IN
].name
&& ! pfilter
->map
[RMAP_IN
].name
)
2387 if (pfilter
->map
[RMAP_IN
].name
)
2388 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_IN
].name
);
2389 pfilter
->map
[RMAP_IN
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_IN
].name
);
2390 pfilter
->map
[RMAP_IN
].map
= gfilter
->map
[RMAP_IN
].map
;
2393 /* outbound filter apply */
2394 if (gfilter
->dlist
[out
].name
)
2396 if (pfilter
->dlist
[out
].name
)
2397 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2398 pfilter
->dlist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[out
].name
);
2399 pfilter
->dlist
[out
].alist
= gfilter
->dlist
[out
].alist
;
2403 if (pfilter
->dlist
[out
].name
)
2404 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2405 pfilter
->dlist
[out
].name
= NULL
;
2406 pfilter
->dlist
[out
].alist
= NULL
;
2409 if (gfilter
->plist
[out
].name
)
2411 if (pfilter
->plist
[out
].name
)
2412 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2413 pfilter
->plist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[out
].name
);
2414 pfilter
->plist
[out
].plist
= gfilter
->plist
[out
].plist
;
2418 if (pfilter
->plist
[out
].name
)
2419 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2420 pfilter
->plist
[out
].name
= NULL
;
2421 pfilter
->plist
[out
].plist
= NULL
;
2424 if (gfilter
->aslist
[out
].name
)
2426 if (pfilter
->aslist
[out
].name
)
2427 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2428 pfilter
->aslist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[out
].name
);
2429 pfilter
->aslist
[out
].aslist
= gfilter
->aslist
[out
].aslist
;
2433 if (pfilter
->aslist
[out
].name
)
2434 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2435 pfilter
->aslist
[out
].name
= NULL
;
2436 pfilter
->aslist
[out
].aslist
= NULL
;
2439 if (gfilter
->map
[RMAP_OUT
].name
)
2441 if (pfilter
->map
[RMAP_OUT
].name
)
2442 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2443 pfilter
->map
[RMAP_OUT
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_OUT
].name
);
2444 pfilter
->map
[RMAP_OUT
].map
= gfilter
->map
[RMAP_OUT
].map
;
2448 if (pfilter
->map
[RMAP_OUT
].name
)
2449 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2450 pfilter
->map
[RMAP_OUT
].name
= NULL
;
2451 pfilter
->map
[RMAP_OUT
].map
= NULL
;
2454 if (gfilter
->usmap
.name
)
2456 if (pfilter
->usmap
.name
)
2457 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2458 pfilter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->usmap
.name
);
2459 pfilter
->usmap
.map
= gfilter
->usmap
.map
;
2463 if (pfilter
->usmap
.name
)
2464 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2465 pfilter
->usmap
.name
= NULL
;
2466 pfilter
->usmap
.map
= NULL
;
2470 /* Peer group's remote AS configuration. */
2472 peer_group_remote_as (struct bgp
*bgp
, const char *group_name
,
2473 as_t
*as
, int as_type
)
2475 struct peer_group
*group
;
2477 struct listnode
*node
, *nnode
;
2479 group
= peer_group_lookup (bgp
, group_name
);
2483 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2487 /* When we setup peer-group AS number all peer group member's AS
2488 number must be updated to same number. */
2489 peer_as_change (group
->conf
, *as
, as_type
);
2491 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2493 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
2494 (peer
->as_type
!= as_type
))
2495 peer_as_change (peer
, *as
, as_type
);
2502 peer_group_delete (struct peer_group
*group
)
2506 struct prefix
*prefix
;
2508 struct listnode
*node
, *nnode
;
2513 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2515 other
= peer
->doppelganger
;
2517 if (other
&& other
->status
!= Deleted
)
2519 other
->group
= NULL
;
2523 list_delete (group
->peer
);
2525 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2527 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2529 prefix_free(prefix
);
2531 list_delete (group
->listen_range
[afi
]);
2534 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2537 bfd_info_free(&(group
->conf
->bfd_info
));
2539 group
->conf
->group
= NULL
;
2540 peer_delete (group
->conf
);
2542 /* Delete from all peer_group list. */
2543 listnode_delete (bgp
->group
, group
);
2545 peer_group_free (group
);
2551 peer_group_remote_as_delete (struct peer_group
*group
)
2553 struct peer
*peer
, *other
;
2554 struct listnode
*node
, *nnode
;
2556 if ((group
->conf
->as_type
== AS_UNSPECIFIED
) ||
2557 ((! group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2560 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2562 other
= peer
->doppelganger
;
2566 if (other
&& other
->status
!= Deleted
)
2568 other
->group
= NULL
;
2572 list_delete_all_node (group
->peer
);
2574 group
->conf
->as
= 0;
2575 group
->conf
->as_type
= AS_UNSPECIFIED
;
2581 peer_group_listen_range_add (struct peer_group
*group
, struct prefix
*range
)
2583 struct prefix
*prefix
;
2584 struct listnode
*node
, *nnode
;
2587 afi
= family2afi(range
->family
);
2589 /* Group needs remote AS configured. */
2590 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2591 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2593 /* Ensure no duplicates. Currently we don't care about overlaps. */
2594 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2596 if (prefix_same(range
, prefix
))
2600 prefix
= prefix_new();
2601 prefix_copy(prefix
, range
);
2602 listnode_add(group
->listen_range
[afi
], prefix
);
2607 peer_group_listen_range_del (struct peer_group
*group
, struct prefix
*range
)
2609 struct prefix
*prefix
, prefix2
;
2610 struct listnode
*node
, *nnode
;
2613 char buf
[PREFIX2STR_BUFFER
];
2615 afi
= family2afi(range
->family
);
2617 /* Identify the listen range. */
2618 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2620 if (prefix_same(range
, prefix
))
2625 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2627 prefix2str(prefix
, buf
, sizeof(buf
));
2629 /* Dispose off any dynamic neighbors that exist due to this listen range */
2630 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2632 if (!peer_dynamic_neighbor (peer
))
2635 sockunion2hostprefix(&peer
->su
, &prefix2
);
2636 if (prefix_match(prefix
, &prefix2
))
2638 if (bgp_debug_neighbor_events(peer
))
2639 zlog_debug ("Deleting dynamic neighbor %s group %s upon "
2640 "delete of listen range %s",
2641 peer
->host
, group
->name
, buf
);
2646 /* Get rid of the listen range */
2647 listnode_delete(group
->listen_range
[afi
], prefix
);
2652 /* Bind specified peer to peer group. */
2654 peer_group_bind (struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2655 struct peer_group
*group
, as_t
*as
)
2657 int first_member
= 0;
2660 int cap_enhe_preset
= 0;
2662 /* Lookup the peer. */
2664 peer
= peer_lookup (bgp
, su
);
2666 /* The peer exist, bind it to the peer-group */
2669 /* When the peer already belongs to peer group, check the consistency. */
2670 if (peer_group_active (peer
) && strcmp (peer
->group
->name
, group
->name
) != 0)
2671 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2673 /* The peer has not specified a remote-as, inherit it from the
2675 if (peer
->as_type
== AS_UNSPECIFIED
)
2677 peer
->as_type
= group
->conf
->as_type
;
2678 peer
->as
= group
->conf
->as
;
2681 if (! group
->conf
->as
)
2683 if (peer_sort (group
->conf
) != BGP_PEER_INTERNAL
2684 && peer_sort (group
->conf
) != peer_sort (peer
))
2688 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2691 if (peer_sort (group
->conf
) == BGP_PEER_INTERNAL
)
2695 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2696 cap_enhe_preset
= 1;
2698 peer_group2peer_config_copy(group
, peer
);
2701 * Capability extended-nexthop is enabled for an interface neighbor by
2702 * default. So, fix that up here.
2704 if (peer
->ifp
&& cap_enhe_preset
)
2705 peer_flag_set (peer
, PEER_FLAG_CAPABILITY_ENHE
);
2707 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2708 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2710 if (group
->conf
->afc
[afi
][safi
])
2712 peer
->afc
[afi
][safi
] = 1;
2714 if (peer_af_find(peer
, afi
, safi
) || peer_af_create(peer
, afi
, safi
))
2716 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2723 assert (group
&& peer
->group
== group
);
2727 struct listnode
*pn
;
2728 pn
= listnode_lookup (bgp
->peer
, peer
);
2729 list_delete_node (bgp
->peer
, pn
);
2730 peer
->group
= group
;
2731 listnode_add_sort (bgp
->peer
, peer
);
2733 peer
= peer_lock (peer
); /* group->peer list reference */
2734 listnode_add (group
->peer
, peer
);
2739 /* Advertisement-interval reset */
2740 if (! CHECK_FLAG (group
->conf
->config
, PEER_CONFIG_ROUTEADV
))
2742 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2743 group
->conf
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2745 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2748 /* ebgp-multihop reset */
2749 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2750 group
->conf
->ttl
= MAXTTL
;
2752 /* local-as reset */
2753 if (peer_sort (group
->conf
) != BGP_PEER_EBGP
)
2755 group
->conf
->change_local_as
= 0;
2756 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2757 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2761 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2763 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2765 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2766 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2767 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2771 bgp_session_reset(peer
);
2775 /* Create a new peer. */
2778 if ((group
->conf
->as_type
== AS_SPECIFIED
) && (! group
->conf
->as
))
2780 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2783 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
2785 peer
= peer_lock (peer
); /* group->peer list reference */
2786 listnode_add (group
->peer
, peer
);
2788 peer_group2peer_config_copy(group
, peer
);
2790 /* If the peer-group is active for this afi/safi then activate for this peer */
2791 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2792 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2793 if (group
->conf
->afc
[afi
][safi
])
2795 peer
->afc
[afi
][safi
] = 1;
2796 peer_af_create(peer
, afi
, safi
);
2797 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2800 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2802 /* Set up peer's events and timers. */
2803 if (peer_active (peer
))
2804 bgp_timer_set (peer
);
2811 peer_group_unbind (struct bgp
*bgp
, struct peer
*peer
,
2812 struct peer_group
*group
)
2818 if (group
!= peer
->group
)
2819 return BGP_ERR_PEER_GROUP_MISMATCH
;
2821 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2822 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2824 if (peer
->afc
[afi
][safi
])
2826 peer
->afc
[afi
][safi
] = 0;
2827 peer_af_flag_reset (peer
, afi
, safi
);
2829 if (peer_af_delete(peer
, afi
, safi
) != 0)
2831 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
2836 assert (listnode_lookup (group
->peer
, peer
));
2837 peer_unlock (peer
); /* peer group list reference */
2838 listnode_delete (group
->peer
, peer
);
2840 other
= peer
->doppelganger
;
2842 if (group
->conf
->as
)
2845 if (other
&& other
->status
!= Deleted
)
2850 listnode_delete(group
->peer
, other
);
2852 other
->group
= NULL
;
2858 bgp_bfd_deregister_peer(peer
);
2859 peer_global_config_reset (peer
);
2861 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2863 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2864 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2865 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2868 bgp_session_reset(peer
);
2874 bgp_startup_timer_expire (struct thread
*thread
)
2878 bgp
= THREAD_ARG (thread
);
2879 bgp
->t_startup
= NULL
;
2884 /* BGP instance creation by `router bgp' commands. */
2886 bgp_create (as_t
*as
, const char *name
, enum bgp_instance_type inst_type
)
2892 if ( (bgp
= XCALLOC (MTYPE_BGP
, sizeof (struct bgp
))) == NULL
)
2895 if (BGP_DEBUG (zebra
, ZEBRA
))
2897 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2898 zlog_debug("Creating Default VRF, AS %u", *as
);
2900 zlog_debug("Creating %s %s, AS %u",
2901 (inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
2906 bgp
->inst_type
= inst_type
;
2907 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ?
2908 VRF_DEFAULT
: VRF_UNKNOWN
;
2909 bgp
->peer_self
= peer_new (bgp
);
2910 if (bgp
->peer_self
->host
)
2911 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2912 bgp
->peer_self
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2913 bgp
->peer
= list_new ();
2914 bgp
->peer
->cmp
= (int (*)(void *, void *)) peer_cmp
;
2915 bgp
->peerhash
= hash_create (peer_hash_key_make
, peer_hash_cmp
);
2917 bgp
->group
= list_new ();
2918 bgp
->group
->cmp
= (int (*)(void *, void *)) peer_group_cmp
;
2920 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2921 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2923 bgp
->route
[afi
][safi
] = bgp_table_init (afi
, safi
);
2924 bgp
->aggregate
[afi
][safi
] = bgp_table_init (afi
, safi
);
2925 bgp
->rib
[afi
][safi
] = bgp_table_init (afi
, safi
);
2927 /* Enable maximum-paths */
2928 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_EBGP
, multipath_num
, 0);
2929 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_IBGP
, multipath_num
, 0);
2932 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2933 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2934 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2935 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2936 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2937 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2938 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2939 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2940 bgp
->dynamic_neighbors_count
= 0;
2941 #if DFLT_BGP_IMPORT_CHECK
2942 bgp_flag_set (bgp
, BGP_FLAG_IMPORT_CHECK
);
2944 #if DFLT_BGP_SHOW_HOSTNAME
2945 bgp_flag_set (bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2947 #if DFLT_BGP_LOG_NEIGHBOR_CHANGES
2948 bgp_flag_set (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2950 #if DFLT_BGP_DETERMINISTIC_MED
2951 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2953 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2958 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
)
2960 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2962 assert(bgp
->rfapi_cfg
);
2964 #endif /* ENABLE_BGP_VNC */
2968 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2972 /* TODO - The startup timer needs to be run for the whole of BGP */
2973 thread_add_timer(bm
->master
, bgp_startup_timer_expire
, bgp
,
2974 bgp
->restart_time
, &bgp
->t_startup
);
2977 bgp
->wpkt_quanta
= BGP_WRITE_PACKET_MAX
;
2978 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
2980 QOBJ_REG (bgp
, bgp
);
2982 update_bgp_group_init(bgp
);
2986 /* Return the "default VRF" instance of BGP. */
2988 bgp_get_default (void)
2991 struct listnode
*node
, *nnode
;
2993 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
2994 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2999 /* Lookup BGP entry. */
3001 bgp_lookup (as_t as
, const char *name
)
3004 struct listnode
*node
, *nnode
;
3006 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3008 && ((bgp
->name
== NULL
&& name
== NULL
)
3009 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0)))
3014 /* Lookup BGP structure by view name. */
3016 bgp_lookup_by_name (const char *name
)
3019 struct listnode
*node
, *nnode
;
3021 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3022 if ((bgp
->name
== NULL
&& name
== NULL
)
3023 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0))
3028 /* Lookup BGP instance based on VRF id. */
3029 /* Note: Only to be used for incoming messages from Zebra. */
3031 bgp_lookup_by_vrf_id (vrf_id_t vrf_id
)
3035 /* Lookup VRF (in tree) and follow link. */
3036 vrf
= vrf_lookup_by_id (vrf_id
);
3039 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3042 /* Called from VTY commands. */
3044 bgp_get (struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3045 enum bgp_instance_type inst_type
)
3049 /* Multiple instance check. */
3050 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
3053 bgp
= bgp_lookup_by_name (name
);
3055 bgp
= bgp_get_default ();
3057 /* Already exists. */
3063 return BGP_ERR_INSTANCE_MISMATCH
;
3065 if (bgp
->inst_type
!= inst_type
)
3066 return BGP_ERR_INSTANCE_MISMATCH
;
3073 /* BGP instance name can not be specified for single instance. */
3075 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3077 /* Get default BGP structure if exists. */
3078 bgp
= bgp_get_default ();
3085 return BGP_ERR_AS_MISMATCH
;
3092 bgp
= bgp_create (as
, name
, inst_type
);
3093 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3094 bgp_address_init (bgp
);
3095 bgp_scan_init (bgp
);
3098 bgp
->t_rmap_def_originate_eval
= NULL
;
3100 /* Create BGP server socket, if first instance. */
3101 if (list_isempty(bm
->bgp
)
3102 && !bgp_option_check (BGP_OPT_NO_LISTEN
))
3104 if (bgp_socket (bm
->port
, bm
->address
) < 0)
3105 return BGP_ERR_INVALID_VALUE
;
3108 listnode_add (bm
->bgp
, bgp
);
3110 /* If Default instance or VRF, link to the VRF structure, if present. */
3111 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
||
3112 bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3116 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3119 bgp_vrf_link (bgp
, vrf
);
3124 /* Register with Zebra, if needed */
3125 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3126 bgp_zebra_instance_register (bgp
);
3133 * Make BGP instance "up". Applies only to VRFs (non-default) and
3134 * implies the VRF has been learnt from Zebra.
3137 bgp_instance_up (struct bgp
*bgp
)
3140 struct listnode
*node
, *next
;
3142 /* Register with zebra. */
3143 bgp_zebra_instance_register (bgp
);
3145 /* Kick off any peers that may have been configured. */
3146 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3148 if (!BGP_PEER_START_SUPPRESSED (peer
))
3149 BGP_EVENT_ADD (peer
, BGP_Start
);
3152 /* Process any networks that have been configured. */
3153 bgp_static_add (bgp
);
3157 * Make BGP instance "down". Applies only to VRFs (non-default) and
3158 * implies the VRF has been deleted by Zebra.
3161 bgp_instance_down (struct bgp
*bgp
)
3164 struct listnode
*node
;
3165 struct listnode
*next
;
3168 if (bgp
->t_rmap_def_originate_eval
)
3170 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3171 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3174 /* Bring down peers, so corresponding routes are purged. */
3175 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3177 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3178 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3180 bgp_session_reset(peer
);
3183 /* Purge network and redistributed routes. */
3184 bgp_purge_static_redist_routes (bgp
);
3187 /* Delete BGP instance. */
3189 bgp_delete (struct bgp
*bgp
)
3192 struct peer_group
*group
;
3193 struct listnode
*node
, *next
;
3198 THREAD_OFF (bgp
->t_startup
);
3200 if (BGP_DEBUG (zebra
, ZEBRA
))
3202 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3203 zlog_debug("Deleting Default VRF");
3205 zlog_debug("Deleting %s %s",
3206 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
3211 if (bgp
->t_rmap_def_originate_eval
)
3213 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3214 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3217 /* Inform peers we're going down. */
3218 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3220 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3221 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3224 /* Delete static routes (networks). */
3225 bgp_static_delete (bgp
);
3227 /* Unset redistribution. */
3228 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3229 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3230 if (i
!= ZEBRA_ROUTE_BGP
)
3231 bgp_redistribute_unset (bgp
, afi
, i
, 0);
3233 /* Free peers and peer-groups. */
3234 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, next
, group
))
3235 peer_group_delete (group
);
3237 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3240 if (bgp
->peer_self
) {
3241 peer_delete(bgp
->peer_self
);
3242 bgp
->peer_self
= NULL
;
3245 update_bgp_group_free (bgp
);
3247 /* TODO - Other memory may need to be freed - e.g., NHT */
3252 bgp_cleanup_routes(bgp
);
3254 /* Remove visibility via the master list - there may however still be
3255 * routes to be processed still referencing the struct bgp.
3257 listnode_delete (bm
->bgp
, bgp
);
3259 /* Deregister from Zebra, if needed */
3260 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3261 bgp_zebra_instance_deregister (bgp
);
3263 /* Free interfaces in this instance. */
3264 bgp_if_finish (bgp
);
3266 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3268 bgp_vrf_unlink (bgp
, vrf
);
3270 thread_master_free_unused(bm
->master
);
3271 bgp_unlock(bgp
); /* initial reference */
3276 static void bgp_free (struct bgp
*);
3279 bgp_lock (struct bgp
*bgp
)
3285 bgp_unlock(struct bgp
*bgp
)
3287 assert(bgp
->lock
> 0);
3288 if (--bgp
->lock
== 0)
3293 bgp_free (struct bgp
*bgp
)
3300 list_delete (bgp
->group
);
3301 list_delete (bgp
->peer
);
3305 hash_free(bgp
->peerhash
);
3306 bgp
->peerhash
= NULL
;
3309 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3310 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3312 if (bgp
->route
[afi
][safi
])
3313 bgp_table_finish (&bgp
->route
[afi
][safi
]);
3314 if (bgp
->aggregate
[afi
][safi
])
3315 bgp_table_finish (&bgp
->aggregate
[afi
][safi
]) ;
3316 if (bgp
->rib
[afi
][safi
])
3317 bgp_table_finish (&bgp
->rib
[afi
][safi
]);
3320 bgp_scan_finish (bgp
);
3321 bgp_address_destroy (bgp
);
3324 XFREE(MTYPE_BGP
, bgp
->name
);
3326 XFREE (MTYPE_BGP
, bgp
);
3330 peer_lookup_by_conf_if (struct bgp
*bgp
, const char *conf_if
)
3333 struct listnode
*node
, *nnode
;
3340 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3341 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3342 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3345 else if (bm
->bgp
!= NULL
)
3347 struct listnode
*bgpnode
, *nbgpnode
;
3349 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3350 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3351 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3352 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3359 peer_lookup_by_hostname (struct bgp
*bgp
, const char *hostname
)
3362 struct listnode
*node
, *nnode
;
3369 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3370 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3371 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3374 else if (bm
->bgp
!= NULL
)
3376 struct listnode
*bgpnode
, *nbgpnode
;
3378 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3379 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3380 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3381 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3388 peer_lookup (struct bgp
*bgp
, union sockunion
*su
)
3390 struct peer
*peer
= NULL
;
3391 struct peer tmp_peer
;
3393 memset(&tmp_peer
, 0, sizeof(struct peer
));
3396 * We do not want to find the doppelganger peer so search for the peer in
3397 * the hash that has PEER_FLAG_CONFIG_NODE
3399 SET_FLAG (tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3405 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3407 else if (bm
->bgp
!= NULL
)
3409 struct listnode
*bgpnode
, *nbgpnode
;
3411 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3413 /* Skip VRFs, this function will not be invoked without an instance
3414 * when examining VRFs.
3416 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3419 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3430 peer_create_bind_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
,
3431 struct peer_group
*group
)
3437 /* Create peer first; we've already checked group config is valid. */
3438 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
3443 peer
= peer_lock (peer
);
3444 listnode_add (group
->peer
, peer
);
3446 peer_group2peer_config_copy(group
, peer
);
3449 * Bind peer for all AFs configured for the group. We don't call
3450 * peer_group_bind as that is sub-optimal and does some stuff we don't want.
3452 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3453 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3455 if (!group
->conf
->afc
[afi
][safi
])
3457 peer
->afc
[afi
][safi
] = 1;
3459 if (!peer_af_find(peer
, afi
, safi
))
3460 peer_af_create(peer
, afi
, safi
);
3462 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
3465 /* Mark as dynamic, but also as a "config node" for other things to work. */
3466 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3467 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3473 peer_group_lookup_dynamic_neighbor_range (struct peer_group
* group
,
3474 struct prefix
* prefix
)
3476 struct listnode
*node
, *nnode
;
3477 struct prefix
*range
;
3480 afi
= family2afi(prefix
->family
);
3482 if (group
->listen_range
[afi
])
3483 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, range
))
3484 if (prefix_match(range
, prefix
))
3491 peer_group_lookup_dynamic_neighbor (struct bgp
*bgp
, struct prefix
*prefix
,
3492 struct prefix
**listen_range
)
3494 struct prefix
*range
= NULL
;
3495 struct peer_group
*group
= NULL
;
3496 struct listnode
*node
, *nnode
;
3498 *listen_range
= NULL
;
3501 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3502 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3505 else if (bm
->bgp
!= NULL
)
3507 struct listnode
*bgpnode
, *nbgpnode
;
3509 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3510 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3511 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3516 *listen_range
= range
;
3517 return (group
&& range
) ? group
: NULL
;
3521 peer_lookup_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
)
3523 struct peer_group
*group
;
3526 struct prefix prefix
;
3527 struct prefix
*listen_range
;
3529 char buf
[PREFIX2STR_BUFFER
];
3530 char buf1
[PREFIX2STR_BUFFER
];
3532 sockunion2hostprefix(su
, &prefix
);
3534 /* See if incoming connection matches a configured listen range. */
3535 group
= peer_group_lookup_dynamic_neighbor (bgp
, &prefix
, &listen_range
);
3546 prefix2str(&prefix
, buf
, sizeof(buf
));
3547 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3549 if (bgp_debug_neighbor_events(NULL
))
3550 zlog_debug ("Dynamic Neighbor %s matches group %s listen range %s",
3551 buf
, group
->name
, buf1
);
3553 /* Are we within the listen limit? */
3554 dncount
= gbgp
->dynamic_neighbors_count
;
3556 if (dncount
>= gbgp
->dynamic_neighbors_limit
)
3558 if (bgp_debug_neighbor_events(NULL
))
3559 zlog_debug ("Dynamic Neighbor %s rejected - at limit %d",
3560 inet_sutop (su
, buf
), gbgp
->dynamic_neighbors_limit
);
3564 /* Ensure group is not disabled. */
3565 if (CHECK_FLAG (group
->conf
->flags
, PEER_FLAG_SHUTDOWN
))
3567 if (bgp_debug_neighbor_events(NULL
))
3568 zlog_debug ("Dynamic Neighbor %s rejected - group %s disabled",
3573 /* Check that at least one AF is activated for the group. */
3574 if (!peer_group_af_configured (group
))
3576 if (bgp_debug_neighbor_events(NULL
))
3577 zlog_debug ("Dynamic Neighbor %s rejected - no AF activated for group %s",
3582 /* Create dynamic peer and bind to associated group. */
3583 peer
= peer_create_bind_dynamic_neighbor (gbgp
, su
, group
);
3586 gbgp
->dynamic_neighbors_count
= ++dncount
;
3588 if (bgp_debug_neighbor_events(peer
))
3589 zlog_debug ("%s Dynamic Neighbor added, group %s count %d",
3590 peer
->host
, group
->name
, dncount
);
3595 void peer_drop_dynamic_neighbor (struct peer
*peer
)
3598 if (peer
->group
&& peer
->group
->bgp
)
3600 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3602 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3604 if (bgp_debug_neighbor_events(peer
))
3605 zlog_debug ("%s dropped from group %s, count %d",
3606 peer
->host
, peer
->group
->name
, dncount
);
3610 /* If peer is configured at least one address family return 1. */
3612 peer_active (struct peer
*peer
)
3614 if (BGP_PEER_SU_UNSPEC(peer
))
3616 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
]
3617 || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3618 || peer
->afc
[AFI_IP
][SAFI_LABELED_UNICAST
]
3619 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
]
3620 || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3621 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3622 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3623 || peer
->afc
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3624 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3625 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
])
3630 /* If peer is negotiated at least one address family return 1. */
3632 peer_active_nego (struct peer
*peer
)
3634 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3635 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3636 || peer
->afc_nego
[AFI_IP
][SAFI_LABELED_UNICAST
]
3637 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3638 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3639 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3640 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3641 || peer
->afc_nego
[AFI_IP6
][SAFI_LABELED_UNICAST
]
3642 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3643 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
3648 /* peer_flag_change_type. */
3649 enum peer_change_type
3653 peer_change_reset_in
,
3654 peer_change_reset_out
,
3658 peer_change_action (struct peer
*peer
, afi_t afi
, safi_t safi
,
3659 enum peer_change_type type
)
3661 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3664 if (peer
->status
!= Established
)
3667 if (type
== peer_change_reset
)
3669 /* If we're resetting session, we've to delete both peer struct */
3670 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3671 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3672 PEER_FLAG_CONFIG_NODE
)))
3673 peer_delete(peer
->doppelganger
);
3675 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3676 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3678 else if (type
== peer_change_reset_in
)
3680 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3681 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3682 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
3685 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3686 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3687 PEER_FLAG_CONFIG_NODE
)))
3688 peer_delete(peer
->doppelganger
);
3690 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3691 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3694 else if (type
== peer_change_reset_out
)
3696 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3697 bgp_announce_route (peer
, afi
, safi
);
3701 struct peer_flag_action
3706 /* This flag can be set for peer-group member. */
3707 u_char not_for_member
;
3709 /* Action when the flag is changed. */
3710 enum peer_change_type type
;
3712 /* Peer down cause */
3716 static const struct peer_flag_action peer_flag_action_list
[] =
3718 { PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3719 { PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3720 { PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3721 { PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3722 { PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3723 { PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3724 { PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3725 { PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3729 static const struct peer_flag_action peer_af_flag_action_list
[] =
3731 { PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3732 { PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3733 { PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3734 { PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3735 { PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3736 { PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3737 { PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3738 { PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3739 { PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3740 { PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3741 // PEER_FLAG_DEFAULT_ORIGINATE
3742 { PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3743 { PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3744 { PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3745 { PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3746 { PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3747 // PEER_FLAG_MAX_PREFIX
3748 // PEER_FLAG_MAX_PREFIX_WARNING
3749 { PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3750 { PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3751 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3752 { PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
,1, peer_change_reset_out
},
3753 { PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3754 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
,1, peer_change_reset_out
},
3755 { PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3756 { PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3757 { PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3761 /* Proper action set. */
3763 peer_flag_action_set (const struct peer_flag_action
*action_list
, int size
,
3764 struct peer_flag_action
*action
, u_int32_t flag
)
3770 const struct peer_flag_action
*match
= NULL
;
3772 /* Check peer's frag action. */
3773 for (i
= 0; i
< size
; i
++)
3775 match
= &action_list
[i
];
3777 if (match
->flag
== 0)
3780 if (match
->flag
& flag
)
3784 if (match
->type
== peer_change_reset_in
)
3786 if (match
->type
== peer_change_reset_out
)
3788 if (match
->type
== peer_change_reset
)
3793 if (match
->not_for_member
)
3794 action
->not_for_member
= 1;
3798 /* Set peer clear type. */
3799 if (reset_in
&& reset_out
)
3800 action
->type
= peer_change_reset
;
3802 action
->type
= peer_change_reset_in
;
3804 action
->type
= peer_change_reset_out
;
3806 action
->type
= peer_change_none
;
3812 peer_flag_modify_action (struct peer
*peer
, u_int32_t flag
)
3814 if (flag
== PEER_FLAG_SHUTDOWN
)
3816 if (CHECK_FLAG (peer
->flags
, flag
))
3818 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3819 peer_nsf_stop (peer
);
3821 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3822 if (peer
->t_pmax_restart
)
3824 BGP_TIMER_OFF (peer
->t_pmax_restart
);
3825 if (bgp_debug_neighbor_events(peer
))
3826 zlog_debug ("%s Maximum-prefix restart timer canceled",
3830 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3831 peer_nsf_stop (peer
);
3833 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3835 char *msg
= peer
->tx_shutdown_message
;
3838 if (!msg
&& peer_group_active (peer
))
3839 msg
= peer
->group
->conf
->tx_shutdown_message
;
3840 msglen
= msg
? strlen(msg
) : 0;
3849 memcpy(msgbuf
+ 1, msg
, msglen
);
3851 bgp_notify_send_with_data (peer
, BGP_NOTIFY_CEASE
,
3852 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3853 msgbuf
, msglen
+ 1);
3856 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3857 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3860 bgp_session_reset(peer
);
3864 peer
->v_start
= BGP_INIT_START_TIMER
;
3865 BGP_EVENT_ADD (peer
, BGP_Stop
);
3868 else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3870 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3871 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3872 else if (flag
== PEER_FLAG_PASSIVE
)
3873 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3874 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3875 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3877 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3878 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3881 bgp_session_reset(peer
);
3884 /* Change specified peer flag. */
3886 peer_flag_modify (struct peer
*peer
, u_int32_t flag
, int set
)
3890 struct peer_group
*group
;
3891 struct peer
*tmp_peer
;
3892 struct listnode
*node
, *nnode
;
3893 struct peer_flag_action action
;
3895 memset (&action
, 0, sizeof (struct peer_flag_action
));
3896 size
= sizeof peer_flag_action_list
/ sizeof (struct peer_flag_action
);
3898 found
= peer_flag_action_set (peer_flag_action_list
, size
, &action
, flag
);
3900 /* No flag action is found. */
3902 return BGP_ERR_INVALID_FLAG
;
3904 /* When unset the peer-group member's flag we have to check
3905 peer-group configuration. */
3906 if (! set
&& peer_group_active (peer
))
3907 if (CHECK_FLAG (peer
->group
->conf
->flags
, flag
))
3909 if (flag
== PEER_FLAG_SHUTDOWN
)
3910 return BGP_ERR_PEER_GROUP_SHUTDOWN
;
3913 /* Flag conflict check. */
3915 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
3916 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
3917 return BGP_ERR_PEER_FLAG_CONFLICT
;
3919 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3921 if (set
&& CHECK_FLAG (peer
->flags
, flag
) == flag
)
3923 if (! set
&& ! CHECK_FLAG (peer
->flags
, flag
))
3928 SET_FLAG (peer
->flags
, flag
);
3930 UNSET_FLAG (peer
->flags
, flag
);
3932 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3934 if (action
.type
== peer_change_reset
)
3935 peer_flag_modify_action (peer
, flag
);
3940 /* peer-group member updates. */
3941 group
= peer
->group
;
3943 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
3946 if (set
&& CHECK_FLAG (tmp_peer
->flags
, flag
) == flag
)
3949 if (! set
&& ! CHECK_FLAG (tmp_peer
->flags
, flag
))
3953 SET_FLAG (tmp_peer
->flags
, flag
);
3955 UNSET_FLAG (tmp_peer
->flags
, flag
);
3957 if (action
.type
== peer_change_reset
)
3958 peer_flag_modify_action (tmp_peer
, flag
);
3964 peer_flag_set (struct peer
*peer
, u_int32_t flag
)
3966 return peer_flag_modify (peer
, flag
, 1);
3970 peer_flag_unset (struct peer
*peer
, u_int32_t flag
)
3972 return peer_flag_modify (peer
, flag
, 0);
3976 peer_af_flag_modify (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
,
3981 struct listnode
*node
, *nnode
;
3982 struct peer_group
*group
;
3983 struct peer_flag_action action
;
3984 struct peer
*tmp_peer
;
3986 int addpath_tx_used
;
3988 memset (&action
, 0, sizeof (struct peer_flag_action
));
3989 size
= sizeof peer_af_flag_action_list
/ sizeof (struct peer_flag_action
);
3991 found
= peer_flag_action_set (peer_af_flag_action_list
, size
, &action
, flag
);
3993 /* No flag action is found. */
3995 return BGP_ERR_INVALID_FLAG
;
3997 /* Special check for reflector client. */
3998 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
3999 && peer_sort (peer
) != BGP_PEER_IBGP
)
4000 return BGP_ERR_NOT_INTERNAL_PEER
;
4002 /* Special check for remove-private-AS. */
4003 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
4004 && peer_sort (peer
) == BGP_PEER_IBGP
)
4005 return BGP_ERR_REMOVE_PRIVATE_AS
;
4007 /* as-override is not allowed for IBGP peers */
4008 if (flag
& PEER_FLAG_AS_OVERRIDE
4009 && peer_sort (peer
) == BGP_PEER_IBGP
)
4010 return BGP_ERR_AS_OVERRIDE
;
4012 /* When current flag configuration is same as requested one. */
4013 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4015 if (set
&& CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
) == flag
)
4017 if (! set
&& ! CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
))
4022 SET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4024 UNSET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4026 /* Execute action when peer is established. */
4027 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4028 && peer
->status
== Established
)
4030 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4031 bgp_clear_adj_in (peer
, afi
, safi
);
4034 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4035 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4036 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4037 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4038 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4039 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4040 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4041 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4043 peer_change_action (peer
, afi
, safi
, action
.type
);
4048 /* Peer group member updates. */
4049 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4051 group
= peer
->group
;
4053 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
4055 if (set
&& CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
) == flag
)
4058 if (! set
&& ! CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
))
4062 SET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4064 UNSET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4066 if (tmp_peer
->status
== Established
)
4068 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4069 bgp_clear_adj_in (tmp_peer
, afi
, safi
);
4072 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4073 tmp_peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4074 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4075 tmp_peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4076 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4077 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4078 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4079 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4081 peer_change_action (tmp_peer
, afi
, safi
, action
.type
);
4087 /* Track if addpath TX is in use */
4088 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
|PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4091 addpath_tx_used
= 0;
4095 addpath_tx_used
= 1;
4097 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)
4099 if (!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
))
4101 zlog_warn("%s: enabling bgp deterministic-med, this is required"\
4102 " for addpath-tx-bestpath-per-AS",
4104 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
4105 bgp_recalculate_all_bestpaths (bgp
);
4111 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, tmp_peer
))
4113 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
4114 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4116 addpath_tx_used
= 1;
4122 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4129 peer_af_flag_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4131 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 1);
4135 peer_af_flag_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4137 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 0);
4141 int peer_tx_shutdown_message_set (struct peer
*peer
, const char *msg
)
4143 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4144 peer
->tx_shutdown_message
= msg
? XSTRDUP (MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4148 int peer_tx_shutdown_message_unset (struct peer
*peer
)
4150 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4155 /* EBGP multihop configuration. */
4157 peer_ebgp_multihop_set (struct peer
*peer
, int ttl
)
4159 struct peer_group
*group
;
4160 struct listnode
*node
, *nnode
;
4163 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4166 /* see comment in peer_ttl_security_hops_set() */
4169 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4171 group
= peer
->group
;
4172 if (group
->conf
->gtsm_hops
!= 0)
4173 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4175 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
4177 if (peer1
->sort
== BGP_PEER_IBGP
)
4180 if (peer1
->gtsm_hops
!= 0)
4181 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4186 if (peer
->gtsm_hops
!= 0)
4187 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4193 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4195 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
)
4197 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4198 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4199 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4201 bgp_session_reset(peer
);
4206 group
= peer
->group
;
4207 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4209 if (peer
->sort
== BGP_PEER_IBGP
)
4212 peer
->ttl
= group
->conf
->ttl
;
4214 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4215 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4216 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4218 bgp_session_reset(peer
);
4225 peer_ebgp_multihop_unset (struct peer
*peer
)
4227 struct peer_group
*group
;
4228 struct listnode
*node
, *nnode
;
4230 if (peer
->sort
== BGP_PEER_IBGP
)
4233 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4234 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4236 if (peer_group_active (peer
))
4237 peer
->ttl
= peer
->group
->conf
->ttl
;
4241 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4243 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4244 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4245 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4247 bgp_session_reset(peer
);
4251 group
= peer
->group
;
4252 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4254 if (peer
->sort
== BGP_PEER_IBGP
)
4261 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4262 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4263 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4265 bgp_session_reset(peer
);
4272 /* Neighbor description. */
4274 peer_description_set (struct peer
*peer
, const char *desc
)
4277 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4279 peer
->desc
= XSTRDUP (MTYPE_PEER_DESC
, desc
);
4285 peer_description_unset (struct peer
*peer
)
4288 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4295 /* Neighbor update-source. */
4297 peer_update_source_if_set (struct peer
*peer
, const char *ifname
)
4299 struct peer_group
*group
;
4300 struct listnode
*node
, *nnode
;
4302 if (peer
->update_if
)
4304 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4305 && strcmp (peer
->update_if
, ifname
) == 0)
4308 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4309 peer
->update_if
= NULL
;
4312 if (peer
->update_source
)
4314 sockunion_free (peer
->update_source
);
4315 peer
->update_source
= NULL
;
4318 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4320 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4322 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4324 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4325 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4326 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4329 bgp_session_reset(peer
);
4333 /* peer-group member updates. */
4334 group
= peer
->group
;
4335 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4337 if (peer
->update_if
)
4339 if (strcmp (peer
->update_if
, ifname
) == 0)
4342 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4343 peer
->update_if
= NULL
;
4346 if (peer
->update_source
)
4348 sockunion_free (peer
->update_source
);
4349 peer
->update_source
= NULL
;
4352 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4354 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4356 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4357 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4358 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4361 bgp_session_reset(peer
);
4367 peer_update_source_addr_set (struct peer
*peer
, const union sockunion
*su
)
4369 struct peer_group
*group
;
4370 struct listnode
*node
, *nnode
;
4372 if (peer
->update_source
)
4374 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4375 && sockunion_cmp (peer
->update_source
, su
) == 0)
4377 sockunion_free (peer
->update_source
);
4378 peer
->update_source
= NULL
;
4381 if (peer
->update_if
)
4383 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4384 peer
->update_if
= NULL
;
4388 peer
->update_source
= sockunion_dup (su
);
4390 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4392 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4394 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4395 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4396 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4399 bgp_session_reset(peer
);
4403 /* peer-group member updates. */
4404 group
= peer
->group
;
4405 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4407 if (peer
->update_source
)
4409 if (sockunion_cmp (peer
->update_source
, su
) == 0)
4411 sockunion_free (peer
->update_source
);
4412 peer
->update_source
= NULL
;
4415 if (peer
->update_if
)
4417 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4418 peer
->update_if
= NULL
;
4421 peer
->update_source
= sockunion_dup (su
);
4423 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4425 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4426 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4427 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4430 bgp_session_reset(peer
);
4436 peer_update_source_unset (struct peer
*peer
)
4438 union sockunion
*su
;
4439 struct peer_group
*group
;
4440 struct listnode
*node
, *nnode
;
4442 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4443 && ! peer
->update_source
4444 && ! peer
->update_if
)
4447 if (peer
->update_source
)
4449 sockunion_free (peer
->update_source
);
4450 peer
->update_source
= NULL
;
4452 if (peer
->update_if
)
4454 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4455 peer
->update_if
= NULL
;
4458 if (peer_group_active (peer
))
4460 group
= peer
->group
;
4462 if (group
->conf
->update_source
)
4464 su
= sockunion_dup (group
->conf
->update_source
);
4465 peer
->update_source
= su
;
4467 else if (group
->conf
->update_if
)
4469 XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, group
->conf
->update_if
);
4472 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4474 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4476 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4477 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4478 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4481 bgp_session_reset(peer
);
4485 /* peer-group member updates. */
4486 group
= peer
->group
;
4487 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4489 if (! peer
->update_source
&& ! peer
->update_if
)
4492 if (peer
->update_source
)
4494 sockunion_free (peer
->update_source
);
4495 peer
->update_source
= NULL
;
4498 if (peer
->update_if
)
4500 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4501 peer
->update_if
= NULL
;
4504 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4506 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4507 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4508 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4511 bgp_session_reset(peer
);
4517 peer_default_originate_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
4520 struct peer_group
*group
;
4521 struct listnode
*node
, *nnode
;
4523 if (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
)
4524 || (rmap
&& ! peer
->default_rmap
[afi
][safi
].name
)
4525 || (rmap
&& strcmp (rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0))
4527 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4531 if (peer
->default_rmap
[afi
][safi
].name
)
4532 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4533 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4534 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4538 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4540 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4541 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4542 bgp_default_originate (peer
, afi
, safi
, 0);
4543 bgp_announce_route (peer
, afi
, safi
);
4548 /* peer-group member updates. */
4549 group
= peer
->group
;
4550 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4552 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4556 if (peer
->default_rmap
[afi
][safi
].name
)
4557 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4558 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4559 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4562 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4563 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4564 bgp_default_originate (peer
, afi
, safi
, 0);
4565 bgp_announce_route (peer
, afi
, safi
);
4572 peer_default_originate_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4574 struct peer_group
*group
;
4575 struct listnode
*node
, *nnode
;
4577 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
))
4579 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4581 if (peer
->default_rmap
[afi
][safi
].name
)
4582 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4583 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4584 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4587 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4589 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4590 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4591 bgp_default_originate (peer
, afi
, safi
, 1);
4592 bgp_announce_route (peer
, afi
, safi
);
4597 /* peer-group member updates. */
4598 group
= peer
->group
;
4599 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4601 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4603 if (peer
->default_rmap
[afi
][safi
].name
)
4604 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4605 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4606 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4608 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4609 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4610 bgp_default_originate (peer
, afi
, safi
, 1);
4611 bgp_announce_route (peer
, afi
, safi
);
4618 peer_port_set (struct peer
*peer
, u_int16_t port
)
4625 peer_port_unset (struct peer
*peer
)
4627 peer
->port
= BGP_PORT_DEFAULT
;
4632 * Helper function that is called after the name of the policy
4633 * being used by a peer has changed (AF specific). Automatically
4634 * initiates inbound or outbound processing as needed.
4637 peer_on_policy_change (struct peer
*peer
, afi_t afi
, safi_t safi
, int outbound
)
4641 update_group_adjust_peer (peer_af_find (peer
, afi
, safi
));
4642 if (peer
->status
== Established
)
4643 bgp_announce_route(peer
, afi
, safi
);
4647 if (peer
->status
!= Established
)
4650 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
4651 bgp_soft_reconfig_in (peer
, afi
, safi
);
4652 else if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4653 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4654 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
4659 /* neighbor weight. */
4661 peer_weight_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int16_t weight
)
4663 struct peer_group
*group
;
4664 struct listnode
*node
, *nnode
;
4666 if (peer
->weight
[afi
][safi
] != weight
)
4668 peer
->weight
[afi
][safi
] = weight
;
4669 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4670 peer_on_policy_change (peer
, afi
, safi
, 0);
4673 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4676 /* peer-group member updates. */
4677 group
= peer
->group
;
4678 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4680 if (peer
->weight
[afi
][safi
] != weight
)
4682 peer
->weight
[afi
][safi
] = weight
;
4683 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4684 peer_on_policy_change (peer
, afi
, safi
, 0);
4691 peer_weight_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4693 struct peer_group
*group
;
4694 struct listnode
*node
, *nnode
;
4696 /* not the peer-group itself but a peer in a peer-group */
4697 if (peer_group_active (peer
))
4699 group
= peer
->group
;
4701 /* inherit weight from the peer-group */
4702 if (CHECK_FLAG (group
->conf
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4704 peer
->weight
[afi
][safi
] = group
->conf
->weight
[afi
][safi
];
4705 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4706 peer_on_policy_change (peer
, afi
, safi
, 0);
4710 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4712 peer
->weight
[afi
][safi
] = 0;
4713 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4714 peer_on_policy_change (peer
, afi
, safi
, 0);
4721 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4723 peer
->weight
[afi
][safi
] = 0;
4724 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4725 peer_on_policy_change (peer
, afi
, safi
, 0);
4728 /* peer-group member updates. */
4729 group
= peer
->group
;
4733 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4735 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4737 peer
->weight
[afi
][safi
] = 0;
4738 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4739 peer_on_policy_change (peer
, afi
, safi
, 0);
4748 peer_timers_set (struct peer
*peer
, u_int32_t keepalive
, u_int32_t holdtime
)
4750 struct peer_group
*group
;
4751 struct listnode
*node
, *nnode
;
4753 /* keepalive value check. */
4754 if (keepalive
> 65535)
4755 return BGP_ERR_INVALID_VALUE
;
4757 /* Holdtime value check. */
4758 if (holdtime
> 65535)
4759 return BGP_ERR_INVALID_VALUE
;
4761 /* Holdtime value must be either 0 or greater than 3. */
4762 if (holdtime
< 3 && holdtime
!= 0)
4763 return BGP_ERR_INVALID_VALUE
;
4765 /* Set value to the configuration. */
4766 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4767 peer
->holdtime
= holdtime
;
4768 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4770 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4773 /* peer-group member updates. */
4774 group
= peer
->group
;
4775 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4777 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4778 peer
->holdtime
= group
->conf
->holdtime
;
4779 peer
->keepalive
= group
->conf
->keepalive
;
4785 peer_timers_unset (struct peer
*peer
)
4787 struct peer_group
*group
;
4788 struct listnode
*node
, *nnode
;
4790 /* Clear configuration. */
4791 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4792 peer
->keepalive
= 0;
4795 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4798 /* peer-group member updates. */
4799 group
= peer
->group
;
4800 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4802 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4804 peer
->keepalive
= 0;
4811 peer_timers_connect_set (struct peer
*peer
, u_int32_t connect
)
4813 struct peer_group
*group
;
4814 struct listnode
*node
, *nnode
;
4816 if (connect
> 65535)
4817 return BGP_ERR_INVALID_VALUE
;
4819 /* Set value to the configuration. */
4820 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4821 peer
->connect
= connect
;
4823 /* Set value to timer setting. */
4824 peer
->v_connect
= connect
;
4826 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4829 /* peer-group member updates. */
4830 group
= peer
->group
;
4831 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4833 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4834 peer
->connect
= connect
;
4835 peer
->v_connect
= connect
;
4841 peer_timers_connect_unset (struct peer
*peer
)
4843 struct peer_group
*group
;
4844 struct listnode
*node
, *nnode
;
4846 /* Clear configuration. */
4847 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4850 /* Set timer setting to default value. */
4851 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4853 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4856 /* peer-group member updates. */
4857 group
= peer
->group
;
4858 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4860 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4862 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4868 peer_advertise_interval_set (struct peer
*peer
, u_int32_t routeadv
)
4870 struct peer_group
*group
;
4871 struct listnode
*node
, *nnode
;
4874 return BGP_ERR_INVALID_VALUE
;
4876 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4877 peer
->routeadv
= routeadv
;
4878 peer
->v_routeadv
= routeadv
;
4880 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4881 update_group_adjust_peer_afs (peer
);
4882 if (peer
->status
== Established
)
4883 bgp_announce_route_all (peer
);
4887 /* peer-group member updates. */
4888 group
= peer
->group
;
4889 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4891 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4892 peer
->routeadv
= routeadv
;
4893 peer
->v_routeadv
= routeadv
;
4894 update_group_adjust_peer_afs (peer
);
4895 if (peer
->status
== Established
)
4896 bgp_announce_route_all (peer
);
4903 peer_advertise_interval_unset (struct peer
*peer
)
4905 struct peer_group
*group
;
4906 struct listnode
*node
, *nnode
;
4908 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4911 if (peer
->sort
== BGP_PEER_IBGP
)
4912 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4914 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4916 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4917 update_group_adjust_peer_afs (peer
);
4918 if (peer
->status
== Established
)
4919 bgp_announce_route_all (peer
);
4923 /* peer-group member updates. */
4924 group
= peer
->group
;
4925 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4927 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4930 if (peer
->sort
== BGP_PEER_IBGP
)
4931 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4933 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4935 update_group_adjust_peer_afs (peer
);
4936 if (peer
->status
== Established
)
4937 bgp_announce_route_all (peer
);
4943 /* neighbor interface */
4945 peer_interface_set (struct peer
*peer
, const char *str
)
4948 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4949 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
4953 peer_interface_unset (struct peer
*peer
)
4956 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4957 peer
->ifname
= NULL
;
4962 peer_allowas_in_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int allow_num
,
4965 struct peer_group
*group
;
4966 struct listnode
*node
, *nnode
;
4970 if (peer
->allowas_in
[afi
][safi
] ||
4971 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
4972 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
4974 peer
->allowas_in
[afi
][safi
] = 0;
4975 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4976 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4977 peer_on_policy_change (peer
, afi
, safi
, 0);
4980 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4983 group
= peer
->group
;
4984 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4986 if (peer
->allowas_in
[afi
][safi
] ||
4987 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
4988 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
4990 peer
->allowas_in
[afi
][safi
] = 0;
4991 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4992 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4993 peer_on_policy_change (peer
, afi
, safi
, 0);
4999 if (allow_num
< 1 || allow_num
> 10)
5000 return BGP_ERR_INVALID_VALUE
;
5002 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
5003 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5005 peer
->allowas_in
[afi
][safi
] = allow_num
;
5006 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5007 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5008 peer_on_policy_change (peer
, afi
, safi
, 0);
5011 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5014 group
= peer
->group
;
5015 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5017 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
5018 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5020 peer
->allowas_in
[afi
][safi
] = allow_num
;
5021 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5022 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5023 peer_on_policy_change (peer
, afi
, safi
, 0);
5032 peer_allowas_in_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5034 struct peer_group
*group
;
5035 struct peer
*tmp_peer
;
5036 struct listnode
*node
, *nnode
;
5038 /* If this is a peer-group we must first clear the flags for all of the
5039 * peer-group members
5041 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5043 group
= peer
->group
;
5044 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
5046 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5047 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5049 tmp_peer
->allowas_in
[afi
][safi
] = 0;
5050 peer_af_flag_unset (tmp_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5051 peer_af_flag_unset (tmp_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5052 peer_on_policy_change (tmp_peer
, afi
, safi
, 0);
5057 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5058 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5060 peer
->allowas_in
[afi
][safi
] = 0;
5061 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5062 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5063 peer_on_policy_change (peer
, afi
, safi
, 0);
5070 peer_local_as_set (struct peer
*peer
, as_t as
, int no_prepend
, int replace_as
)
5072 struct bgp
*bgp
= peer
->bgp
;
5073 struct peer_group
*group
;
5074 struct listnode
*node
, *nnode
;
5076 if (peer_sort (peer
) != BGP_PEER_EBGP
5077 && peer_sort (peer
) != BGP_PEER_INTERNAL
)
5078 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5081 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5084 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5086 if (peer
->change_local_as
== as
&&
5087 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && no_prepend
)
5088 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && ! no_prepend
)) &&
5089 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && replace_as
)
5090 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && ! replace_as
)))
5093 peer
->change_local_as
= as
;
5095 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5097 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5100 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5102 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5104 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5106 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5108 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5109 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5110 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5113 bgp_session_reset(peer
);
5117 group
= peer
->group
;
5118 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5120 peer
->change_local_as
= as
;
5122 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5124 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5127 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5129 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5131 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5133 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5134 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5135 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5138 BGP_EVENT_ADD (peer
, BGP_Stop
);
5145 peer_local_as_unset (struct peer
*peer
)
5147 struct peer_group
*group
;
5148 struct listnode
*node
, *nnode
;
5150 if (! peer
->change_local_as
)
5153 peer
->change_local_as
= 0;
5154 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5155 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5157 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5159 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5161 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5162 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5163 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5166 BGP_EVENT_ADD (peer
, BGP_Stop
);
5171 group
= peer
->group
;
5172 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5174 peer
->change_local_as
= 0;
5175 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5176 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5178 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5180 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5181 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5182 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5185 bgp_session_reset(peer
);
5190 /* Set password for authenticating with the peer. */
5192 peer_password_set (struct peer
*peer
, const char *password
)
5194 struct listnode
*nn
, *nnode
;
5195 int len
= password
? strlen(password
) : 0;
5196 int ret
= BGP_SUCCESS
;
5198 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5199 return BGP_ERR_INVALID_VALUE
;
5201 if (peer
->password
&& strcmp (peer
->password
, password
) == 0
5202 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5206 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5208 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, password
);
5210 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5212 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5213 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5215 bgp_session_reset(peer
);
5217 if (BGP_PEER_SU_UNSPEC(peer
))
5220 return (bgp_md5_set (peer
) >= 0) ? BGP_SUCCESS
: BGP_ERR_TCPSIG_FAILED
;
5223 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5225 if (peer
->password
&& strcmp (peer
->password
, password
) == 0)
5229 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5231 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5233 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5234 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5236 bgp_session_reset(peer
);
5238 if (! BGP_PEER_SU_UNSPEC(peer
))
5240 if (bgp_md5_set (peer
) < 0)
5241 ret
= BGP_ERR_TCPSIG_FAILED
;
5249 peer_password_unset (struct peer
*peer
)
5251 struct listnode
*nn
, *nnode
;
5254 && !CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5257 if (!CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5259 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5260 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5262 bgp_session_reset(peer
);
5265 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5267 peer
->password
= NULL
;
5269 if (! BGP_PEER_SU_UNSPEC(peer
))
5270 bgp_md5_unset (peer
);
5275 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5276 peer
->password
= NULL
;
5278 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5280 if (!peer
->password
)
5283 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5284 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5286 bgp_session_reset(peer
);
5288 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5289 peer
->password
= NULL
;
5291 if (! BGP_PEER_SU_UNSPEC(peer
))
5292 bgp_md5_unset (peer
);
5299 /* Set distribute list to the peer. */
5301 peer_distribute_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5304 struct bgp_filter
*filter
;
5305 struct peer_group
*group
;
5306 struct listnode
*node
, *nnode
;
5308 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5309 return BGP_ERR_INVALID_VALUE
;
5311 filter
= &peer
->filter
[afi
][safi
];
5313 if (filter
->plist
[direct
].name
)
5314 return BGP_ERR_PEER_FILTER_CONFLICT
;
5316 if (filter
->dlist
[direct
].name
)
5317 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5318 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5319 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5321 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5323 peer_on_policy_change(peer
, afi
, safi
,
5324 (direct
== FILTER_OUT
) ? 1 : 0);
5328 group
= peer
->group
;
5329 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5331 filter
= &peer
->filter
[afi
][safi
];
5333 if (filter
->dlist
[direct
].name
)
5334 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5335 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5336 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5337 peer_on_policy_change(peer
, afi
, safi
,
5338 (direct
== FILTER_OUT
) ? 1 : 0);
5345 peer_distribute_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5347 struct bgp_filter
*filter
;
5348 struct bgp_filter
*gfilter
;
5349 struct peer_group
*group
;
5350 struct listnode
*node
, *nnode
;
5352 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5353 return BGP_ERR_INVALID_VALUE
;
5355 filter
= &peer
->filter
[afi
][safi
];
5357 /* apply peer-group filter */
5358 if (peer_group_active(peer
))
5360 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5362 if (gfilter
->dlist
[direct
].name
)
5364 if (filter
->dlist
[direct
].name
)
5365 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5366 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[direct
].name
);
5367 filter
->dlist
[direct
].alist
= gfilter
->dlist
[direct
].alist
;
5368 peer_on_policy_change(peer
, afi
, safi
,
5369 (direct
== FILTER_OUT
) ? 1 : 0);
5374 if (filter
->dlist
[direct
].name
)
5375 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5376 filter
->dlist
[direct
].name
= NULL
;
5377 filter
->dlist
[direct
].alist
= NULL
;
5379 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5381 peer_on_policy_change(peer
, afi
, safi
,
5382 (direct
== FILTER_OUT
) ? 1 : 0);
5386 group
= peer
->group
;
5387 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5389 filter
= &peer
->filter
[afi
][safi
];
5391 if (filter
->dlist
[direct
].name
)
5392 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5393 filter
->dlist
[direct
].name
= NULL
;
5394 filter
->dlist
[direct
].alist
= NULL
;
5395 peer_on_policy_change(peer
, afi
, safi
,
5396 (direct
== FILTER_OUT
) ? 1 : 0);
5402 /* Update distribute list. */
5404 peer_distribute_update (struct access_list
*access
)
5409 struct listnode
*mnode
, *mnnode
;
5410 struct listnode
*node
, *nnode
;
5413 struct peer_group
*group
;
5414 struct bgp_filter
*filter
;
5416 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5419 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, access
->name
,
5421 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5423 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5424 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5426 filter
= &peer
->filter
[afi
][safi
];
5428 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5430 if (filter
->dlist
[direct
].name
)
5431 filter
->dlist
[direct
].alist
=
5432 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5434 filter
->dlist
[direct
].alist
= NULL
;
5438 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5440 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5441 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5443 filter
= &group
->conf
->filter
[afi
][safi
];
5445 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5447 if (filter
->dlist
[direct
].name
)
5448 filter
->dlist
[direct
].alist
=
5449 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5451 filter
->dlist
[direct
].alist
= NULL
;
5456 vnc_prefix_list_update(bgp
);
5461 /* Set prefix list to the peer. */
5463 peer_prefix_list_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5466 struct bgp_filter
*filter
;
5467 struct peer_group
*group
;
5468 struct listnode
*node
, *nnode
;
5470 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5471 return BGP_ERR_INVALID_VALUE
;
5473 filter
= &peer
->filter
[afi
][safi
];
5475 if (filter
->dlist
[direct
].name
)
5476 return BGP_ERR_PEER_FILTER_CONFLICT
;
5478 if (filter
->plist
[direct
].name
)
5479 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5480 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5481 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5483 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5485 peer_on_policy_change(peer
, afi
, safi
,
5486 (direct
== FILTER_OUT
) ? 1 : 0);
5490 group
= peer
->group
;
5491 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5493 filter
= &peer
->filter
[afi
][safi
];
5495 if (filter
->plist
[direct
].name
)
5496 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5497 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5498 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5499 peer_on_policy_change(peer
, afi
, safi
,
5500 (direct
== FILTER_OUT
) ? 1 : 0);
5506 peer_prefix_list_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5508 struct bgp_filter
*filter
;
5509 struct bgp_filter
*gfilter
;
5510 struct peer_group
*group
;
5511 struct listnode
*node
, *nnode
;
5513 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5514 return BGP_ERR_INVALID_VALUE
;
5516 filter
= &peer
->filter
[afi
][safi
];
5518 /* apply peer-group filter */
5519 if (peer_group_active(peer
))
5521 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5523 if (gfilter
->plist
[direct
].name
)
5525 if (filter
->plist
[direct
].name
)
5526 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5527 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[direct
].name
);
5528 filter
->plist
[direct
].plist
= gfilter
->plist
[direct
].plist
;
5529 peer_on_policy_change(peer
, afi
, safi
,
5530 (direct
== FILTER_OUT
) ? 1 : 0);
5535 if (filter
->plist
[direct
].name
)
5536 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5537 filter
->plist
[direct
].name
= NULL
;
5538 filter
->plist
[direct
].plist
= NULL
;
5540 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5542 peer_on_policy_change(peer
, afi
, safi
,
5543 (direct
== FILTER_OUT
) ? 1 : 0);
5547 group
= peer
->group
;
5548 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5550 filter
= &peer
->filter
[afi
][safi
];
5552 if (filter
->plist
[direct
].name
)
5553 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5554 filter
->plist
[direct
].name
= NULL
;
5555 filter
->plist
[direct
].plist
= NULL
;
5556 peer_on_policy_change(peer
, afi
, safi
,
5557 (direct
== FILTER_OUT
) ? 1 : 0);
5563 /* Update prefix-list list. */
5565 peer_prefix_list_update (struct prefix_list
*plist
)
5567 struct listnode
*mnode
, *mnnode
;
5568 struct listnode
*node
, *nnode
;
5571 struct peer_group
*group
;
5572 struct bgp_filter
*filter
;
5577 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5581 * Update the prefix-list on update groups.
5583 update_group_policy_update(bgp
, BGP_POLICY_PREFIX_LIST
,
5584 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5586 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5588 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5589 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5591 filter
= &peer
->filter
[afi
][safi
];
5593 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5595 if (filter
->plist
[direct
].name
)
5596 filter
->plist
[direct
].plist
=
5597 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5599 filter
->plist
[direct
].plist
= NULL
;
5603 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5605 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5606 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5608 filter
= &group
->conf
->filter
[afi
][safi
];
5610 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5612 if (filter
->plist
[direct
].name
)
5613 filter
->plist
[direct
].plist
=
5614 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5616 filter
->plist
[direct
].plist
= NULL
;
5624 peer_aslist_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5627 struct bgp_filter
*filter
;
5628 struct peer_group
*group
;
5629 struct listnode
*node
, *nnode
;
5631 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5632 return BGP_ERR_INVALID_VALUE
;
5634 filter
= &peer
->filter
[afi
][safi
];
5636 if (filter
->aslist
[direct
].name
)
5637 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5638 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5639 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5641 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5643 peer_on_policy_change(peer
, afi
, safi
,
5644 (direct
== FILTER_OUT
) ? 1 : 0);
5648 group
= peer
->group
;
5649 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5651 filter
= &peer
->filter
[afi
][safi
];
5653 if (filter
->aslist
[direct
].name
)
5654 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5655 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5656 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5657 peer_on_policy_change(peer
, afi
, safi
,
5658 (direct
== FILTER_OUT
) ? 1 : 0);
5664 peer_aslist_unset (struct peer
*peer
,afi_t afi
, safi_t safi
, int direct
)
5666 struct bgp_filter
*filter
;
5667 struct bgp_filter
*gfilter
;
5668 struct peer_group
*group
;
5669 struct listnode
*node
, *nnode
;
5671 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5672 return BGP_ERR_INVALID_VALUE
;
5674 filter
= &peer
->filter
[afi
][safi
];
5676 /* apply peer-group filter */
5677 if (peer_group_active(peer
))
5679 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5681 if (gfilter
->aslist
[direct
].name
)
5683 if (filter
->aslist
[direct
].name
)
5684 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5685 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[direct
].name
);
5686 filter
->aslist
[direct
].aslist
= gfilter
->aslist
[direct
].aslist
;
5687 peer_on_policy_change(peer
, afi
, safi
,
5688 (direct
== FILTER_OUT
) ? 1 : 0);
5693 if (filter
->aslist
[direct
].name
)
5694 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5695 filter
->aslist
[direct
].name
= NULL
;
5696 filter
->aslist
[direct
].aslist
= NULL
;
5698 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5700 peer_on_policy_change(peer
, afi
, safi
,
5701 (direct
== FILTER_OUT
) ? 1 : 0);
5705 group
= peer
->group
;
5706 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5708 filter
= &peer
->filter
[afi
][safi
];
5710 if (filter
->aslist
[direct
].name
)
5711 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5712 filter
->aslist
[direct
].name
= NULL
;
5713 filter
->aslist
[direct
].aslist
= NULL
;
5714 peer_on_policy_change(peer
, afi
, safi
,
5715 (direct
== FILTER_OUT
) ? 1 : 0);
5722 peer_aslist_update (const char *aslist_name
)
5727 struct listnode
*mnode
, *mnnode
;
5728 struct listnode
*node
, *nnode
;
5731 struct peer_group
*group
;
5732 struct bgp_filter
*filter
;
5734 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5736 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, aslist_name
,
5739 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5741 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5742 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5744 filter
= &peer
->filter
[afi
][safi
];
5746 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5748 if (filter
->aslist
[direct
].name
)
5749 filter
->aslist
[direct
].aslist
=
5750 as_list_lookup (filter
->aslist
[direct
].name
);
5752 filter
->aslist
[direct
].aslist
= NULL
;
5756 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5758 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5759 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5761 filter
= &group
->conf
->filter
[afi
][safi
];
5763 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5765 if (filter
->aslist
[direct
].name
)
5766 filter
->aslist
[direct
].aslist
=
5767 as_list_lookup (filter
->aslist
[direct
].name
);
5769 filter
->aslist
[direct
].aslist
= NULL
;
5777 peer_aslist_add (char *aslist_name
)
5779 peer_aslist_update (aslist_name
);
5780 route_map_notify_dependencies((char *)aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
5784 peer_aslist_del (const char *aslist_name
)
5786 peer_aslist_update (aslist_name
);
5787 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
5792 peer_route_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5795 struct bgp_filter
*filter
;
5796 struct peer_group
*group
;
5797 struct listnode
*node
, *nnode
;
5799 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5800 return BGP_ERR_INVALID_VALUE
;
5802 filter
= &peer
->filter
[afi
][safi
];
5804 if (filter
->map
[direct
].name
)
5805 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5807 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5808 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5810 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5812 peer_on_policy_change(peer
, afi
, safi
,
5813 (direct
== RMAP_OUT
) ? 1 : 0);
5817 group
= peer
->group
;
5818 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5820 filter
= &peer
->filter
[afi
][safi
];
5822 if (filter
->map
[direct
].name
)
5823 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5824 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5825 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5826 peer_on_policy_change(peer
, afi
, safi
,
5827 (direct
== RMAP_OUT
) ? 1 : 0);
5832 /* Unset route-map from the peer. */
5834 peer_route_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5836 struct bgp_filter
*filter
;
5837 struct bgp_filter
*gfilter
;
5838 struct peer_group
*group
;
5839 struct listnode
*node
, *nnode
;
5841 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5842 return BGP_ERR_INVALID_VALUE
;
5844 filter
= &peer
->filter
[afi
][safi
];
5846 /* apply peer-group filter */
5847 if (peer_group_active(peer
))
5849 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5851 if (gfilter
->map
[direct
].name
)
5853 if (filter
->map
[direct
].name
)
5854 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5855 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[direct
].name
);
5856 filter
->map
[direct
].map
= gfilter
->map
[direct
].map
;
5857 peer_on_policy_change(peer
, afi
, safi
,
5858 (direct
== RMAP_OUT
) ? 1 : 0);
5863 if (filter
->map
[direct
].name
)
5864 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5865 filter
->map
[direct
].name
= NULL
;
5866 filter
->map
[direct
].map
= NULL
;
5868 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5870 peer_on_policy_change(peer
, afi
, safi
,
5871 (direct
== RMAP_OUT
) ? 1 : 0);
5875 group
= peer
->group
;
5876 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5878 filter
= &peer
->filter
[afi
][safi
];
5880 if (filter
->map
[direct
].name
)
5881 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5882 filter
->map
[direct
].name
= NULL
;
5883 filter
->map
[direct
].map
= NULL
;
5884 peer_on_policy_change(peer
, afi
, safi
,
5885 (direct
== RMAP_OUT
) ? 1 : 0);
5890 /* Set unsuppress-map to the peer. */
5892 peer_unsuppress_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5895 struct bgp_filter
*filter
;
5896 struct peer_group
*group
;
5897 struct listnode
*node
, *nnode
;
5899 filter
= &peer
->filter
[afi
][safi
];
5901 if (filter
->usmap
.name
)
5902 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5904 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5905 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5907 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5909 peer_on_policy_change(peer
, afi
, safi
, 1);
5913 group
= peer
->group
;
5914 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5916 filter
= &peer
->filter
[afi
][safi
];
5918 if (filter
->usmap
.name
)
5919 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5920 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5921 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5922 peer_on_policy_change(peer
, afi
, safi
, 1);
5927 /* Unset route-map from the peer. */
5929 peer_unsuppress_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5931 struct bgp_filter
*filter
;
5932 struct peer_group
*group
;
5933 struct listnode
*node
, *nnode
;
5935 filter
= &peer
->filter
[afi
][safi
];
5937 if (filter
->usmap
.name
)
5938 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5939 filter
->usmap
.name
= NULL
;
5940 filter
->usmap
.map
= NULL
;
5942 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5944 peer_on_policy_change(peer
, afi
, safi
, 1);
5948 group
= peer
->group
;
5949 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5951 filter
= &peer
->filter
[afi
][safi
];
5953 if (filter
->usmap
.name
)
5954 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5955 filter
->usmap
.name
= NULL
;
5956 filter
->usmap
.map
= NULL
;
5957 peer_on_policy_change(peer
, afi
, safi
, 1);
5963 peer_maximum_prefix_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5964 u_int32_t max
, u_char threshold
,
5965 int warning
, u_int16_t restart
)
5967 struct peer_group
*group
;
5968 struct listnode
*node
, *nnode
;
5970 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5971 peer
->pmax
[afi
][safi
] = max
;
5972 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5973 peer
->pmax_restart
[afi
][safi
] = restart
;
5975 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5977 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5979 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5981 group
= peer
->group
;
5982 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5984 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5985 peer
->pmax
[afi
][safi
] = max
;
5986 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5987 peer
->pmax_restart
[afi
][safi
] = restart
;
5989 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5991 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5993 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5994 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
5999 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
6000 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
6007 peer_maximum_prefix_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
6009 struct peer_group
*group
;
6010 struct listnode
*node
, *nnode
;
6012 /* apply peer-group config */
6013 if (peer_group_active(peer
))
6015 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6016 PEER_FLAG_MAX_PREFIX
))
6017 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6019 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6021 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6022 PEER_FLAG_MAX_PREFIX_WARNING
))
6023 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6025 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6027 peer
->pmax
[afi
][safi
] = peer
->group
->conf
->pmax
[afi
][safi
];
6028 peer
->pmax_threshold
[afi
][safi
] = peer
->group
->conf
->pmax_threshold
[afi
][safi
];
6029 peer
->pmax_restart
[afi
][safi
] = peer
->group
->conf
->pmax_restart
[afi
][safi
];
6033 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6034 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6035 peer
->pmax
[afi
][safi
] = 0;
6036 peer
->pmax_threshold
[afi
][safi
] = 0;
6037 peer
->pmax_restart
[afi
][safi
] = 0;
6039 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6042 group
= peer
->group
;
6043 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6045 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6046 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6047 peer
->pmax
[afi
][safi
] = 0;
6048 peer
->pmax_threshold
[afi
][safi
] = 0;
6049 peer
->pmax_restart
[afi
][safi
] = 0;
6054 int is_ebgp_multihop_configured (struct peer
*peer
)
6056 struct peer_group
*group
;
6057 struct listnode
*node
, *nnode
;
6060 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6062 group
= peer
->group
;
6063 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6064 (group
->conf
->ttl
!= 1))
6067 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
6069 if ((peer_sort (peer1
) != BGP_PEER_IBGP
) &&
6076 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6083 /* Set # of hops between us and BGP peer. */
6085 peer_ttl_security_hops_set (struct peer
*peer
, int gtsm_hops
)
6087 struct peer_group
*group
;
6088 struct listnode
*node
, *nnode
;
6091 zlog_debug ("peer_ttl_security_hops_set: set gtsm_hops to %d for %s", gtsm_hops
, peer
->host
);
6093 /* We cannot configure ttl-security hops when ebgp-multihop is already
6094 set. For non peer-groups, the check is simple. For peer-groups, it's
6095 slightly messy, because we need to check both the peer-group structure
6096 and all peer-group members for any trace of ebgp-multihop configuration
6097 before actually applying the ttl-security rules. Cisco really made a
6098 mess of this configuration parameter, and OpenBGPD got it right.
6101 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
))
6103 if (is_ebgp_multihop_configured (peer
))
6104 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6106 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6108 peer
->gtsm_hops
= gtsm_hops
;
6110 /* Calling ebgp multihop also resets the session.
6111 * On restart, NHT will get setup correctly as will the
6112 * min & max ttls on the socket. The return value is
6115 ret
= peer_ebgp_multihop_set (peer
, MAXTTL
);
6122 group
= peer
->group
;
6123 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6125 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6127 /* Calling ebgp multihop also resets the session.
6128 * On restart, NHT will get setup correctly as will the
6129 * min & max ttls on the socket. The return value is
6132 peer_ebgp_multihop_set (peer
, MAXTTL
);
6138 /* Post the first gtsm setup or if its ibgp, maxttl setting isn't
6139 * necessary, just set the minttl.
6141 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6143 peer
->gtsm_hops
= gtsm_hops
;
6146 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6147 MAXTTL
+ 1 - gtsm_hops
);
6148 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6149 (peer
->doppelganger
->fd
>= 0))
6150 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6151 MAXTTL
+ 1 - gtsm_hops
);
6155 group
= peer
->group
;
6156 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6158 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6160 /* Change setting of existing peer
6161 * established then change value (may break connectivity)
6162 * not established yet (teardown session and restart)
6163 * no session then do nothing (will get handled by next connection)
6165 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6166 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6167 MAXTTL
+ 1 - peer
->gtsm_hops
);
6168 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6169 (peer
->doppelganger
->fd
>= 0))
6170 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6171 MAXTTL
+ 1 - gtsm_hops
);
6181 peer_ttl_security_hops_unset (struct peer
*peer
)
6183 struct peer_group
*group
;
6184 struct listnode
*node
, *nnode
;
6187 zlog_debug ("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s", peer
->host
);
6189 /* if a peer-group member, then reset to peer-group default rather than 0 */
6190 if (peer_group_active (peer
))
6191 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6193 peer
->gtsm_hops
= 0;
6195 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6197 /* Invoking ebgp_multihop_set will set the TTL back to the original
6198 * value as well as restting the NHT and such. The session is reset.
6200 if (peer
->sort
== BGP_PEER_EBGP
)
6201 ret
= peer_ebgp_multihop_unset (peer
);
6205 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6207 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6208 (peer
->doppelganger
->fd
>= 0))
6209 sockopt_minttl (peer
->su
.sa
.sa_family
,
6210 peer
->doppelganger
->fd
, 0);
6215 group
= peer
->group
;
6216 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6218 peer
->gtsm_hops
= 0;
6219 if (peer
->sort
== BGP_PEER_EBGP
)
6220 ret
= peer_ebgp_multihop_unset (peer
);
6224 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6226 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6227 (peer
->doppelganger
->fd
>= 0))
6228 sockopt_minttl (peer
->su
.sa
.sa_family
,
6229 peer
->doppelganger
->fd
, 0);
6238 * If peer clear is invoked in a loop for all peers on the BGP instance,
6239 * it may end up freeing the doppelganger, and if this was the next node
6240 * to the current node, we would end up accessing the freed next node.
6241 * Pass along additional parameter which can be updated if next node
6242 * is freed; only required when walking the peer list on BGP instance.
6245 peer_clear (struct peer
*peer
, struct listnode
**nnode
)
6247 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6249 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
6251 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6252 if (peer
->t_pmax_restart
)
6254 BGP_TIMER_OFF (peer
->t_pmax_restart
);
6255 if (bgp_debug_neighbor_events(peer
))
6256 zlog_debug ("%s Maximum-prefix restart timer canceled",
6259 BGP_EVENT_ADD (peer
, BGP_Start
);
6263 peer
->v_start
= BGP_INIT_START_TIMER
;
6264 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6265 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
6266 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6268 bgp_session_reset_safe(peer
, nnode
);
6274 peer_clear_soft (struct peer
*peer
, afi_t afi
, safi_t safi
,
6275 enum bgp_clear_type stype
)
6277 struct peer_af
*paf
;
6279 if (peer
->status
!= Established
)
6282 if (! peer
->afc
[afi
][safi
])
6283 return BGP_ERR_AF_UNCONFIGURED
;
6285 peer
->rtt
= sockopt_tcp_rtt (peer
->fd
);
6287 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
)
6289 /* Clear the "neighbor x.x.x.x default-originate" flag */
6290 paf
= peer_af_find (peer
, afi
, safi
);
6291 if (paf
&& paf
->subgroup
&&
6292 CHECK_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6293 UNSET_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6295 bgp_announce_route (peer
, afi
, safi
);
6298 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6300 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
)
6301 && (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
)
6302 || CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
6304 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6307 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
))
6308 prefix_type
= ORF_TYPE_PREFIX
;
6310 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6312 if (filter
->plist
[FILTER_IN
].plist
)
6314 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6315 bgp_route_refresh_send (peer
, afi
, safi
,
6316 prefix_type
, REFRESH_DEFER
, 1);
6317 bgp_route_refresh_send (peer
, afi
, safi
, prefix_type
,
6318 REFRESH_IMMEDIATE
, 0);
6322 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6323 bgp_route_refresh_send (peer
, afi
, safi
,
6324 prefix_type
, REFRESH_IMMEDIATE
, 1);
6326 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6332 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6333 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6335 /* If neighbor has soft reconfiguration inbound flag.
6336 Use Adj-RIB-In database. */
6337 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
6338 bgp_soft_reconfig_in (peer
, afi
, safi
);
6341 /* If neighbor has route refresh capability, send route refresh
6342 message to the peer. */
6343 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6344 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6345 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6347 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6353 /* Display peer uptime.*/
6355 peer_uptime (time_t uptime2
, char *buf
, size_t len
, u_char use_json
, json_object
*json
)
6360 /* Check buffer length. */
6361 if (len
< BGP_UPTIME_LEN
)
6365 zlog_warn ("peer_uptime (): buffer shortage %lu", (u_long
)len
);
6366 /* XXX: should return status instead of buf... */
6367 snprintf (buf
, len
, "<error> ");
6372 /* If there is no connection has been done before print `never'. */
6377 json_object_string_add(json
, "peerUptime", "never");
6378 json_object_int_add(json
, "peerUptimeMsec", 0);
6381 snprintf (buf
, len
, "never");
6385 /* Get current time. */
6386 uptime1
= bgp_clock ();
6388 tm
= gmtime (&uptime1
);
6390 /* Making formatted timer strings. */
6391 #define ONE_DAY_SECOND 60*60*24
6392 #define ONE_WEEK_SECOND ONE_DAY_SECOND*7
6393 #define ONE_YEAR_SECOND ONE_DAY_SECOND*365
6395 if (uptime1
< ONE_DAY_SECOND
)
6396 snprintf (buf
, len
, "%02d:%02d:%02d",
6397 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6398 else if (uptime1
< ONE_WEEK_SECOND
)
6399 snprintf (buf
, len
, "%dd%02dh%02dm",
6400 tm
->tm_yday
, tm
->tm_hour
, tm
->tm_min
);
6401 else if (uptime1
< ONE_YEAR_SECOND
)
6402 snprintf (buf
, len
, "%02dw%dd%02dh",
6403 tm
->tm_yday
/7, tm
->tm_yday
- ((tm
->tm_yday
/7) * 7), tm
->tm_hour
);
6405 snprintf (buf
, len
, "%02dy%02dw%dd",
6406 tm
->tm_year
- 70, tm
->tm_yday
/7,
6407 tm
->tm_yday
- ((tm
->tm_yday
/7) * 7));
6411 json_object_string_add(json
, "peerUptime", buf
);
6412 json_object_long_add(json
, "peerUptimeMsec", uptime1
* 1000);
6419 afi_header_vty_out (struct vty
*vty
, afi_t afi
, safi_t safi
,
6420 int *write
, const char *format
, ...)
6426 bgp_config_write_family_header (vty
, afi
, safi
, write
);
6428 if (vty_shell (vty
))
6430 va_start (args
, format
);
6431 vprintf (format
, args
);
6436 va_start (args
, format
);
6437 len
= vsnprintf (buf
, sizeof(buf
), format
, args
);
6440 buffer_put (vty
->obuf
, (u_char
*) buf
, len
);
6445 bgp_config_write_filter (struct vty
*vty
, struct peer
*peer
,
6446 afi_t afi
, safi_t safi
, int *write
)
6448 struct bgp_filter
*filter
;
6449 struct bgp_filter
*gfilter
= NULL
;
6452 int out
= FILTER_OUT
;
6455 filter
= &peer
->filter
[afi
][safi
];
6457 if (peer_group_active(peer
))
6458 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
6460 /* distribute-list. */
6461 if (filter
->dlist
[in
].name
)
6462 if (! gfilter
|| ! gfilter
->dlist
[in
].name
6463 || strcmp (filter
->dlist
[in
].name
, gfilter
->dlist
[in
].name
) != 0)
6465 afi_header_vty_out (vty
, afi
, safi
, write
,
6466 " neighbor %s distribute-list %s in%s",
6467 addr
, filter
->dlist
[in
].name
, VTY_NEWLINE
);
6470 if (filter
->dlist
[out
].name
&& ! gfilter
)
6472 afi_header_vty_out (vty
, afi
, safi
, write
,
6473 " neighbor %s distribute-list %s out%s",
6474 addr
, filter
->dlist
[out
].name
, VTY_NEWLINE
);
6478 if (filter
->plist
[in
].name
)
6479 if (! gfilter
|| ! gfilter
->plist
[in
].name
6480 || strcmp (filter
->plist
[in
].name
, gfilter
->plist
[in
].name
) != 0)
6482 afi_header_vty_out (vty
, afi
, safi
, write
,
6483 " neighbor %s prefix-list %s in%s",
6484 addr
, filter
->plist
[in
].name
, VTY_NEWLINE
);
6487 if (filter
->plist
[out
].name
&& ! gfilter
)
6489 afi_header_vty_out (vty
, afi
, safi
, write
,
6490 " neighbor %s prefix-list %s out%s",
6491 addr
, filter
->plist
[out
].name
, VTY_NEWLINE
);
6495 if (filter
->map
[RMAP_IN
].name
)
6496 if (! gfilter
|| ! gfilter
->map
[RMAP_IN
].name
6497 || strcmp (filter
->map
[RMAP_IN
].name
, gfilter
->map
[RMAP_IN
].name
) != 0)
6499 afi_header_vty_out (vty
, afi
, safi
, write
,
6500 " neighbor %s route-map %s in%s",
6501 addr
, filter
->map
[RMAP_IN
].name
, VTY_NEWLINE
);
6504 if (filter
->map
[RMAP_OUT
].name
)
6505 if (! gfilter
|| ! gfilter
->map
[RMAP_OUT
].name
6506 || strcmp (filter
->map
[RMAP_OUT
].name
, gfilter
->map
[RMAP_OUT
].name
) != 0)
6508 afi_header_vty_out (vty
, afi
, safi
, write
,
6509 " neighbor %s route-map %s out%s",
6510 addr
, filter
->map
[RMAP_OUT
].name
, VTY_NEWLINE
);
6513 /* unsuppress-map */
6514 if (filter
->usmap
.name
&& ! gfilter
)
6516 afi_header_vty_out (vty
, afi
, safi
, write
,
6517 " neighbor %s unsuppress-map %s%s",
6518 addr
, filter
->usmap
.name
, VTY_NEWLINE
);
6522 if (filter
->aslist
[in
].name
)
6523 if (! gfilter
|| ! gfilter
->aslist
[in
].name
6524 || strcmp (filter
->aslist
[in
].name
, gfilter
->aslist
[in
].name
) != 0)
6526 afi_header_vty_out (vty
, afi
, safi
, write
,
6527 " neighbor %s filter-list %s in%s",
6528 addr
, filter
->aslist
[in
].name
, VTY_NEWLINE
);
6531 if (filter
->aslist
[out
].name
&& ! gfilter
)
6533 afi_header_vty_out (vty
, afi
, safi
, write
,
6534 " neighbor %s filter-list %s out%s",
6535 addr
, filter
->aslist
[out
].name
, VTY_NEWLINE
);
6539 /* BGP peer configuration display function. */
6541 bgp_config_write_peer_global (struct vty
*vty
, struct bgp
*bgp
,
6544 struct peer
*g_peer
= NULL
;
6545 char buf
[SU_ADDRSTRLEN
];
6547 int if_pg_printed
= FALSE
;
6548 int if_ras_printed
= FALSE
;
6550 /* Skip dynamic neighbors. */
6551 if (peer_dynamic_neighbor (peer
))
6555 addr
= peer
->conf_if
;
6559 /************************************
6560 ****** Global to the neighbor ******
6561 ************************************/
6564 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6565 vty_out (vty
, " neighbor %s interface v6only", addr
);
6567 vty_out (vty
, " neighbor %s interface", addr
);
6569 if (peer_group_active (peer
))
6571 vty_out (vty
, " peer-group %s", peer
->group
->name
);
6572 if_pg_printed
= TRUE
;
6574 else if (peer
->as_type
== AS_SPECIFIED
)
6576 vty_out (vty
, " remote-as %u", peer
->as
);
6577 if_ras_printed
= TRUE
;
6579 else if (peer
->as_type
== AS_INTERNAL
)
6581 vty_out (vty
, " remote-as internal");
6582 if_ras_printed
= TRUE
;
6584 else if (peer
->as_type
== AS_EXTERNAL
)
6586 vty_out (vty
, " remote-as external");
6587 if_ras_printed
= TRUE
;
6590 vty_out (vty
, "%s", VTY_NEWLINE
);
6593 /* remote-as and peer-group */
6594 /* peer is a member of a peer-group */
6595 if (peer_group_active (peer
))
6597 g_peer
= peer
->group
->conf
;
6599 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
)
6601 if (peer
->as_type
== AS_SPECIFIED
)
6603 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6606 else if (peer
->as_type
== AS_INTERNAL
)
6608 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6610 else if (peer
->as_type
== AS_EXTERNAL
)
6612 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6616 /* For swpX peers we displayed the peer-group
6617 * via 'neighbor swpX interface peer-group WORD' */
6619 vty_out (vty
, " neighbor %s peer-group %s%s", addr
,
6620 peer
->group
->name
, VTY_NEWLINE
);
6623 /* peer is NOT a member of a peer-group */
6626 /* peer is a peer-group, declare the peer-group */
6627 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6629 vty_out (vty
, " neighbor %s peer-group%s", addr
,
6633 if (!if_ras_printed
)
6635 if (peer
->as_type
== AS_SPECIFIED
)
6637 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6640 else if (peer
->as_type
== AS_INTERNAL
)
6642 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6644 else if (peer
->as_type
== AS_EXTERNAL
)
6646 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6652 if (peer
->change_local_as
)
6654 if (! peer_group_active (peer
)
6655 || peer
->change_local_as
!= g_peer
->change_local_as
6656 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) !=
6657 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6658 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) !=
6659 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)))
6661 vty_out (vty
, " neighbor %s local-as %u%s%s%s", addr
,
6662 peer
->change_local_as
,
6663 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) ?
6665 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) ?
6666 " replace-as" : "", VTY_NEWLINE
);
6673 vty_out (vty
, " neighbor %s description %s%s", addr
, peer
->desc
,
6678 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6680 if (! peer_group_active (peer
) ||
6681 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_SHUTDOWN
) ||
6682 peer
->tx_shutdown_message
)
6684 if (peer
->tx_shutdown_message
)
6685 vty_out (vty
, " neighbor %s shutdown message %s%s", addr
,
6686 peer
->tx_shutdown_message
, VTY_NEWLINE
);
6688 vty_out (vty
, " neighbor %s shutdown%s", addr
, VTY_NEWLINE
);
6695 if (! peer_group_active (peer
) || ! g_peer
->bfd_info
)
6697 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6704 if (!peer_group_active (peer
)
6705 || ! g_peer
->password
6706 || strcmp (peer
->password
, g_peer
->password
) != 0)
6708 vty_out (vty
, " neighbor %s password %s%s", addr
, peer
->password
,
6714 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
))
6716 if (!peer_group_active (peer
))
6718 vty_out (vty
, " neighbor %s solo%s", addr
, VTY_NEWLINE
);
6723 if (peer
->port
!= BGP_PORT_DEFAULT
)
6725 vty_out (vty
, " neighbor %s port %d%s", addr
, peer
->port
,
6729 /* Local interface name */
6732 vty_out (vty
, " neighbor %s interface %s%s", addr
, peer
->ifname
,
6737 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_PASSIVE
))
6739 if (! peer_group_active (peer
) ||
6740 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_PASSIVE
))
6742 vty_out (vty
, " neighbor %s passive%s", addr
, VTY_NEWLINE
);
6747 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1 &&
6748 !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
))
6750 if (! peer_group_active (peer
) || g_peer
->ttl
!= peer
->ttl
)
6752 vty_out (vty
, " neighbor %s ebgp-multihop %d%s", addr
, peer
->ttl
,
6757 /* ttl-security hops */
6758 if (peer
->gtsm_hops
!= 0)
6760 if (! peer_group_active (peer
) || g_peer
->gtsm_hops
!= peer
->gtsm_hops
)
6762 vty_out (vty
, " neighbor %s ttl-security hops %d%s", addr
,
6763 peer
->gtsm_hops
, VTY_NEWLINE
);
6767 /* disable-connected-check */
6768 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6770 if (! peer_group_active (peer
) ||
6771 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6773 vty_out (vty
, " neighbor %s disable-connected-check%s", addr
, VTY_NEWLINE
);
6778 if (peer
->update_if
)
6780 if (! peer_group_active (peer
) || ! g_peer
->update_if
6781 || strcmp (g_peer
->update_if
, peer
->update_if
) != 0)
6783 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6784 peer
->update_if
, VTY_NEWLINE
);
6787 if (peer
->update_source
)
6789 if (! peer_group_active (peer
) || ! g_peer
->update_source
6790 || sockunion_cmp (g_peer
->update_source
,
6791 peer
->update_source
) != 0)
6793 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6794 sockunion2str (peer
->update_source
, buf
, SU_ADDRSTRLEN
),
6799 /* advertisement-interval */
6800 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
) &&
6801 ((! peer_group_active (peer
) && peer
->v_routeadv
!= BGP_DEFAULT_EBGP_ROUTEADV
) ||
6802 (peer_group_active (peer
) && peer
->v_routeadv
!= g_peer
->v_routeadv
)))
6804 vty_out (vty
, " neighbor %s advertisement-interval %d%s",
6805 addr
, peer
->v_routeadv
, VTY_NEWLINE
);
6809 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
) &&
6810 ((! peer_group_active (peer
) && (peer
->keepalive
!= BGP_DEFAULT_KEEPALIVE
|| peer
->holdtime
!= BGP_DEFAULT_HOLDTIME
)) ||
6811 (peer_group_active (peer
) && (peer
->keepalive
!= g_peer
->keepalive
|| peer
->holdtime
!= g_peer
->holdtime
))))
6813 vty_out (vty
, " neighbor %s timers %d %d%s", addr
,
6814 peer
->keepalive
, peer
->holdtime
, VTY_NEWLINE
);
6817 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_CONNECT
) &&
6818 ((! peer_group_active (peer
) && peer
->connect
!= BGP_DEFAULT_CONNECT_RETRY
) ||
6819 (peer_group_active (peer
) && peer
->connect
!= g_peer
->connect
)))
6822 vty_out (vty
, " neighbor %s timers connect %d%s", addr
,
6823 peer
->connect
, VTY_NEWLINE
);
6826 /* capability dynamic */
6827 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6829 if (! peer_group_active (peer
) ||
6830 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6832 vty_out (vty
, " neighbor %s capability dynamic%s", addr
,
6837 /* capability extended-nexthop */
6838 if (peer
->ifp
&& !CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6840 if (! peer_group_active (peer
) ||
6841 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6843 vty_out (vty
, " no neighbor %s capability extended-nexthop%s", addr
,
6848 if (!peer
->ifp
&& CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6850 if (! peer_group_active (peer
) ||
6851 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6853 vty_out (vty
, " neighbor %s capability extended-nexthop%s", addr
,
6858 /* dont-capability-negotiation */
6859 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6861 if (! peer_group_active (peer
) ||
6862 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6864 vty_out (vty
, " neighbor %s dont-capability-negotiate%s", addr
,
6869 /* override-capability */
6870 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6872 if (! peer_group_active (peer
) ||
6873 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6875 vty_out (vty
, " neighbor %s override-capability%s", addr
,
6880 /* strict-capability-match */
6881 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6883 if (! peer_group_active (peer
) ||
6884 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6886 vty_out (vty
, " neighbor %s strict-capability-match%s", addr
,
6892 /* BGP peer configuration display function. */
6894 bgp_config_write_peer_af (struct vty
*vty
, struct bgp
*bgp
,
6895 struct peer
*peer
, afi_t afi
, safi_t safi
,
6898 struct peer
*g_peer
= NULL
;
6901 /* Skip dynamic neighbors. */
6902 if (peer_dynamic_neighbor (peer
))
6906 addr
= peer
->conf_if
;
6910 /************************************
6911 ****** Per AF to the neighbor ******
6912 ************************************/
6913 if (peer_group_active (peer
))
6915 g_peer
= peer
->group
->conf
;
6917 /* If the peer-group is active but peer is not, print a 'no activate' */
6918 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
])
6920 afi_header_vty_out (vty
, afi
, safi
, write
,
6921 " no neighbor %s activate%s",
6925 /* If the peer-group is not active but peer is, print an 'activate' */
6926 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
])
6928 afi_header_vty_out (vty
, afi
, safi
, write
,
6929 " neighbor %s activate%s",
6935 if (peer
->afc
[afi
][safi
])
6937 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6939 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6941 afi_header_vty_out(vty
, afi
, safi
, write
,
6942 " neighbor %s activate%s",
6947 afi_header_vty_out (vty
, afi
, safi
, write
,
6948 " neighbor %s activate%s",
6953 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6955 if (!bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6957 afi_header_vty_out (vty
, afi
, safi
, write
,
6958 " no neighbor %s activate%s",
6965 /* addpath TX knobs */
6966 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
6968 afi_header_vty_out (vty
, afi
, safi
, write
,
6969 " neighbor %s addpath-tx-all-paths%s",
6973 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
6975 afi_header_vty_out (vty
, afi
, safi
, write
,
6976 " neighbor %s addpath-tx-bestpath-per-AS%s",
6980 /* ORF capability. */
6981 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) ||
6982 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6984 afi_header_vty_out (vty
, afi
, safi
, write
,
6985 " neighbor %s capability orf prefix-list",
6988 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) &&
6989 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6990 vty_out (vty
, " both");
6991 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
))
6992 vty_out (vty
, " send");
6994 vty_out (vty
, " receive");
6995 vty_out (vty
, "%s", VTY_NEWLINE
);
6998 /* Route reflector client. */
6999 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REFLECTOR_CLIENT
))
7001 afi_header_vty_out (vty
, afi
, safi
, write
,
7002 " neighbor %s route-reflector-client%s",
7006 /* next-hop-self force */
7007 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
7009 afi_header_vty_out (vty
, afi
, safi
, write
,
7010 " neighbor %s next-hop-self force%s",
7015 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
))
7017 afi_header_vty_out (vty
, afi
, safi
, write
,
7018 " neighbor %s next-hop-self%s",
7022 /* remove-private-AS */
7023 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
))
7025 afi_header_vty_out (vty
, afi
, safi
, write
,
7026 " neighbor %s remove-private-AS all replace-AS%s",
7030 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
))
7032 afi_header_vty_out (vty
, afi
, safi
, write
,
7033 " neighbor %s remove-private-AS replace-AS%s",
7037 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL
))
7039 afi_header_vty_out (vty
, afi
, safi
, write
,
7040 " neighbor %s remove-private-AS all%s",
7044 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS
))
7046 afi_header_vty_out (vty
, afi
, safi
, write
,
7047 " neighbor %s remove-private-AS%s",
7052 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
))
7054 afi_header_vty_out (vty
, afi
, safi
, write
,
7055 " neighbor %s as-override%s",
7059 /* send-community print. */
7060 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7062 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)
7063 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)
7064 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7066 afi_header_vty_out (vty
, afi
, safi
, write
,
7067 " neighbor %s send-community all%s",
7070 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7072 afi_header_vty_out (vty
, afi
, safi
, write
,
7073 " neighbor %s send-community large%s",
7076 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
))
7078 afi_header_vty_out (vty
, afi
, safi
, write
,
7079 " neighbor %s send-community extended%s",
7082 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
))
7084 afi_header_vty_out (vty
, afi
, safi
, write
,
7085 " neighbor %s send-community%s",
7091 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7092 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)) &&
7093 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7094 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)) &&
7095 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7096 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7098 afi_header_vty_out (vty
, afi
, safi
, write
,
7099 " no neighbor %s send-community all%s",
7102 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7103 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7105 afi_header_vty_out (vty
, afi
, safi
, write
,
7106 " no neighbor %s send-community large%s",
7109 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7110 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)))
7112 afi_header_vty_out (vty
, afi
, safi
, write
,
7113 " no neighbor %s send-community extended%s",
7116 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7117 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)))
7119 afi_header_vty_out (vty
, afi
, safi
, write
,
7120 " no neighbor %s send-community%s",
7125 /* Default information */
7126 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
) ||
7128 ((peer
->default_rmap
[afi
][safi
].name
&& !g_peer
->default_rmap
[afi
][safi
].name
) ||
7129 (!peer
->default_rmap
[afi
][safi
].name
&& g_peer
->default_rmap
[afi
][safi
].name
) ||
7130 (peer
->default_rmap
[afi
][safi
].name
&&
7131 strcmp(peer
->default_rmap
[afi
][safi
].name
, g_peer
->default_rmap
[afi
][safi
].name
)))))
7133 afi_header_vty_out (vty
, afi
, safi
, write
,
7134 " neighbor %s default-originate", addr
);
7135 if (peer
->default_rmap
[afi
][safi
].name
)
7136 vty_out (vty
, " route-map %s", peer
->default_rmap
[afi
][safi
].name
);
7137 vty_out (vty
, "%s", VTY_NEWLINE
);
7140 /* Soft reconfiguration inbound. */
7141 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
))
7143 afi_header_vty_out (vty
, afi
, safi
, write
,
7144 " neighbor %s soft-reconfiguration inbound%s",
7148 /* maximum-prefix. */
7149 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
7150 if (! peer_group_active(peer
)
7151 || g_peer
->pmax
[afi
][safi
] != peer
->pmax
[afi
][safi
]
7152 || g_peer
->pmax_threshold
[afi
][safi
] != peer
->pmax_threshold
[afi
][safi
]
7153 || CHECK_FLAG (g_peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
)
7154 != CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7156 afi_header_vty_out (vty
, afi
, safi
, write
,
7157 " neighbor %s maximum-prefix %lu",
7158 addr
, peer
->pmax
[afi
][safi
]);
7159 if (peer
->pmax_threshold
[afi
][safi
] != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
7160 vty_out (vty
, " %d", peer
->pmax_threshold
[afi
][safi
]);
7161 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7162 vty_out (vty
, " warning-only");
7163 if (peer
->pmax_restart
[afi
][safi
])
7164 vty_out (vty
, " restart %d", peer
->pmax_restart
[afi
][safi
]);
7165 vty_out (vty
, "%s", VTY_NEWLINE
);
7168 /* Route server client. */
7169 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_RSERVER_CLIENT
))
7171 afi_header_vty_out (vty
, afi
, safi
, write
,
7172 " neighbor %s route-server-client%s",
7176 /* Nexthop-local unchanged. */
7177 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
))
7179 afi_header_vty_out (vty
, afi
, safi
, write
,
7180 " neighbor %s nexthop-local unchanged%s",
7184 /* allowas-in <1-10> */
7185 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
))
7187 if (! peer_group_active (peer
)
7188 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)
7189 || peer
->allowas_in
[afi
][safi
] != g_peer
->allowas_in
[afi
][safi
])
7191 if (peer
->allowas_in
[afi
][safi
] == 3)
7193 afi_header_vty_out (vty
, afi
, safi
, write
,
7194 " neighbor %s allowas-in%s",
7199 afi_header_vty_out (vty
, afi
, safi
, write
,
7200 " neighbor %s allowas-in %d%s",
7201 addr
, peer
->allowas_in
[afi
][safi
], VTY_NEWLINE
);
7206 /* allowas-in origin */
7207 else if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7209 if (! peer_group_active (peer
)
7210 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7212 afi_header_vty_out (vty
, afi
, safi
, write
,
7213 " neighbor %s allowas-in origin%s",
7219 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7220 if (! peer_group_active (peer
)
7221 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_WEIGHT
)
7222 || peer
->weight
[afi
][safi
] != g_peer
->weight
[afi
][safi
])
7224 if (peer
->weight
[afi
][safi
])
7226 afi_header_vty_out (vty
, afi
, safi
, write
,
7227 " neighbor %s weight %d%s",
7228 addr
, peer
->weight
[afi
][safi
], VTY_NEWLINE
);
7233 bgp_config_write_filter (vty
, peer
, afi
, safi
, write
);
7235 /* atribute-unchanged. */
7236 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_AS_PATH_UNCHANGED
)
7237 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_NEXTHOP_UNCHANGED
)
7238 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MED_UNCHANGED
))
7240 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7241 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
)
7242 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
))
7244 afi_header_vty_out (vty
, afi
, safi
, write
,
7245 " neighbor %s attribute-unchanged%s",
7250 afi_header_vty_out (vty
, afi
, safi
, write
,
7251 " neighbor %s attribute-unchanged%s%s%s%s", addr
,
7252 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
) ?
7254 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
) ?
7256 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
) ?
7257 " med" : "", VTY_NEWLINE
);
7262 /* Display "address-family" configuration header. */
7264 bgp_config_write_family_header (struct vty
*vty
, afi_t afi
, safi_t safi
,
7270 vty_out (vty
, " !%s address-family ", VTY_NEWLINE
);
7274 if (safi
== SAFI_UNICAST
)
7275 vty_out (vty
, "ipv4 unicast");
7276 else if (safi
== SAFI_LABELED_UNICAST
)
7277 vty_out (vty
, "ipv4 labeled-unicast");
7278 else if (safi
== SAFI_MULTICAST
)
7279 vty_out (vty
, "ipv4 multicast");
7280 else if (safi
== SAFI_MPLS_VPN
)
7281 vty_out (vty
, "ipv4 vpn");
7282 else if (safi
== SAFI_ENCAP
)
7283 vty_out (vty
, "ipv4 encap");
7285 else if (afi
== AFI_IP6
)
7287 if (safi
== SAFI_UNICAST
)
7288 vty_out (vty
, "ipv6 unicast");
7289 else if (safi
== SAFI_LABELED_UNICAST
)
7290 vty_out (vty
, "ipv6 labeled-unicast");
7291 else if (safi
== SAFI_MULTICAST
)
7292 vty_out (vty
, "ipv6 multicast");
7293 else if (safi
== SAFI_MPLS_VPN
)
7294 vty_out (vty
, "ipv6 vpn");
7295 else if (safi
== SAFI_ENCAP
)
7296 vty_out (vty
, "ipv6 encap");
7298 else if (afi
== AFI_L2VPN
)
7300 if (safi
== SAFI_EVPN
)
7301 vty_out (vty
, "l2vpn evpn");
7303 vty_out (vty
, "%s", VTY_NEWLINE
);
7308 /* Address family based peer configuration display. */
7310 bgp_config_write_family (struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7315 struct peer_group
*group
;
7316 struct listnode
*node
, *nnode
;
7318 bgp_config_write_distance (vty
, bgp
, afi
, safi
, &write
);
7320 bgp_config_write_network (vty
, bgp
, afi
, safi
, &write
);
7322 bgp_config_write_redistribute (vty
, bgp
, afi
, safi
, &write
);
7324 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7325 bgp_config_write_peer_af (vty
, bgp
, group
->conf
, afi
, safi
, &write
);
7327 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7329 /* Skip dynamic neighbors. */
7330 if (peer_dynamic_neighbor (peer
))
7333 /* Do not display doppelganger peers */
7334 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7335 bgp_config_write_peer_af (vty
, bgp
, peer
, afi
, safi
, &write
);
7338 bgp_config_write_maxpaths (vty
, bgp
, afi
, safi
, &write
);
7339 bgp_config_write_table_map (vty
, bgp
, afi
, safi
, &write
);
7342 vty_out (vty
, " exit-address-family%s", VTY_NEWLINE
);
7348 bgp_config_write (struct vty
*vty
)
7352 struct peer_group
*group
;
7354 struct listnode
*node
, *nnode
;
7355 struct listnode
*mnode
, *mnnode
;
7357 /* BGP Multiple instance. */
7358 if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7360 vty_out (vty
, "no bgp multiple-instance%s", VTY_NEWLINE
);
7364 /* BGP Config type. */
7365 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7367 vty_out (vty
, "bgp config-type cisco%s", VTY_NEWLINE
);
7371 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7372 vty_out (vty
, "bgp route-map delay-timer %d%s", bm
->rmap_update_timer
,
7375 /* BGP configuration. */
7376 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7379 vty_out (vty
, "!%s", VTY_NEWLINE
);
7381 /* Router bgp ASN */
7382 vty_out (vty
, "router bgp %u", bgp
->as
);
7384 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7387 vty_out (vty
, " %s %s",
7388 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
) ?
7389 "view" : "vrf", bgp
->name
);
7391 vty_out (vty
, "%s", VTY_NEWLINE
);
7393 /* No Synchronization */
7394 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7395 vty_out (vty
, " no synchronization%s", VTY_NEWLINE
);
7397 /* BGP fast-external-failover. */
7398 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7399 vty_out (vty
, " no bgp fast-external-failover%s", VTY_NEWLINE
);
7401 /* BGP router ID. */
7402 if (bgp
->router_id_static
.s_addr
!= 0)
7403 vty_out (vty
, " bgp router-id %s%s",
7404 inet_ntoa (bgp
->router_id_static
), VTY_NEWLINE
);
7406 /* BGP log-neighbor-changes. */
7407 if (!!bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7408 != DFLT_BGP_LOG_NEIGHBOR_CHANGES
)
7409 vty_out (vty
, " %sbgp log-neighbor-changes%s",
7410 bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
) ? "" : "no ",
7413 /* BGP configuration. */
7414 if (bgp_flag_check (bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7415 vty_out (vty
, " bgp always-compare-med%s", VTY_NEWLINE
);
7417 /* BGP default ipv4-unicast. */
7418 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7419 vty_out (vty
, " no bgp default ipv4-unicast%s", VTY_NEWLINE
);
7421 /* BGP default local-preference. */
7422 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7423 vty_out (vty
, " bgp default local-preference %d%s",
7424 bgp
->default_local_pref
, VTY_NEWLINE
);
7426 /* BGP default show-hostname */
7427 if (!!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7428 != DFLT_BGP_SHOW_HOSTNAME
)
7429 vty_out (vty
, " %sbgp default show-hostname%s",
7430 bgp_flag_check (bgp
, BGP_FLAG_SHOW_HOSTNAME
) ? "" : "no ",
7433 /* BGP default subgroup-pkt-queue-max. */
7434 if (bgp
->default_subgroup_pkt_queue_max
!= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7435 vty_out (vty
, " bgp default subgroup-pkt-queue-max %d%s",
7436 bgp
->default_subgroup_pkt_queue_max
, VTY_NEWLINE
);
7438 /* BGP client-to-client reflection. */
7439 if (bgp_flag_check (bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7440 vty_out (vty
, " no bgp client-to-client reflection%s", VTY_NEWLINE
);
7442 /* BGP cluster ID. */
7443 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7444 vty_out (vty
, " bgp cluster-id %s%s", inet_ntoa (bgp
->cluster_id
),
7447 /* Disable ebgp connected nexthop check */
7448 if (bgp_flag_check (bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7449 vty_out (vty
, " bgp disable-ebgp-connected-route-check%s", VTY_NEWLINE
);
7451 /* Confederation identifier*/
7452 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7453 vty_out (vty
, " bgp confederation identifier %i%s", bgp
->confed_id
,
7456 /* Confederation peer */
7457 if (bgp
->confed_peers_cnt
> 0)
7461 vty_out (vty
, " bgp confederation peers");
7463 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7464 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7466 vty_out (vty
, "%s", VTY_NEWLINE
);
7469 /* BGP enforce-first-as. */
7470 if (bgp_flag_check (bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
7471 vty_out (vty
, " bgp enforce-first-as%s", VTY_NEWLINE
);
7473 /* BGP deterministic-med. */
7474 if (!!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7475 != DFLT_BGP_DETERMINISTIC_MED
)
7476 vty_out (vty
, " %sbgp deterministic-med%s",
7477 bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
) ? "" : "no ",
7480 /* BGP update-delay. */
7481 bgp_config_write_update_delay (vty
, bgp
);
7483 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
7485 vty_out (vty
, " bgp max-med on-startup %d", bgp
->v_maxmed_onstartup
);
7486 if (bgp
->maxmed_onstartup_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7487 vty_out (vty
, " %d", bgp
->maxmed_onstartup_value
);
7488 vty_out (vty
, "%s", VTY_NEWLINE
);
7490 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
)
7492 vty_out (vty
, " bgp max-med administrative");
7493 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7494 vty_out (vty
, " %d", bgp
->maxmed_admin_value
);
7495 vty_out (vty
, "%s", VTY_NEWLINE
);
7499 bgp_config_write_wpkt_quanta (vty
, bgp
);
7502 bgp_config_write_coalesce_time(vty
, bgp
);
7504 /* BGP graceful-restart. */
7505 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7506 vty_out (vty
, " bgp graceful-restart stalepath-time %d%s",
7507 bgp
->stalepath_time
, VTY_NEWLINE
);
7508 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7509 vty_out (vty
, " bgp graceful-restart restart-time %d%s",
7510 bgp
->restart_time
, VTY_NEWLINE
);
7511 if (bgp_flag_check (bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7512 vty_out (vty
, " bgp graceful-restart%s", VTY_NEWLINE
);
7514 /* BGP graceful-restart Preserve State F bit. */
7515 if (bgp_flag_check (bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
7516 vty_out (vty
, " bgp graceful-restart preserve-fw-state%s", VTY_NEWLINE
);
7518 /* BGP bestpath method. */
7519 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_IGNORE
))
7520 vty_out (vty
, " bgp bestpath as-path ignore%s", VTY_NEWLINE
);
7521 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_CONFED
))
7522 vty_out (vty
, " bgp bestpath as-path confed%s", VTY_NEWLINE
);
7524 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
))
7526 if (bgp_flag_check (bgp
, BGP_FLAG_MULTIPATH_RELAX_AS_SET
))
7528 vty_out (vty
, " bgp bestpath as-path multipath-relax as-set%s", VTY_NEWLINE
);
7532 vty_out (vty
, " bgp bestpath as-path multipath-relax%s", VTY_NEWLINE
);
7536 if (bgp_flag_check (bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7537 vty_out (vty
, " bgp route-reflector allow-outbound-policy%s",
7540 if (bgp_flag_check (bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7541 vty_out (vty
, " bgp bestpath compare-routerid%s", VTY_NEWLINE
);
7542 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
)
7543 || bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7545 vty_out (vty
, " bgp bestpath med");
7546 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
))
7547 vty_out (vty
, " confed");
7548 if (bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7549 vty_out (vty
, " missing-as-worst");
7550 vty_out (vty
, "%s", VTY_NEWLINE
);
7553 /* BGP network import check. */
7554 if (!!bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
)
7555 != DFLT_BGP_IMPORT_CHECK
)
7556 vty_out (vty
, " %sbgp network import-check%s",
7557 bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
) ? "" : "no ",
7560 /* BGP flag dampening. */
7561 if (CHECK_FLAG (bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7562 BGP_CONFIG_DAMPENING
))
7563 bgp_config_write_damp (vty
);
7565 /* BGP timers configuration. */
7566 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7567 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7568 vty_out (vty
, " timers bgp %d %d%s", bgp
->default_keepalive
,
7569 bgp
->default_holdtime
, VTY_NEWLINE
);
7572 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7574 bgp_config_write_peer_global (vty
, bgp
, group
->conf
);
7577 /* Normal neighbor configuration. */
7578 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7580 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7581 bgp_config_write_peer_global (vty
, bgp
, peer
);
7584 /* listen range and limit for dynamic BGP neighbors */
7585 bgp_config_write_listen (vty
, bgp
);
7587 /* No auto-summary */
7588 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7589 vty_out (vty
, " no auto-summary%s", VTY_NEWLINE
);
7591 /* IPv4 unicast configuration. */
7592 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7594 /* IPv4 multicast configuration. */
7595 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7597 /* IPv4 labeled-unicast configuration. */
7598 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_LABELED_UNICAST
);
7600 /* IPv4 VPN configuration. */
7601 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7603 /* ENCAPv4 configuration. */
7604 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7606 /* IPv6 unicast configuration. */
7607 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7609 /* IPv6 multicast configuration. */
7610 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7612 /* IPv6 labeled-unicast configuration. */
7613 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_LABELED_UNICAST
);
7615 /* IPv6 VPN configuration. */
7616 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7618 /* ENCAPv6 configuration. */
7619 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7621 /* EVPN configuration. */
7622 write
+= bgp_config_write_family (vty
, bgp
, AFI_L2VPN
, SAFI_EVPN
);
7625 write
+= bgp_rfapi_cfg_write(vty
, bgp
);
7634 bgp_master_init (struct thread_master
*master
)
7638 memset (&bgp_master
, 0, sizeof (struct bgp_master
));
7641 bm
->bgp
= list_new ();
7642 bm
->listen_sockets
= list_new ();
7643 bm
->port
= BGP_PORT_DEFAULT
;
7644 bm
->master
= master
;
7645 bm
->start_time
= bgp_clock ();
7646 bm
->t_rmap_update
= NULL
;
7647 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7649 bgp_process_queue_init();
7651 /* Enable multiple instances by default. */
7652 bgp_option_set (BGP_OPT_MULTIPLE_INSTANCE
);
7654 QOBJ_REG (bm
, bgp_master
);
7658 * Initialize interface list for instance, if needed. Invoked upon
7662 bgp_if_init (struct bgp
*bgp
)
7664 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7667 vrf_iflist_create (bgp
->vrf_id
);
7671 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7672 * instance delete (non-default only) or BGP exit.
7675 bgp_if_finish (struct bgp
*bgp
)
7677 struct listnode
*ifnode
, *ifnnode
;
7678 struct interface
*ifp
;
7680 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7683 for (ALL_LIST_ELEMENTS (vrf_iflist(bgp
->vrf_id
), ifnode
, ifnnode
, ifp
))
7685 struct listnode
*c_node
, *c_nnode
;
7686 struct connected
*c
;
7688 for (ALL_LIST_ELEMENTS (ifp
->connected
, c_node
, c_nnode
, c
))
7689 bgp_connected_delete (bgp
, c
);
7693 extern void bgp_snmp_init (void);
7699 /* allocates some vital data structures used by peer commands in vty_init */
7702 bgp_zebra_init(bm
->master
);
7705 vnc_zebra_init (bm
->master
);
7708 /* BGP VTY commands installation. */
7716 bgp_route_map_init ();
7717 bgp_scan_vty_init();
7718 bgp_mplsvpn_init ();
7723 bgp_ethernetvpn_init ();
7725 /* Access list initialize. */
7726 access_list_init ();
7727 access_list_add_hook (peer_distribute_update
);
7728 access_list_delete_hook (peer_distribute_update
);
7730 /* Filter list initialize. */
7732 as_list_add_hook (peer_aslist_add
);
7733 as_list_delete_hook (peer_aslist_del
);
7735 /* Prefix list initialize.*/
7736 prefix_list_init ();
7737 prefix_list_add_hook (peer_prefix_list_update
);
7738 prefix_list_delete_hook (peer_prefix_list_update
);
7740 /* Community list initialize. */
7741 bgp_clist
= community_list_init ();
7748 bgp_terminate (void)
7752 struct listnode
*node
, *nnode
;
7753 struct listnode
*mnode
, *mnnode
;
7757 /* Close the listener sockets first as this prevents peers from attempting
7758 * to reconnect on receiving the peer unconfig message. In the presence
7759 * of a large number of peers this will ensure that no peer is left with
7760 * a dangling connection
7762 /* reverse bgp_master_init */
7764 if (bm
->listen_sockets
)
7765 list_free(bm
->listen_sockets
);
7766 bm
->listen_sockets
= NULL
;
7768 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7769 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7770 if (peer
->status
== Established
||
7771 peer
->status
== OpenSent
||
7772 peer
->status
== OpenConfirm
)
7773 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
7774 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7776 if (bm
->process_main_queue
)
7778 work_queue_free (bm
->process_main_queue
);
7779 bm
->process_main_queue
= NULL
;
7782 if (bm
->t_rmap_update
)
7783 BGP_TIMER_OFF(bm
->t_rmap_update
);