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
17 along with GNU Zebra; see the file COPYING. If not, write to the Free
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
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_MPLS_VPN
],
1640 PEER_FLAG_REFLECTOR_CLIENT
);
1641 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1642 PEER_FLAG_REFLECTOR_CLIENT
);
1643 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1644 PEER_FLAG_REFLECTOR_CLIENT
);
1645 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1646 PEER_FLAG_REFLECTOR_CLIENT
);
1647 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1648 PEER_FLAG_REFLECTOR_CLIENT
);
1649 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1650 PEER_FLAG_REFLECTOR_CLIENT
);
1651 UNSET_FLAG (peer
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
1652 PEER_FLAG_REFLECTOR_CLIENT
);
1655 /* local-as reset */
1656 if (peer_sort (peer
) != BGP_PEER_EBGP
)
1658 peer
->change_local_as
= 0;
1659 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1660 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1664 /* If peer does not exist, create new one. If peer already exists,
1665 set AS number to the peer. */
1667 peer_remote_as (struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1668 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1674 peer
= peer_lookup_by_conf_if (bgp
, conf_if
);
1676 peer
= peer_lookup (bgp
, su
);
1680 /* Not allowed for a dynamic peer. */
1681 if (peer_dynamic_neighbor (peer
))
1684 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1687 /* When this peer is a member of peer-group. */
1690 if (peer
->group
->conf
->as
)
1692 /* Return peer group's AS number. */
1693 *as
= peer
->group
->conf
->as
;
1694 return BGP_ERR_PEER_GROUP_MEMBER
;
1696 if (peer_sort (peer
->group
->conf
) == BGP_PEER_IBGP
)
1698 if ((as_type
!= AS_INTERNAL
) && (bgp
->as
!= *as
))
1701 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1706 if ((as_type
!= AS_EXTERNAL
) && (bgp
->as
== *as
))
1709 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1714 /* Existing peer's AS number change. */
1715 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
1716 (peer
->as_type
!= as_type
))
1717 peer_as_change (peer
, *as
, as_type
);
1722 return BGP_ERR_NO_INTERFACE_CONFIG
;
1724 /* If the peer is not part of our confederation, and its not an
1725 iBGP peer then spoof the source AS */
1726 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
)
1727 && ! bgp_confederation_peers_check (bgp
, *as
)
1729 local_as
= bgp
->confed_id
;
1733 /* If this is IPv4 unicast configuration and "no bgp default
1734 ipv4-unicast" is specified. */
1736 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1737 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1738 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0, 0, NULL
);
1740 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, afi
, safi
, NULL
);
1747 non_peergroup_activate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1751 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1753 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1757 /* Nothing to do if we've already activated this peer */
1758 if (peer
->afc
[afi
][safi
])
1761 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1764 active
= peer_active (peer
);
1765 peer
->afc
[afi
][safi
] = 1;
1767 if (!active
&& peer_active (peer
))
1769 bgp_timer_set (peer
);
1773 if (peer
->status
== Established
)
1775 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1777 peer
->afc_adv
[afi
][safi
] = 1;
1778 bgp_capability_send (peer
, afi
, safi
,
1780 CAPABILITY_ACTION_SET
);
1781 if (peer
->afc_recv
[afi
][safi
])
1783 peer
->afc_nego
[afi
][safi
] = 1;
1784 bgp_announce_route (peer
, afi
, safi
);
1789 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1790 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1791 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1799 /* Activate the peer or peer group for specified AFI and SAFI. */
1801 peer_activate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1804 struct peer_group
*group
;
1805 struct listnode
*node
, *nnode
;
1806 struct peer
*tmp_peer
;
1808 /* Nothing to do if we've already activated this peer */
1809 if (peer
->afc
[afi
][safi
])
1812 /* This is a peer-group so activate all of the members of the
1813 * peer-group as well */
1814 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1816 peer
->afc
[afi
][safi
] = 1;
1817 group
= peer
->group
;
1819 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1821 ret
|= non_peergroup_activate_af (tmp_peer
, afi
, safi
);
1826 ret
|= non_peergroup_activate_af (peer
, afi
, safi
);
1833 non_peergroup_deactivate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1835 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1837 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1841 /* Nothing to do if we've already deactivated this peer */
1842 if (! peer
->afc
[afi
][safi
])
1845 /* De-activate the address family configuration. */
1846 peer
->afc
[afi
][safi
] = 0;
1848 if (peer_af_delete(peer
, afi
, safi
) != 0)
1850 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1854 if (peer
->status
== Established
)
1856 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1858 peer
->afc_adv
[afi
][safi
] = 0;
1859 peer
->afc_nego
[afi
][safi
] = 0;
1861 if (peer_active_nego (peer
))
1863 bgp_capability_send (peer
, afi
, safi
,
1865 CAPABILITY_ACTION_UNSET
);
1866 bgp_clear_route (peer
, afi
, safi
);
1867 peer
->pcount
[afi
][safi
] = 0;
1871 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1872 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1873 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1878 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1879 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1880 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1888 peer_deactivate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1891 struct peer_group
*group
;
1892 struct peer
*tmp_peer
;
1893 struct listnode
*node
, *nnode
;
1895 /* Nothing to do if we've already de-activated this peer */
1896 if (! peer
->afc
[afi
][safi
])
1899 /* This is a peer-group so de-activate all of the members of the
1900 * peer-group as well */
1901 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1903 peer
->afc
[afi
][safi
] = 0;
1904 group
= peer
->group
;
1906 if (peer_af_delete(peer
, afi
, safi
) != 0)
1908 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1911 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1913 ret
|= non_peergroup_deactivate_af (tmp_peer
, afi
, safi
);
1918 ret
|= non_peergroup_deactivate_af (peer
, afi
, safi
);
1925 peer_afc_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
1928 return peer_activate (peer
, afi
, safi
);
1930 return peer_deactivate (peer
, afi
, safi
);
1934 peer_nsf_stop (struct peer
*peer
)
1939 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1940 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
);
1942 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1943 for (safi
= SAFI_UNICAST
; safi
< SAFI_RESERVED_4
; safi
++)
1944 peer
->nsf
[afi
][safi
] = 0;
1946 if (peer
->t_gr_restart
)
1948 BGP_TIMER_OFF (peer
->t_gr_restart
);
1949 if (bgp_debug_neighbor_events(peer
))
1950 zlog_debug ("%s graceful restart timer stopped", peer
->host
);
1952 if (peer
->t_gr_stale
)
1954 BGP_TIMER_OFF (peer
->t_gr_stale
);
1955 if (bgp_debug_neighbor_events(peer
))
1956 zlog_debug ("%s graceful restart stalepath timer stopped", peer
->host
);
1958 bgp_clear_route_all (peer
);
1961 /* Delete peer from confguration.
1963 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
1964 * it to "cool off" and refcounts to hit 0, at which state it is freed.
1966 * This function /should/ take care to be idempotent, to guard against
1967 * it being called multiple times through stray events that come in
1968 * that happen to result in this function being called again. That
1969 * said, getting here for a "Deleted" peer is a bug in the neighbour
1973 peer_delete (struct peer
*peer
)
1979 struct bgp_filter
*filter
;
1980 struct listnode
*pn
;
1983 assert (peer
->status
!= Deleted
);
1986 accept_peer
= CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1988 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
1989 peer_nsf_stop (peer
);
1991 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
1993 /* If this peer belongs to peer group, clear up the
1997 if (peer_dynamic_neighbor(peer
))
1998 peer_drop_dynamic_neighbor(peer
);
2000 if ((pn
= listnode_lookup (peer
->group
->peer
, peer
)))
2002 peer
= peer_unlock (peer
); /* group->peer list reference */
2003 list_delete_node (peer
->group
->peer
, pn
);
2008 /* Withdraw all information from routing table. We can not use
2009 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2010 * executed after peer structure is deleted.
2012 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
2014 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
2016 if (peer
->doppelganger
)
2018 peer
->doppelganger
->doppelganger
= NULL
;
2019 peer
->doppelganger
= NULL
;
2022 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
2023 bgp_fsm_change_status (peer
, Deleted
);
2025 /* Remove from NHT */
2026 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
))
2027 bgp_unlink_nexthop_by_peer (peer
);
2029 /* Password configuration */
2032 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
2033 peer
->password
= NULL
;
2036 ! BGP_PEER_SU_UNSPEC(peer
) &&
2037 ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
2038 bgp_md5_unset (peer
);
2041 bgp_timer_set (peer
); /* stops all timers for Deleted */
2043 /* Delete from all peer list. */
2044 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
2045 && (pn
= listnode_lookup (bgp
->peer
, peer
)))
2047 peer_unlock (peer
); /* bgp peer list reference */
2048 list_delete_node (bgp
->peer
, pn
);
2049 hash_release(bgp
->peerhash
, peer
);
2055 stream_free (peer
->ibuf
);
2061 stream_fifo_free (peer
->obuf
);
2067 stream_free (peer
->work
);
2073 stream_free(peer
->scratch
);
2074 peer
->scratch
= NULL
;
2077 /* Local and remote addresses. */
2080 sockunion_free (peer
->su_local
);
2081 peer
->su_local
= NULL
;
2084 if (peer
->su_remote
)
2086 sockunion_free (peer
->su_remote
);
2087 peer
->su_remote
= NULL
;
2090 /* Free filter related memory. */
2091 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2092 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2094 filter
= &peer
->filter
[afi
][safi
];
2096 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
2098 if (filter
->dlist
[i
].name
)
2100 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2101 filter
->dlist
[i
].name
= NULL
;
2104 if (filter
->plist
[i
].name
)
2106 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2107 filter
->plist
[i
].name
= NULL
;
2110 if (filter
->aslist
[i
].name
)
2112 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2113 filter
->aslist
[i
].name
= NULL
;
2117 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
2119 if (filter
->map
[i
].name
)
2121 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2122 filter
->map
[i
].name
= NULL
;
2126 if (filter
->usmap
.name
)
2128 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2129 filter
->usmap
.name
= NULL
;
2132 if (peer
->default_rmap
[afi
][safi
].name
)
2134 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2135 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2139 FOREACH_AFI_SAFI (afi
, safi
)
2140 peer_af_delete (peer
, afi
, safi
);
2144 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2145 peer
->hostname
= NULL
;
2148 if (peer
->domainname
)
2150 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2151 peer
->domainname
= NULL
;
2154 peer_unlock (peer
); /* initial reference */
2160 peer_group_cmp (struct peer_group
*g1
, struct peer_group
*g2
)
2162 return strcmp (g1
->name
, g2
->name
);
2165 /* Peer group cofiguration. */
2166 static struct peer_group
*
2167 peer_group_new (void)
2169 return (struct peer_group
*) XCALLOC (MTYPE_PEER_GROUP
,
2170 sizeof (struct peer_group
));
2174 peer_group_free (struct peer_group
*group
)
2176 XFREE (MTYPE_PEER_GROUP
, group
);
2180 peer_group_lookup (struct bgp
*bgp
, const char *name
)
2182 struct peer_group
*group
;
2183 struct listnode
*node
, *nnode
;
2185 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
2187 if (strcmp (group
->name
, name
) == 0)
2194 peer_group_get (struct bgp
*bgp
, const char *name
)
2196 struct peer_group
*group
;
2199 group
= peer_group_lookup (bgp
, name
);
2203 group
= peer_group_new ();
2206 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2207 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2208 group
->peer
= list_new ();
2209 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2210 group
->listen_range
[afi
] = list_new ();
2211 group
->conf
= peer_new (bgp
);
2212 if (! bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2213 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2214 if (group
->conf
->host
)
2215 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2216 group
->conf
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, name
);
2217 group
->conf
->group
= group
;
2218 group
->conf
->as
= 0;
2219 group
->conf
->ttl
= 1;
2220 group
->conf
->gtsm_hops
= 0;
2221 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2222 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_TIMER
);
2223 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_CONNECT
);
2224 group
->conf
->keepalive
= 0;
2225 group
->conf
->holdtime
= 0;
2226 group
->conf
->connect
= 0;
2227 SET_FLAG (group
->conf
->sflags
, PEER_STATUS_GROUP
);
2228 listnode_add_sort (bgp
->group
, group
);
2234 peer_group2peer_config_copy (struct peer_group
*group
, struct peer
*peer
)
2243 peer
->as
= conf
->as
;
2246 if (conf
->change_local_as
)
2247 peer
->change_local_as
= conf
->change_local_as
;
2250 peer
->ttl
= conf
->ttl
;
2253 peer
->gtsm_hops
= conf
->gtsm_hops
;
2255 /* this flag is per-neighbor and so has to be preserved */
2256 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2258 /* peer flags apply */
2259 peer
->flags
= conf
->flags
;
2262 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2264 /* peer config apply */
2265 peer
->config
= conf
->config
;
2267 /* peer timers apply */
2268 peer
->holdtime
= conf
->holdtime
;
2269 peer
->keepalive
= conf
->keepalive
;
2270 peer
->connect
= conf
->connect
;
2271 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_CONNECT
))
2272 peer
->v_connect
= conf
->connect
;
2274 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2276 /* advertisement-interval reset */
2277 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
2278 peer
->v_routeadv
= conf
->routeadv
;
2280 if (peer_sort (peer
) == BGP_PEER_IBGP
)
2281 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2283 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2285 /* password apply */
2286 if (conf
->password
&& !peer
->password
)
2287 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, conf
->password
);
2289 if (! BGP_PEER_SU_UNSPEC(peer
))
2292 /* update-source apply */
2293 if (conf
->update_source
)
2295 if (peer
->update_source
)
2296 sockunion_free (peer
->update_source
);
2297 if (peer
->update_if
)
2299 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2300 peer
->update_if
= NULL
;
2302 peer
->update_source
= sockunion_dup (conf
->update_source
);
2304 else if (conf
->update_if
)
2306 if (peer
->update_if
)
2307 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2308 if (peer
->update_source
)
2310 sockunion_free (peer
->update_source
);
2311 peer
->update_source
= NULL
;
2313 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2316 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2320 peer_group2peer_config_copy_af (struct peer_group
*group
, struct peer
*peer
,
2321 afi_t afi
, safi_t safi
)
2324 int out
= FILTER_OUT
;
2326 struct bgp_filter
*pfilter
;
2327 struct bgp_filter
*gfilter
;
2330 pfilter
= &peer
->filter
[afi
][safi
];
2331 gfilter
= &conf
->filter
[afi
][safi
];
2333 /* peer af_flags apply */
2334 peer
->af_flags
[afi
][safi
] = conf
->af_flags
[afi
][safi
];
2336 /* maximum-prefix */
2337 peer
->pmax
[afi
][safi
] = conf
->pmax
[afi
][safi
];
2338 peer
->pmax_threshold
[afi
][safi
] = conf
->pmax_threshold
[afi
][safi
];
2339 peer
->pmax_restart
[afi
][safi
] = conf
->pmax_restart
[afi
][safi
];
2342 peer
->allowas_in
[afi
][safi
] = conf
->allowas_in
[afi
][safi
];
2345 peer
->weight
[afi
][safi
] = conf
->weight
[afi
][safi
];
2347 /* default-originate route-map */
2348 if (conf
->default_rmap
[afi
][safi
].name
)
2350 if (peer
->default_rmap
[afi
][safi
].name
)
2351 XFREE(MTYPE_BGP_FILTER_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2352 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, conf
->default_rmap
[afi
][safi
].name
);
2353 peer
->default_rmap
[afi
][safi
].map
= conf
->default_rmap
[afi
][safi
].map
;
2356 /* inbound filter apply */
2357 if (gfilter
->dlist
[in
].name
&& ! pfilter
->dlist
[in
].name
)
2359 if (pfilter
->dlist
[in
].name
)
2360 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[in
].name
);
2361 pfilter
->dlist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[in
].name
);
2362 pfilter
->dlist
[in
].alist
= gfilter
->dlist
[in
].alist
;
2365 if (gfilter
->plist
[in
].name
&& ! pfilter
->plist
[in
].name
)
2367 if (pfilter
->plist
[in
].name
)
2368 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[in
].name
);
2369 pfilter
->plist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[in
].name
);
2370 pfilter
->plist
[in
].plist
= gfilter
->plist
[in
].plist
;
2373 if (gfilter
->aslist
[in
].name
&& ! pfilter
->aslist
[in
].name
)
2375 if (pfilter
->aslist
[in
].name
)
2376 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[in
].name
);
2377 pfilter
->aslist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[in
].name
);
2378 pfilter
->aslist
[in
].aslist
= gfilter
->aslist
[in
].aslist
;
2381 if (gfilter
->map
[RMAP_IN
].name
&& ! pfilter
->map
[RMAP_IN
].name
)
2383 if (pfilter
->map
[RMAP_IN
].name
)
2384 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_IN
].name
);
2385 pfilter
->map
[RMAP_IN
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_IN
].name
);
2386 pfilter
->map
[RMAP_IN
].map
= gfilter
->map
[RMAP_IN
].map
;
2389 /* outbound filter apply */
2390 if (gfilter
->dlist
[out
].name
)
2392 if (pfilter
->dlist
[out
].name
)
2393 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2394 pfilter
->dlist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[out
].name
);
2395 pfilter
->dlist
[out
].alist
= gfilter
->dlist
[out
].alist
;
2399 if (pfilter
->dlist
[out
].name
)
2400 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2401 pfilter
->dlist
[out
].name
= NULL
;
2402 pfilter
->dlist
[out
].alist
= NULL
;
2405 if (gfilter
->plist
[out
].name
)
2407 if (pfilter
->plist
[out
].name
)
2408 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2409 pfilter
->plist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[out
].name
);
2410 pfilter
->plist
[out
].plist
= gfilter
->plist
[out
].plist
;
2414 if (pfilter
->plist
[out
].name
)
2415 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2416 pfilter
->plist
[out
].name
= NULL
;
2417 pfilter
->plist
[out
].plist
= NULL
;
2420 if (gfilter
->aslist
[out
].name
)
2422 if (pfilter
->aslist
[out
].name
)
2423 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2424 pfilter
->aslist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[out
].name
);
2425 pfilter
->aslist
[out
].aslist
= gfilter
->aslist
[out
].aslist
;
2429 if (pfilter
->aslist
[out
].name
)
2430 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2431 pfilter
->aslist
[out
].name
= NULL
;
2432 pfilter
->aslist
[out
].aslist
= NULL
;
2435 if (gfilter
->map
[RMAP_OUT
].name
)
2437 if (pfilter
->map
[RMAP_OUT
].name
)
2438 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2439 pfilter
->map
[RMAP_OUT
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_OUT
].name
);
2440 pfilter
->map
[RMAP_OUT
].map
= gfilter
->map
[RMAP_OUT
].map
;
2444 if (pfilter
->map
[RMAP_OUT
].name
)
2445 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2446 pfilter
->map
[RMAP_OUT
].name
= NULL
;
2447 pfilter
->map
[RMAP_OUT
].map
= NULL
;
2450 if (gfilter
->usmap
.name
)
2452 if (pfilter
->usmap
.name
)
2453 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2454 pfilter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->usmap
.name
);
2455 pfilter
->usmap
.map
= gfilter
->usmap
.map
;
2459 if (pfilter
->usmap
.name
)
2460 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2461 pfilter
->usmap
.name
= NULL
;
2462 pfilter
->usmap
.map
= NULL
;
2466 /* Peer group's remote AS configuration. */
2468 peer_group_remote_as (struct bgp
*bgp
, const char *group_name
,
2469 as_t
*as
, int as_type
)
2471 struct peer_group
*group
;
2473 struct listnode
*node
, *nnode
;
2475 group
= peer_group_lookup (bgp
, group_name
);
2479 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2483 /* When we setup peer-group AS number all peer group member's AS
2484 number must be updated to same number. */
2485 peer_as_change (group
->conf
, *as
, as_type
);
2487 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2489 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
2490 (peer
->as_type
!= as_type
))
2491 peer_as_change (peer
, *as
, as_type
);
2498 peer_group_delete (struct peer_group
*group
)
2502 struct prefix
*prefix
;
2504 struct listnode
*node
, *nnode
;
2509 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2511 other
= peer
->doppelganger
;
2513 if (other
&& other
->status
!= Deleted
)
2515 other
->group
= NULL
;
2519 list_delete (group
->peer
);
2521 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2523 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2525 prefix_free(prefix
);
2527 list_delete (group
->listen_range
[afi
]);
2530 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2533 bfd_info_free(&(group
->conf
->bfd_info
));
2535 group
->conf
->group
= NULL
;
2536 peer_delete (group
->conf
);
2538 /* Delete from all peer_group list. */
2539 listnode_delete (bgp
->group
, group
);
2541 peer_group_free (group
);
2547 peer_group_remote_as_delete (struct peer_group
*group
)
2549 struct peer
*peer
, *other
;
2550 struct listnode
*node
, *nnode
;
2552 if ((group
->conf
->as_type
== AS_UNSPECIFIED
) ||
2553 ((! group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2556 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2558 other
= peer
->doppelganger
;
2562 if (other
&& other
->status
!= Deleted
)
2564 other
->group
= NULL
;
2568 list_delete_all_node (group
->peer
);
2570 group
->conf
->as
= 0;
2571 group
->conf
->as_type
= AS_UNSPECIFIED
;
2577 peer_group_listen_range_add (struct peer_group
*group
, struct prefix
*range
)
2579 struct prefix
*prefix
;
2580 struct listnode
*node
, *nnode
;
2583 afi
= family2afi(range
->family
);
2585 /* Group needs remote AS configured. */
2586 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2587 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2589 /* Ensure no duplicates. Currently we don't care about overlaps. */
2590 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2592 if (prefix_same(range
, prefix
))
2596 prefix
= prefix_new();
2597 prefix_copy(prefix
, range
);
2598 listnode_add(group
->listen_range
[afi
], prefix
);
2603 peer_group_listen_range_del (struct peer_group
*group
, struct prefix
*range
)
2605 struct prefix
*prefix
, prefix2
;
2606 struct listnode
*node
, *nnode
;
2609 char buf
[PREFIX2STR_BUFFER
];
2611 afi
= family2afi(range
->family
);
2613 /* Identify the listen range. */
2614 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2616 if (prefix_same(range
, prefix
))
2621 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2623 prefix2str(prefix
, buf
, sizeof(buf
));
2625 /* Dispose off any dynamic neighbors that exist due to this listen range */
2626 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2628 if (!peer_dynamic_neighbor (peer
))
2631 sockunion2hostprefix(&peer
->su
, &prefix2
);
2632 if (prefix_match(prefix
, &prefix2
))
2634 if (bgp_debug_neighbor_events(peer
))
2635 zlog_debug ("Deleting dynamic neighbor %s group %s upon "
2636 "delete of listen range %s",
2637 peer
->host
, group
->name
, buf
);
2642 /* Get rid of the listen range */
2643 listnode_delete(group
->listen_range
[afi
], prefix
);
2648 /* Bind specified peer to peer group. */
2650 peer_group_bind (struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2651 struct peer_group
*group
, as_t
*as
)
2653 int first_member
= 0;
2656 int cap_enhe_preset
= 0;
2658 /* Lookup the peer. */
2660 peer
= peer_lookup (bgp
, su
);
2662 /* The peer exist, bind it to the peer-group */
2665 /* When the peer already belongs to peer group, check the consistency. */
2666 if (peer_group_active (peer
) && strcmp (peer
->group
->name
, group
->name
) != 0)
2667 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2669 /* The peer has not specified a remote-as, inherit it from the
2671 if (peer
->as_type
== AS_UNSPECIFIED
)
2673 peer
->as_type
= group
->conf
->as_type
;
2674 peer
->as
= group
->conf
->as
;
2677 if (! group
->conf
->as
)
2679 if (peer_sort (group
->conf
) != BGP_PEER_INTERNAL
2680 && peer_sort (group
->conf
) != peer_sort (peer
))
2684 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2687 if (peer_sort (group
->conf
) == BGP_PEER_INTERNAL
)
2691 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2692 cap_enhe_preset
= 1;
2694 peer_group2peer_config_copy(group
, peer
);
2697 * Capability extended-nexthop is enabled for an interface neighbor by
2698 * default. So, fix that up here.
2700 if (peer
->conf_if
&& cap_enhe_preset
)
2701 peer_flag_set (peer
, PEER_FLAG_CAPABILITY_ENHE
);
2703 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2704 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2706 if (group
->conf
->afc
[afi
][safi
])
2708 peer
->afc
[afi
][safi
] = 1;
2710 if (peer_af_find(peer
, afi
, safi
) || peer_af_create(peer
, afi
, safi
))
2712 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2719 assert (group
&& peer
->group
== group
);
2723 struct listnode
*pn
;
2724 pn
= listnode_lookup (bgp
->peer
, peer
);
2725 list_delete_node (bgp
->peer
, pn
);
2726 peer
->group
= group
;
2727 listnode_add_sort (bgp
->peer
, peer
);
2729 peer
= peer_lock (peer
); /* group->peer list reference */
2730 listnode_add (group
->peer
, peer
);
2735 /* Advertisement-interval reset */
2736 if (! CHECK_FLAG (group
->conf
->config
, PEER_CONFIG_ROUTEADV
))
2738 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2739 group
->conf
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2741 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2744 /* ebgp-multihop reset */
2745 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2746 group
->conf
->ttl
= MAXTTL
;
2748 /* local-as reset */
2749 if (peer_sort (group
->conf
) != BGP_PEER_EBGP
)
2751 group
->conf
->change_local_as
= 0;
2752 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2753 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2757 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2759 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2761 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2762 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2763 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2767 bgp_session_reset(peer
);
2771 /* Create a new peer. */
2774 if ((group
->conf
->as_type
== AS_SPECIFIED
) && (! group
->conf
->as
))
2776 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2779 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
2781 peer
= peer_lock (peer
); /* group->peer list reference */
2782 listnode_add (group
->peer
, peer
);
2784 peer_group2peer_config_copy(group
, peer
);
2786 /* If the peer-group is active for this afi/safi then activate for this peer */
2787 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2788 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2789 if (group
->conf
->afc
[afi
][safi
])
2791 peer
->afc
[afi
][safi
] = 1;
2792 peer_af_create(peer
, afi
, safi
);
2793 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2796 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2798 /* Set up peer's events and timers. */
2799 if (peer_active (peer
))
2800 bgp_timer_set (peer
);
2807 peer_group_unbind (struct bgp
*bgp
, struct peer
*peer
,
2808 struct peer_group
*group
)
2814 if (group
!= peer
->group
)
2815 return BGP_ERR_PEER_GROUP_MISMATCH
;
2817 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2818 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2820 if (peer
->afc
[afi
][safi
])
2822 peer
->afc
[afi
][safi
] = 0;
2823 peer_af_flag_reset (peer
, afi
, safi
);
2825 if (peer_af_delete(peer
, afi
, safi
) != 0)
2827 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
2832 assert (listnode_lookup (group
->peer
, peer
));
2833 peer_unlock (peer
); /* peer group list reference */
2834 listnode_delete (group
->peer
, peer
);
2836 other
= peer
->doppelganger
;
2838 if (group
->conf
->as
)
2841 if (other
&& other
->status
!= Deleted
)
2846 listnode_delete(group
->peer
, other
);
2848 other
->group
= NULL
;
2854 bgp_bfd_deregister_peer(peer
);
2855 peer_global_config_reset (peer
);
2857 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2859 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2860 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2861 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2864 bgp_session_reset(peer
);
2870 bgp_startup_timer_expire (struct thread
*thread
)
2874 bgp
= THREAD_ARG (thread
);
2875 bgp
->t_startup
= NULL
;
2880 /* BGP instance creation by `router bgp' commands. */
2882 bgp_create (as_t
*as
, const char *name
, enum bgp_instance_type inst_type
)
2888 if ( (bgp
= XCALLOC (MTYPE_BGP
, sizeof (struct bgp
))) == NULL
)
2891 if (BGP_DEBUG (zebra
, ZEBRA
))
2893 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2894 zlog_debug("Creating Default VRF, AS %u", *as
);
2896 zlog_debug("Creating %s %s, AS %u",
2897 (inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
2902 bgp
->inst_type
= inst_type
;
2903 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ?
2904 VRF_DEFAULT
: VRF_UNKNOWN
;
2905 bgp
->peer_self
= peer_new (bgp
);
2906 if (bgp
->peer_self
->host
)
2907 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2908 bgp
->peer_self
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2909 bgp
->peer
= list_new ();
2910 bgp
->peer
->cmp
= (int (*)(void *, void *)) peer_cmp
;
2911 bgp
->peerhash
= hash_create (peer_hash_key_make
, peer_hash_cmp
);
2913 bgp
->group
= list_new ();
2914 bgp
->group
->cmp
= (int (*)(void *, void *)) peer_group_cmp
;
2916 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2917 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2919 bgp
->route
[afi
][safi
] = bgp_table_init (afi
, safi
);
2920 bgp
->aggregate
[afi
][safi
] = bgp_table_init (afi
, safi
);
2921 bgp
->rib
[afi
][safi
] = bgp_table_init (afi
, safi
);
2923 /* Enable maximum-paths */
2924 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_EBGP
, multipath_num
, 0);
2925 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_IBGP
, multipath_num
, 0);
2928 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2929 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2930 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2931 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2932 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2933 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2934 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2935 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2936 bgp
->dynamic_neighbors_count
= 0;
2937 #if DFLT_BGP_IMPORT_CHECK
2938 bgp_flag_set (bgp
, BGP_FLAG_IMPORT_CHECK
);
2940 #if DFLT_BGP_SHOW_HOSTNAME
2941 bgp_flag_set (bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2943 #if DFLT_BGP_LOG_NEIGHBOR_CHANGES
2944 bgp_flag_set (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2946 #if DFLT_BGP_DETERMINISTIC_MED
2947 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2949 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2954 if (inst_type
!= BGP_INSTANCE_TYPE_VRF
)
2956 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2958 assert(bgp
->rfapi_cfg
);
2960 #endif /* ENABLE_BGP_VNC */
2964 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2968 /* TODO - The startup timer needs to be run for the whole of BGP */
2969 THREAD_TIMER_ON (bm
->master
, bgp
->t_startup
, bgp_startup_timer_expire
,
2970 bgp
, bgp
->restart_time
);
2973 bgp
->wpkt_quanta
= BGP_WRITE_PACKET_MAX
;
2974 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
2976 QOBJ_REG (bgp
, bgp
);
2978 update_bgp_group_init(bgp
);
2982 /* Return the "default VRF" instance of BGP. */
2984 bgp_get_default (void)
2987 struct listnode
*node
, *nnode
;
2989 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
2990 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2995 /* Lookup BGP entry. */
2997 bgp_lookup (as_t as
, const char *name
)
3000 struct listnode
*node
, *nnode
;
3002 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3004 && ((bgp
->name
== NULL
&& name
== NULL
)
3005 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0)))
3010 /* Lookup BGP structure by view name. */
3012 bgp_lookup_by_name (const char *name
)
3015 struct listnode
*node
, *nnode
;
3017 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
3018 if ((bgp
->name
== NULL
&& name
== NULL
)
3019 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0))
3024 /* Lookup BGP instance based on VRF id. */
3025 /* Note: Only to be used for incoming messages from Zebra. */
3027 bgp_lookup_by_vrf_id (vrf_id_t vrf_id
)
3031 /* Lookup VRF (in tree) and follow link. */
3032 vrf
= vrf_lookup_by_id (vrf_id
);
3035 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
3038 /* Called from VTY commands. */
3040 bgp_get (struct bgp
**bgp_val
, as_t
*as
, const char *name
,
3041 enum bgp_instance_type inst_type
)
3045 /* Multiple instance check. */
3046 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
3049 bgp
= bgp_lookup_by_name (name
);
3051 bgp
= bgp_get_default ();
3053 /* Already exists. */
3059 return BGP_ERR_INSTANCE_MISMATCH
;
3061 if (bgp
->inst_type
!= inst_type
)
3062 return BGP_ERR_INSTANCE_MISMATCH
;
3069 /* BGP instance name can not be specified for single instance. */
3071 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3073 /* Get default BGP structure if exists. */
3074 bgp
= bgp_get_default ();
3081 return BGP_ERR_AS_MISMATCH
;
3088 bgp
= bgp_create (as
, name
, inst_type
);
3089 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3090 bgp_address_init (bgp
);
3091 bgp_scan_init (bgp
);
3094 bgp
->t_rmap_def_originate_eval
= NULL
;
3096 /* Create BGP server socket, if first instance. */
3097 if (list_isempty(bm
->bgp
)
3098 && !bgp_option_check (BGP_OPT_NO_LISTEN
))
3100 if (bgp_socket (bm
->port
, bm
->address
) < 0)
3101 return BGP_ERR_INVALID_VALUE
;
3104 listnode_add (bm
->bgp
, bgp
);
3106 /* If Default instance or VRF, link to the VRF structure, if present. */
3107 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
||
3108 bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3112 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3115 bgp_vrf_link (bgp
, vrf
);
3120 /* Register with Zebra, if needed */
3121 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3122 bgp_zebra_instance_register (bgp
);
3129 * Make BGP instance "up". Applies only to VRFs (non-default) and
3130 * implies the VRF has been learnt from Zebra.
3133 bgp_instance_up (struct bgp
*bgp
)
3136 struct listnode
*node
, *next
;
3138 /* Register with zebra. */
3139 bgp_zebra_instance_register (bgp
);
3141 /* Kick off any peers that may have been configured. */
3142 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3144 if (!BGP_PEER_START_SUPPRESSED (peer
))
3145 BGP_EVENT_ADD (peer
, BGP_Start
);
3148 /* Process any networks that have been configured. */
3149 bgp_static_add (bgp
);
3153 * Make BGP instance "down". Applies only to VRFs (non-default) and
3154 * implies the VRF has been deleted by Zebra.
3157 bgp_instance_down (struct bgp
*bgp
)
3160 struct listnode
*node
;
3161 struct listnode
*next
;
3164 if (bgp
->t_rmap_def_originate_eval
)
3166 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3167 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3170 /* Bring down peers, so corresponding routes are purged. */
3171 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3173 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3174 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3176 bgp_session_reset(peer
);
3179 /* Purge network and redistributed routes. */
3180 bgp_purge_static_redist_routes (bgp
);
3183 /* Delete BGP instance. */
3185 bgp_delete (struct bgp
*bgp
)
3188 struct peer_group
*group
;
3189 struct listnode
*node
, *next
;
3194 THREAD_OFF (bgp
->t_startup
);
3196 if (BGP_DEBUG (zebra
, ZEBRA
))
3198 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3199 zlog_debug("Deleting Default VRF");
3201 zlog_debug("Deleting %s %s",
3202 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
3207 if (bgp
->t_rmap_def_originate_eval
)
3209 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3210 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3213 /* Inform peers we're going down. */
3214 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3216 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3217 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3220 /* Delete static routes (networks). */
3221 bgp_static_delete (bgp
);
3223 /* Unset redistribution. */
3224 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3225 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3226 if (i
!= ZEBRA_ROUTE_BGP
)
3227 bgp_redistribute_unset (bgp
, afi
, i
, 0);
3229 /* Free peers and peer-groups. */
3230 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, next
, group
))
3231 peer_group_delete (group
);
3233 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3236 if (bgp
->peer_self
) {
3237 peer_delete(bgp
->peer_self
);
3238 bgp
->peer_self
= NULL
;
3241 update_bgp_group_free (bgp
);
3243 /* TODO - Other memory may need to be freed - e.g., NHT */
3248 bgp_cleanup_routes(bgp
);
3250 /* Remove visibility via the master list - there may however still be
3251 * routes to be processed still referencing the struct bgp.
3253 listnode_delete (bm
->bgp
, bgp
);
3255 /* Deregister from Zebra, if needed */
3256 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3257 bgp_zebra_instance_deregister (bgp
);
3259 /* Free interfaces in this instance. */
3260 bgp_if_finish (bgp
);
3262 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3264 bgp_vrf_unlink (bgp
, vrf
);
3266 thread_master_free_unused(bm
->master
);
3267 bgp_unlock(bgp
); /* initial reference */
3272 static void bgp_free (struct bgp
*);
3275 bgp_lock (struct bgp
*bgp
)
3281 bgp_unlock(struct bgp
*bgp
)
3283 assert(bgp
->lock
> 0);
3284 if (--bgp
->lock
== 0)
3289 bgp_free (struct bgp
*bgp
)
3296 list_delete (bgp
->group
);
3297 list_delete (bgp
->peer
);
3301 hash_free(bgp
->peerhash
);
3302 bgp
->peerhash
= NULL
;
3305 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3306 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3308 if (bgp
->route
[afi
][safi
])
3309 bgp_table_finish (&bgp
->route
[afi
][safi
]);
3310 if (bgp
->aggregate
[afi
][safi
])
3311 bgp_table_finish (&bgp
->aggregate
[afi
][safi
]) ;
3312 if (bgp
->rib
[afi
][safi
])
3313 bgp_table_finish (&bgp
->rib
[afi
][safi
]);
3316 bgp_scan_finish (bgp
);
3317 bgp_address_destroy (bgp
);
3320 XFREE(MTYPE_BGP
, bgp
->name
);
3322 XFREE (MTYPE_BGP
, bgp
);
3326 peer_lookup_by_conf_if (struct bgp
*bgp
, const char *conf_if
)
3329 struct listnode
*node
, *nnode
;
3336 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3337 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3338 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3341 else if (bm
->bgp
!= NULL
)
3343 struct listnode
*bgpnode
, *nbgpnode
;
3345 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3346 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3347 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3348 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3355 peer_lookup_by_hostname (struct bgp
*bgp
, const char *hostname
)
3358 struct listnode
*node
, *nnode
;
3365 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3366 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3367 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3370 else if (bm
->bgp
!= NULL
)
3372 struct listnode
*bgpnode
, *nbgpnode
;
3374 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3375 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3376 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3377 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3384 peer_lookup (struct bgp
*bgp
, union sockunion
*su
)
3386 struct peer
*peer
= NULL
;
3387 struct peer tmp_peer
;
3389 memset(&tmp_peer
, 0, sizeof(struct peer
));
3392 * We do not want to find the doppelganger peer so search for the peer in
3393 * the hash that has PEER_FLAG_CONFIG_NODE
3395 SET_FLAG (tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3401 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3403 else if (bm
->bgp
!= NULL
)
3405 struct listnode
*bgpnode
, *nbgpnode
;
3407 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3409 /* Skip VRFs, this function will not be invoked without an instance
3410 * when examining VRFs.
3412 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3415 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3426 peer_create_bind_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
,
3427 struct peer_group
*group
)
3433 /* Create peer first; we've already checked group config is valid. */
3434 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
3439 peer
= peer_lock (peer
);
3440 listnode_add (group
->peer
, peer
);
3442 peer_group2peer_config_copy(group
, peer
);
3445 * Bind peer for all AFs configured for the group. We don't call
3446 * peer_group_bind as that is sub-optimal and does some stuff we don't want.
3448 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3449 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3451 if (!group
->conf
->afc
[afi
][safi
])
3453 peer
->afc
[afi
][safi
] = 1;
3455 if (!peer_af_find(peer
, afi
, safi
))
3456 peer_af_create(peer
, afi
, safi
);
3458 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
3461 /* Mark as dynamic, but also as a "config node" for other things to work. */
3462 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3463 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3469 peer_group_lookup_dynamic_neighbor_range (struct peer_group
* group
,
3470 struct prefix
* prefix
)
3472 struct listnode
*node
, *nnode
;
3473 struct prefix
*range
;
3476 afi
= family2afi(prefix
->family
);
3478 if (group
->listen_range
[afi
])
3479 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, range
))
3480 if (prefix_match(range
, prefix
))
3487 peer_group_lookup_dynamic_neighbor (struct bgp
*bgp
, struct prefix
*prefix
,
3488 struct prefix
**listen_range
)
3490 struct prefix
*range
= NULL
;
3491 struct peer_group
*group
= NULL
;
3492 struct listnode
*node
, *nnode
;
3494 *listen_range
= NULL
;
3497 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3498 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3501 else if (bm
->bgp
!= NULL
)
3503 struct listnode
*bgpnode
, *nbgpnode
;
3505 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3506 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3507 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3512 *listen_range
= range
;
3513 return (group
&& range
) ? group
: NULL
;
3517 peer_lookup_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
)
3519 struct peer_group
*group
;
3522 struct prefix prefix
;
3523 struct prefix
*listen_range
;
3525 char buf
[PREFIX2STR_BUFFER
];
3526 char buf1
[PREFIX2STR_BUFFER
];
3528 sockunion2hostprefix(su
, &prefix
);
3530 /* See if incoming connection matches a configured listen range. */
3531 group
= peer_group_lookup_dynamic_neighbor (bgp
, &prefix
, &listen_range
);
3542 prefix2str(&prefix
, buf
, sizeof(buf
));
3543 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3545 if (bgp_debug_neighbor_events(NULL
))
3546 zlog_debug ("Dynamic Neighbor %s matches group %s listen range %s",
3547 buf
, group
->name
, buf1
);
3549 /* Are we within the listen limit? */
3550 dncount
= gbgp
->dynamic_neighbors_count
;
3552 if (dncount
>= gbgp
->dynamic_neighbors_limit
)
3554 if (bgp_debug_neighbor_events(NULL
))
3555 zlog_debug ("Dynamic Neighbor %s rejected - at limit %d",
3556 inet_sutop (su
, buf
), gbgp
->dynamic_neighbors_limit
);
3560 /* Ensure group is not disabled. */
3561 if (CHECK_FLAG (group
->conf
->flags
, PEER_FLAG_SHUTDOWN
))
3563 if (bgp_debug_neighbor_events(NULL
))
3564 zlog_debug ("Dynamic Neighbor %s rejected - group %s disabled",
3569 /* Check that at least one AF is activated for the group. */
3570 if (!peer_group_af_configured (group
))
3572 if (bgp_debug_neighbor_events(NULL
))
3573 zlog_debug ("Dynamic Neighbor %s rejected - no AF activated for group %s",
3578 /* Create dynamic peer and bind to associated group. */
3579 peer
= peer_create_bind_dynamic_neighbor (gbgp
, su
, group
);
3582 gbgp
->dynamic_neighbors_count
= ++dncount
;
3584 if (bgp_debug_neighbor_events(peer
))
3585 zlog_debug ("%s Dynamic Neighbor added, group %s count %d",
3586 peer
->host
, group
->name
, dncount
);
3591 void peer_drop_dynamic_neighbor (struct peer
*peer
)
3594 if (peer
->group
&& peer
->group
->bgp
)
3596 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3598 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3600 if (bgp_debug_neighbor_events(peer
))
3601 zlog_debug ("%s dropped from group %s, count %d",
3602 peer
->host
, peer
->group
->name
, dncount
);
3606 /* If peer is configured at least one address family return 1. */
3608 peer_active (struct peer
*peer
)
3610 if (BGP_PEER_SU_UNSPEC(peer
))
3612 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
]
3613 || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3614 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
]
3615 || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3616 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3617 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3618 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3619 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
])
3624 /* If peer is negotiated at least one address family return 1. */
3626 peer_active_nego (struct peer
*peer
)
3628 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3629 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3630 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3631 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3632 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3633 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3634 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3635 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
3640 /* peer_flag_change_type. */
3641 enum peer_change_type
3645 peer_change_reset_in
,
3646 peer_change_reset_out
,
3650 peer_change_action (struct peer
*peer
, afi_t afi
, safi_t safi
,
3651 enum peer_change_type type
)
3653 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3656 if (peer
->status
!= Established
)
3659 if (type
== peer_change_reset
)
3661 /* If we're resetting session, we've to delete both peer struct */
3662 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3663 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3664 PEER_FLAG_CONFIG_NODE
)))
3665 peer_delete(peer
->doppelganger
);
3667 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3668 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3670 else if (type
== peer_change_reset_in
)
3672 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3673 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3674 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
3677 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3678 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3679 PEER_FLAG_CONFIG_NODE
)))
3680 peer_delete(peer
->doppelganger
);
3682 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3683 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3686 else if (type
== peer_change_reset_out
)
3688 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3689 bgp_announce_route (peer
, afi
, safi
);
3693 struct peer_flag_action
3698 /* This flag can be set for peer-group member. */
3699 u_char not_for_member
;
3701 /* Action when the flag is changed. */
3702 enum peer_change_type type
;
3704 /* Peer down cause */
3708 static const struct peer_flag_action peer_flag_action_list
[] =
3710 { PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3711 { PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3712 { PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3713 { PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3714 { PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3715 { PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3716 { PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3717 { PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3721 static const struct peer_flag_action peer_af_flag_action_list
[] =
3723 { PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3724 { PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3725 { PEER_FLAG_SEND_LARGE_COMMUNITY
, 1, peer_change_reset_out
},
3726 { PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3727 { PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3728 { PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3729 { PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3730 { PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3731 { PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3732 { PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3733 // PEER_FLAG_DEFAULT_ORIGINATE
3734 { PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3735 { PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3736 { PEER_FLAG_ALLOWAS_IN_ORIGIN
, 0, peer_change_reset_in
},
3737 { PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3738 { PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3739 // PEER_FLAG_MAX_PREFIX
3740 // PEER_FLAG_MAX_PREFIX_WARNING
3741 { PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3742 { PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3743 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3744 { PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
,1, peer_change_reset_out
},
3745 { PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3746 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
,1, peer_change_reset_out
},
3747 { PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3748 { PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3749 { PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3753 /* Proper action set. */
3755 peer_flag_action_set (const struct peer_flag_action
*action_list
, int size
,
3756 struct peer_flag_action
*action
, u_int32_t flag
)
3762 const struct peer_flag_action
*match
= NULL
;
3764 /* Check peer's frag action. */
3765 for (i
= 0; i
< size
; i
++)
3767 match
= &action_list
[i
];
3769 if (match
->flag
== 0)
3772 if (match
->flag
& flag
)
3776 if (match
->type
== peer_change_reset_in
)
3778 if (match
->type
== peer_change_reset_out
)
3780 if (match
->type
== peer_change_reset
)
3785 if (match
->not_for_member
)
3786 action
->not_for_member
= 1;
3790 /* Set peer clear type. */
3791 if (reset_in
&& reset_out
)
3792 action
->type
= peer_change_reset
;
3794 action
->type
= peer_change_reset_in
;
3796 action
->type
= peer_change_reset_out
;
3798 action
->type
= peer_change_none
;
3804 peer_flag_modify_action (struct peer
*peer
, u_int32_t flag
)
3806 if (flag
== PEER_FLAG_SHUTDOWN
)
3808 if (CHECK_FLAG (peer
->flags
, flag
))
3810 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3811 peer_nsf_stop (peer
);
3813 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3814 if (peer
->t_pmax_restart
)
3816 BGP_TIMER_OFF (peer
->t_pmax_restart
);
3817 if (bgp_debug_neighbor_events(peer
))
3818 zlog_debug ("%s Maximum-prefix restart timer canceled",
3822 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3823 peer_nsf_stop (peer
);
3825 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3827 char *msg
= peer
->tx_shutdown_message
;
3830 if (!msg
&& peer_group_active (peer
))
3831 msg
= peer
->group
->conf
->tx_shutdown_message
;
3832 msglen
= msg
? strlen(msg
) : 0;
3841 memcpy(msgbuf
+ 1, msg
, msglen
);
3843 bgp_notify_send_with_data (peer
, BGP_NOTIFY_CEASE
,
3844 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
,
3845 msgbuf
, msglen
+ 1);
3848 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3849 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3852 bgp_session_reset(peer
);
3856 peer
->v_start
= BGP_INIT_START_TIMER
;
3857 BGP_EVENT_ADD (peer
, BGP_Stop
);
3860 else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3862 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3863 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3864 else if (flag
== PEER_FLAG_PASSIVE
)
3865 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3866 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3867 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3869 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3870 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3873 bgp_session_reset(peer
);
3876 /* Change specified peer flag. */
3878 peer_flag_modify (struct peer
*peer
, u_int32_t flag
, int set
)
3882 struct peer_group
*group
;
3883 struct peer
*tmp_peer
;
3884 struct listnode
*node
, *nnode
;
3885 struct peer_flag_action action
;
3887 memset (&action
, 0, sizeof (struct peer_flag_action
));
3888 size
= sizeof peer_flag_action_list
/ sizeof (struct peer_flag_action
);
3890 found
= peer_flag_action_set (peer_flag_action_list
, size
, &action
, flag
);
3892 /* No flag action is found. */
3894 return BGP_ERR_INVALID_FLAG
;
3896 /* When unset the peer-group member's flag we have to check
3897 peer-group configuration. */
3898 if (! set
&& peer_group_active (peer
))
3899 if (CHECK_FLAG (peer
->group
->conf
->flags
, flag
))
3901 if (flag
== PEER_FLAG_SHUTDOWN
)
3902 return BGP_ERR_PEER_GROUP_SHUTDOWN
;
3905 /* Flag conflict check. */
3907 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
3908 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
3909 return BGP_ERR_PEER_FLAG_CONFLICT
;
3911 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3913 if (set
&& CHECK_FLAG (peer
->flags
, flag
) == flag
)
3915 if (! set
&& ! CHECK_FLAG (peer
->flags
, flag
))
3920 SET_FLAG (peer
->flags
, flag
);
3922 UNSET_FLAG (peer
->flags
, flag
);
3924 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3926 if (action
.type
== peer_change_reset
)
3927 peer_flag_modify_action (peer
, flag
);
3932 /* peer-group member updates. */
3933 group
= peer
->group
;
3935 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
3938 if (set
&& CHECK_FLAG (tmp_peer
->flags
, flag
) == flag
)
3941 if (! set
&& ! CHECK_FLAG (tmp_peer
->flags
, flag
))
3945 SET_FLAG (tmp_peer
->flags
, flag
);
3947 UNSET_FLAG (tmp_peer
->flags
, flag
);
3949 if (action
.type
== peer_change_reset
)
3950 peer_flag_modify_action (tmp_peer
, flag
);
3956 peer_flag_set (struct peer
*peer
, u_int32_t flag
)
3958 return peer_flag_modify (peer
, flag
, 1);
3962 peer_flag_unset (struct peer
*peer
, u_int32_t flag
)
3964 return peer_flag_modify (peer
, flag
, 0);
3968 peer_af_flag_modify (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
,
3973 struct listnode
*node
, *nnode
;
3974 struct peer_group
*group
;
3975 struct peer_flag_action action
;
3976 struct peer
*tmp_peer
;
3978 int addpath_tx_used
;
3980 memset (&action
, 0, sizeof (struct peer_flag_action
));
3981 size
= sizeof peer_af_flag_action_list
/ sizeof (struct peer_flag_action
);
3983 found
= peer_flag_action_set (peer_af_flag_action_list
, size
, &action
, flag
);
3985 /* No flag action is found. */
3987 return BGP_ERR_INVALID_FLAG
;
3989 /* Special check for reflector client. */
3990 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
3991 && peer_sort (peer
) != BGP_PEER_IBGP
)
3992 return BGP_ERR_NOT_INTERNAL_PEER
;
3994 /* Special check for remove-private-AS. */
3995 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
3996 && peer_sort (peer
) == BGP_PEER_IBGP
)
3997 return BGP_ERR_REMOVE_PRIVATE_AS
;
3999 /* as-override is not allowed for IBGP peers */
4000 if (flag
& PEER_FLAG_AS_OVERRIDE
4001 && peer_sort (peer
) == BGP_PEER_IBGP
)
4002 return BGP_ERR_AS_OVERRIDE
;
4004 /* When current flag configuration is same as requested one. */
4005 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4007 if (set
&& CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
) == flag
)
4009 if (! set
&& ! CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
))
4014 SET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4016 UNSET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
4018 /* Execute action when peer is established. */
4019 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4020 && peer
->status
== Established
)
4022 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4023 bgp_clear_adj_in (peer
, afi
, safi
);
4026 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4027 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4028 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4029 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4030 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4031 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4032 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4033 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4035 peer_change_action (peer
, afi
, safi
, action
.type
);
4040 /* Peer group member updates. */
4041 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4043 group
= peer
->group
;
4045 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
4047 if (set
&& CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
) == flag
)
4050 if (! set
&& ! CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
))
4054 SET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4056 UNSET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
4058 if (tmp_peer
->status
== Established
)
4060 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
4061 bgp_clear_adj_in (tmp_peer
, afi
, safi
);
4064 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
4065 tmp_peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
4066 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
4067 tmp_peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
4068 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
4069 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4070 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
4071 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
4073 peer_change_action (tmp_peer
, afi
, safi
, action
.type
);
4079 /* Track if addpath TX is in use */
4080 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
|PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4083 addpath_tx_used
= 0;
4087 addpath_tx_used
= 1;
4089 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)
4091 if (!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
))
4093 zlog_warn("%s: enabling bgp deterministic-med, this is required"\
4094 " for addpath-tx-bestpath-per-AS",
4096 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
4097 bgp_recalculate_all_bestpaths (bgp
);
4103 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, tmp_peer
))
4105 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
4106 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4108 addpath_tx_used
= 1;
4114 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4121 peer_af_flag_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4123 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 1);
4127 peer_af_flag_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4129 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 0);
4133 int peer_tx_shutdown_message_set (struct peer
*peer
, const char *msg
)
4135 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4136 peer
->tx_shutdown_message
= msg
? XSTRDUP (MTYPE_PEER_TX_SHUTDOWN_MSG
, msg
) : NULL
;
4140 int peer_tx_shutdown_message_unset (struct peer
*peer
)
4142 XFREE (MTYPE_PEER_TX_SHUTDOWN_MSG
, peer
->tx_shutdown_message
);
4147 /* EBGP multihop configuration. */
4149 peer_ebgp_multihop_set (struct peer
*peer
, int ttl
)
4151 struct peer_group
*group
;
4152 struct listnode
*node
, *nnode
;
4155 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4158 /* see comment in peer_ttl_security_hops_set() */
4161 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4163 group
= peer
->group
;
4164 if (group
->conf
->gtsm_hops
!= 0)
4165 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4167 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
4169 if (peer1
->sort
== BGP_PEER_IBGP
)
4172 if (peer1
->gtsm_hops
!= 0)
4173 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4178 if (peer
->gtsm_hops
!= 0)
4179 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4185 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4187 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
)
4189 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4190 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4191 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4193 bgp_session_reset(peer
);
4198 group
= peer
->group
;
4199 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4201 if (peer
->sort
== BGP_PEER_IBGP
)
4204 peer
->ttl
= group
->conf
->ttl
;
4206 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4207 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4208 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4210 bgp_session_reset(peer
);
4217 peer_ebgp_multihop_unset (struct peer
*peer
)
4219 struct peer_group
*group
;
4220 struct listnode
*node
, *nnode
;
4222 if (peer
->sort
== BGP_PEER_IBGP
)
4225 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4226 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4228 if (peer_group_active (peer
))
4229 peer
->ttl
= peer
->group
->conf
->ttl
;
4233 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4235 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4236 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4237 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4239 bgp_session_reset(peer
);
4243 group
= peer
->group
;
4244 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4246 if (peer
->sort
== BGP_PEER_IBGP
)
4253 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4254 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4255 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4257 bgp_session_reset(peer
);
4264 /* Neighbor description. */
4266 peer_description_set (struct peer
*peer
, const char *desc
)
4269 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4271 peer
->desc
= XSTRDUP (MTYPE_PEER_DESC
, desc
);
4277 peer_description_unset (struct peer
*peer
)
4280 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4287 /* Neighbor update-source. */
4289 peer_update_source_if_set (struct peer
*peer
, const char *ifname
)
4291 struct peer_group
*group
;
4292 struct listnode
*node
, *nnode
;
4294 if (peer
->update_if
)
4296 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4297 && strcmp (peer
->update_if
, ifname
) == 0)
4300 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4301 peer
->update_if
= NULL
;
4304 if (peer
->update_source
)
4306 sockunion_free (peer
->update_source
);
4307 peer
->update_source
= NULL
;
4310 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4312 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4314 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4316 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4317 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4318 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4321 bgp_session_reset(peer
);
4325 /* peer-group member updates. */
4326 group
= peer
->group
;
4327 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4329 if (peer
->update_if
)
4331 if (strcmp (peer
->update_if
, ifname
) == 0)
4334 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4335 peer
->update_if
= NULL
;
4338 if (peer
->update_source
)
4340 sockunion_free (peer
->update_source
);
4341 peer
->update_source
= NULL
;
4344 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4346 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4348 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4349 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4350 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4353 bgp_session_reset(peer
);
4359 peer_update_source_addr_set (struct peer
*peer
, const union sockunion
*su
)
4361 struct peer_group
*group
;
4362 struct listnode
*node
, *nnode
;
4364 if (peer
->update_source
)
4366 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4367 && sockunion_cmp (peer
->update_source
, su
) == 0)
4369 sockunion_free (peer
->update_source
);
4370 peer
->update_source
= NULL
;
4373 if (peer
->update_if
)
4375 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4376 peer
->update_if
= NULL
;
4380 peer
->update_source
= sockunion_dup (su
);
4382 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4384 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4386 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4387 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4388 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4391 bgp_session_reset(peer
);
4395 /* peer-group member updates. */
4396 group
= peer
->group
;
4397 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4399 if (peer
->update_source
)
4401 if (sockunion_cmp (peer
->update_source
, su
) == 0)
4403 sockunion_free (peer
->update_source
);
4404 peer
->update_source
= NULL
;
4407 if (peer
->update_if
)
4409 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4410 peer
->update_if
= NULL
;
4413 peer
->update_source
= sockunion_dup (su
);
4415 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4417 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4418 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4419 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4422 bgp_session_reset(peer
);
4428 peer_update_source_unset (struct peer
*peer
)
4430 union sockunion
*su
;
4431 struct peer_group
*group
;
4432 struct listnode
*node
, *nnode
;
4434 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4435 && ! peer
->update_source
4436 && ! peer
->update_if
)
4439 if (peer
->update_source
)
4441 sockunion_free (peer
->update_source
);
4442 peer
->update_source
= NULL
;
4444 if (peer
->update_if
)
4446 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4447 peer
->update_if
= NULL
;
4450 if (peer_group_active (peer
))
4452 group
= peer
->group
;
4454 if (group
->conf
->update_source
)
4456 su
= sockunion_dup (group
->conf
->update_source
);
4457 peer
->update_source
= su
;
4459 else if (group
->conf
->update_if
)
4461 XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, group
->conf
->update_if
);
4464 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4466 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4468 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4469 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4470 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4473 bgp_session_reset(peer
);
4477 /* peer-group member updates. */
4478 group
= peer
->group
;
4479 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4481 if (! peer
->update_source
&& ! peer
->update_if
)
4484 if (peer
->update_source
)
4486 sockunion_free (peer
->update_source
);
4487 peer
->update_source
= NULL
;
4490 if (peer
->update_if
)
4492 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4493 peer
->update_if
= NULL
;
4496 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4498 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4499 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4500 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4503 bgp_session_reset(peer
);
4509 peer_default_originate_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
4512 struct peer_group
*group
;
4513 struct listnode
*node
, *nnode
;
4515 if (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
)
4516 || (rmap
&& ! peer
->default_rmap
[afi
][safi
].name
)
4517 || (rmap
&& strcmp (rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0))
4519 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4523 if (peer
->default_rmap
[afi
][safi
].name
)
4524 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4525 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4526 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4530 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4532 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4533 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4534 bgp_default_originate (peer
, afi
, safi
, 0);
4535 bgp_announce_route (peer
, afi
, safi
);
4540 /* peer-group member updates. */
4541 group
= peer
->group
;
4542 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4544 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4548 if (peer
->default_rmap
[afi
][safi
].name
)
4549 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4550 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4551 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4554 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4555 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4556 bgp_default_originate (peer
, afi
, safi
, 0);
4557 bgp_announce_route (peer
, afi
, safi
);
4564 peer_default_originate_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4566 struct peer_group
*group
;
4567 struct listnode
*node
, *nnode
;
4569 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
))
4571 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4573 if (peer
->default_rmap
[afi
][safi
].name
)
4574 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4575 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4576 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4579 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4581 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4582 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4583 bgp_default_originate (peer
, afi
, safi
, 1);
4584 bgp_announce_route (peer
, afi
, safi
);
4589 /* peer-group member updates. */
4590 group
= peer
->group
;
4591 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4593 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4595 if (peer
->default_rmap
[afi
][safi
].name
)
4596 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4597 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4598 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4600 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4601 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4602 bgp_default_originate (peer
, afi
, safi
, 1);
4603 bgp_announce_route (peer
, afi
, safi
);
4610 peer_port_set (struct peer
*peer
, u_int16_t port
)
4617 peer_port_unset (struct peer
*peer
)
4619 peer
->port
= BGP_PORT_DEFAULT
;
4624 * Helper function that is called after the name of the policy
4625 * being used by a peer has changed (AF specific). Automatically
4626 * initiates inbound or outbound processing as needed.
4629 peer_on_policy_change (struct peer
*peer
, afi_t afi
, safi_t safi
, int outbound
)
4633 update_group_adjust_peer (peer_af_find (peer
, afi
, safi
));
4634 if (peer
->status
== Established
)
4635 bgp_announce_route(peer
, afi
, safi
);
4639 if (peer
->status
!= Established
)
4642 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
4643 bgp_soft_reconfig_in (peer
, afi
, safi
);
4644 else if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4645 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4646 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
4651 /* neighbor weight. */
4653 peer_weight_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int16_t weight
)
4655 struct peer_group
*group
;
4656 struct listnode
*node
, *nnode
;
4658 if (peer
->weight
[afi
][safi
] != weight
)
4660 peer
->weight
[afi
][safi
] = weight
;
4661 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4662 peer_on_policy_change (peer
, afi
, safi
, 0);
4665 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4668 /* peer-group member updates. */
4669 group
= peer
->group
;
4670 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4672 if (peer
->weight
[afi
][safi
] != weight
)
4674 peer
->weight
[afi
][safi
] = weight
;
4675 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4676 peer_on_policy_change (peer
, afi
, safi
, 0);
4683 peer_weight_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4685 struct peer_group
*group
;
4686 struct listnode
*node
, *nnode
;
4688 /* not the peer-group itself but a peer in a peer-group */
4689 if (peer_group_active (peer
))
4691 group
= peer
->group
;
4693 /* inherit weight from the peer-group */
4694 if (CHECK_FLAG (group
->conf
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4696 peer
->weight
[afi
][safi
] = group
->conf
->weight
[afi
][safi
];
4697 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4698 peer_on_policy_change (peer
, afi
, safi
, 0);
4702 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4704 peer
->weight
[afi
][safi
] = 0;
4705 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4706 peer_on_policy_change (peer
, afi
, safi
, 0);
4713 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4715 peer
->weight
[afi
][safi
] = 0;
4716 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4717 peer_on_policy_change (peer
, afi
, safi
, 0);
4720 /* peer-group member updates. */
4721 group
= peer
->group
;
4725 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4727 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4729 peer
->weight
[afi
][safi
] = 0;
4730 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4731 peer_on_policy_change (peer
, afi
, safi
, 0);
4740 peer_timers_set (struct peer
*peer
, u_int32_t keepalive
, u_int32_t holdtime
)
4742 struct peer_group
*group
;
4743 struct listnode
*node
, *nnode
;
4745 /* keepalive value check. */
4746 if (keepalive
> 65535)
4747 return BGP_ERR_INVALID_VALUE
;
4749 /* Holdtime value check. */
4750 if (holdtime
> 65535)
4751 return BGP_ERR_INVALID_VALUE
;
4753 /* Holdtime value must be either 0 or greater than 3. */
4754 if (holdtime
< 3 && holdtime
!= 0)
4755 return BGP_ERR_INVALID_VALUE
;
4757 /* Set value to the configuration. */
4758 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4759 peer
->holdtime
= holdtime
;
4760 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4762 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4765 /* peer-group member updates. */
4766 group
= peer
->group
;
4767 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4769 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4770 peer
->holdtime
= group
->conf
->holdtime
;
4771 peer
->keepalive
= group
->conf
->keepalive
;
4777 peer_timers_unset (struct peer
*peer
)
4779 struct peer_group
*group
;
4780 struct listnode
*node
, *nnode
;
4782 /* Clear configuration. */
4783 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4784 peer
->keepalive
= 0;
4787 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4790 /* peer-group member updates. */
4791 group
= peer
->group
;
4792 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4794 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4796 peer
->keepalive
= 0;
4803 peer_timers_connect_set (struct peer
*peer
, u_int32_t connect
)
4805 struct peer_group
*group
;
4806 struct listnode
*node
, *nnode
;
4808 if (connect
> 65535)
4809 return BGP_ERR_INVALID_VALUE
;
4811 /* Set value to the configuration. */
4812 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4813 peer
->connect
= connect
;
4815 /* Set value to timer setting. */
4816 peer
->v_connect
= connect
;
4818 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4821 /* peer-group member updates. */
4822 group
= peer
->group
;
4823 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4825 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4826 peer
->connect
= connect
;
4827 peer
->v_connect
= connect
;
4833 peer_timers_connect_unset (struct peer
*peer
)
4835 struct peer_group
*group
;
4836 struct listnode
*node
, *nnode
;
4838 /* Clear configuration. */
4839 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4842 /* Set timer setting to default value. */
4843 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4845 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4848 /* peer-group member updates. */
4849 group
= peer
->group
;
4850 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4852 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4854 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4860 peer_advertise_interval_set (struct peer
*peer
, u_int32_t routeadv
)
4862 struct peer_group
*group
;
4863 struct listnode
*node
, *nnode
;
4866 return BGP_ERR_INVALID_VALUE
;
4868 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4869 peer
->routeadv
= routeadv
;
4870 peer
->v_routeadv
= routeadv
;
4872 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4873 update_group_adjust_peer_afs (peer
);
4874 if (peer
->status
== Established
)
4875 bgp_announce_route_all (peer
);
4879 /* peer-group member updates. */
4880 group
= peer
->group
;
4881 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4883 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4884 peer
->routeadv
= routeadv
;
4885 peer
->v_routeadv
= routeadv
;
4886 update_group_adjust_peer_afs (peer
);
4887 if (peer
->status
== Established
)
4888 bgp_announce_route_all (peer
);
4895 peer_advertise_interval_unset (struct peer
*peer
)
4897 struct peer_group
*group
;
4898 struct listnode
*node
, *nnode
;
4900 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4903 if (peer
->sort
== BGP_PEER_IBGP
)
4904 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4906 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4908 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4909 update_group_adjust_peer_afs (peer
);
4910 if (peer
->status
== Established
)
4911 bgp_announce_route_all (peer
);
4915 /* peer-group member updates. */
4916 group
= peer
->group
;
4917 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4919 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4922 if (peer
->sort
== BGP_PEER_IBGP
)
4923 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4925 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4927 update_group_adjust_peer_afs (peer
);
4928 if (peer
->status
== Established
)
4929 bgp_announce_route_all (peer
);
4935 /* neighbor interface */
4937 peer_interface_set (struct peer
*peer
, const char *str
)
4940 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4941 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
4945 peer_interface_unset (struct peer
*peer
)
4948 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4949 peer
->ifname
= NULL
;
4954 peer_allowas_in_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int allow_num
,
4957 struct peer_group
*group
;
4958 struct listnode
*node
, *nnode
;
4962 if (peer
->allowas_in
[afi
][safi
] ||
4963 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
4964 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
4966 peer
->allowas_in
[afi
][safi
] = 0;
4967 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4968 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4969 peer_on_policy_change (peer
, afi
, safi
, 0);
4972 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4975 group
= peer
->group
;
4976 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4978 if (peer
->allowas_in
[afi
][safi
] ||
4979 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
4980 !CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
4982 peer
->allowas_in
[afi
][safi
] = 0;
4983 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4984 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
4985 peer_on_policy_change (peer
, afi
, safi
, 0);
4991 if (allow_num
< 1 || allow_num
> 10)
4992 return BGP_ERR_INVALID_VALUE
;
4994 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
4995 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
4997 peer
->allowas_in
[afi
][safi
] = allow_num
;
4998 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4999 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5000 peer_on_policy_change (peer
, afi
, safi
, 0);
5003 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5006 group
= peer
->group
;
5007 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5009 if (peer
->allowas_in
[afi
][safi
] != allow_num
||
5010 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5012 peer
->allowas_in
[afi
][safi
] = allow_num
;
5013 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5014 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5015 peer_on_policy_change (peer
, afi
, safi
, 0);
5024 peer_allowas_in_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5026 struct peer_group
*group
;
5027 struct listnode
*node
, *nnode
;
5029 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5030 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5032 peer
->allowas_in
[afi
][safi
] = 0;
5033 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5034 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5035 peer_on_policy_change (peer
, afi
, safi
, 0);
5038 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5041 group
= peer
->group
;
5042 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5044 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
) ||
5045 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN_ORIGIN
))
5047 peer
->allowas_in
[afi
][safi
] = 0;
5048 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
5049 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
);
5050 peer_on_policy_change (peer
, afi
, safi
, 0);
5057 peer_local_as_set (struct peer
*peer
, as_t as
, int no_prepend
, int replace_as
)
5059 struct bgp
*bgp
= peer
->bgp
;
5060 struct peer_group
*group
;
5061 struct listnode
*node
, *nnode
;
5063 if (peer_sort (peer
) != BGP_PEER_EBGP
5064 && peer_sort (peer
) != BGP_PEER_INTERNAL
)
5065 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
5068 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
5071 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
5073 if (peer
->change_local_as
== as
&&
5074 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && no_prepend
)
5075 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && ! no_prepend
)) &&
5076 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && replace_as
)
5077 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && ! replace_as
)))
5080 peer
->change_local_as
= as
;
5082 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5084 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5087 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5089 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5091 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5093 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5095 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5096 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5097 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5100 bgp_session_reset(peer
);
5104 group
= peer
->group
;
5105 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5107 peer
->change_local_as
= as
;
5109 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5111 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5114 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5116 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5118 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5120 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5121 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5122 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5125 BGP_EVENT_ADD (peer
, BGP_Stop
);
5132 peer_local_as_unset (struct peer
*peer
)
5134 struct peer_group
*group
;
5135 struct listnode
*node
, *nnode
;
5137 if (! peer
->change_local_as
)
5140 peer
->change_local_as
= 0;
5141 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5142 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5144 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5146 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5148 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5149 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5150 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5153 BGP_EVENT_ADD (peer
, BGP_Stop
);
5158 group
= peer
->group
;
5159 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5161 peer
->change_local_as
= 0;
5162 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5163 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5165 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5167 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5168 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5169 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5172 bgp_session_reset(peer
);
5177 /* Set password for authenticating with the peer. */
5179 peer_password_set (struct peer
*peer
, const char *password
)
5181 struct listnode
*nn
, *nnode
;
5182 int len
= password
? strlen(password
) : 0;
5183 int ret
= BGP_SUCCESS
;
5185 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5186 return BGP_ERR_INVALID_VALUE
;
5188 if (peer
->password
&& strcmp (peer
->password
, password
) == 0
5189 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5193 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5195 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, password
);
5197 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5199 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5200 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5202 bgp_session_reset(peer
);
5204 if (BGP_PEER_SU_UNSPEC(peer
))
5207 return (bgp_md5_set (peer
) >= 0) ? BGP_SUCCESS
: BGP_ERR_TCPSIG_FAILED
;
5210 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5212 if (peer
->password
&& strcmp (peer
->password
, password
) == 0)
5216 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5218 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5220 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5221 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5223 bgp_session_reset(peer
);
5225 if (! BGP_PEER_SU_UNSPEC(peer
))
5227 if (bgp_md5_set (peer
) < 0)
5228 ret
= BGP_ERR_TCPSIG_FAILED
;
5236 peer_password_unset (struct peer
*peer
)
5238 struct listnode
*nn
, *nnode
;
5241 && !CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5244 if (!CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5246 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5247 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5249 bgp_session_reset(peer
);
5252 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5254 peer
->password
= NULL
;
5256 if (! BGP_PEER_SU_UNSPEC(peer
))
5257 bgp_md5_unset (peer
);
5262 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5263 peer
->password
= NULL
;
5265 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5267 if (!peer
->password
)
5270 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5271 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5273 bgp_session_reset(peer
);
5275 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5276 peer
->password
= NULL
;
5278 if (! BGP_PEER_SU_UNSPEC(peer
))
5279 bgp_md5_unset (peer
);
5286 /* Set distribute list to the peer. */
5288 peer_distribute_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5291 struct bgp_filter
*filter
;
5292 struct peer_group
*group
;
5293 struct listnode
*node
, *nnode
;
5295 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5296 return BGP_ERR_INVALID_VALUE
;
5298 filter
= &peer
->filter
[afi
][safi
];
5300 if (filter
->plist
[direct
].name
)
5301 return BGP_ERR_PEER_FILTER_CONFLICT
;
5303 if (filter
->dlist
[direct
].name
)
5304 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5305 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5306 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5308 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5310 peer_on_policy_change(peer
, afi
, safi
,
5311 (direct
== FILTER_OUT
) ? 1 : 0);
5315 group
= peer
->group
;
5316 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5318 filter
= &peer
->filter
[afi
][safi
];
5320 if (filter
->dlist
[direct
].name
)
5321 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5322 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5323 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5324 peer_on_policy_change(peer
, afi
, safi
,
5325 (direct
== FILTER_OUT
) ? 1 : 0);
5332 peer_distribute_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5334 struct bgp_filter
*filter
;
5335 struct bgp_filter
*gfilter
;
5336 struct peer_group
*group
;
5337 struct listnode
*node
, *nnode
;
5339 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5340 return BGP_ERR_INVALID_VALUE
;
5342 filter
= &peer
->filter
[afi
][safi
];
5344 /* apply peer-group filter */
5345 if (peer_group_active(peer
))
5347 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5349 if (gfilter
->dlist
[direct
].name
)
5351 if (filter
->dlist
[direct
].name
)
5352 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5353 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[direct
].name
);
5354 filter
->dlist
[direct
].alist
= gfilter
->dlist
[direct
].alist
;
5355 peer_on_policy_change(peer
, afi
, safi
,
5356 (direct
== FILTER_OUT
) ? 1 : 0);
5361 if (filter
->dlist
[direct
].name
)
5362 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5363 filter
->dlist
[direct
].name
= NULL
;
5364 filter
->dlist
[direct
].alist
= NULL
;
5366 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5368 peer_on_policy_change(peer
, afi
, safi
,
5369 (direct
== FILTER_OUT
) ? 1 : 0);
5373 group
= peer
->group
;
5374 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5376 filter
= &peer
->filter
[afi
][safi
];
5378 if (filter
->dlist
[direct
].name
)
5379 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5380 filter
->dlist
[direct
].name
= NULL
;
5381 filter
->dlist
[direct
].alist
= NULL
;
5382 peer_on_policy_change(peer
, afi
, safi
,
5383 (direct
== FILTER_OUT
) ? 1 : 0);
5389 /* Update distribute list. */
5391 peer_distribute_update (struct access_list
*access
)
5396 struct listnode
*mnode
, *mnnode
;
5397 struct listnode
*node
, *nnode
;
5400 struct peer_group
*group
;
5401 struct bgp_filter
*filter
;
5403 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5406 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, access
->name
,
5408 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5410 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5411 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5413 filter
= &peer
->filter
[afi
][safi
];
5415 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5417 if (filter
->dlist
[direct
].name
)
5418 filter
->dlist
[direct
].alist
=
5419 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5421 filter
->dlist
[direct
].alist
= NULL
;
5425 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5427 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5428 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5430 filter
= &group
->conf
->filter
[afi
][safi
];
5432 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5434 if (filter
->dlist
[direct
].name
)
5435 filter
->dlist
[direct
].alist
=
5436 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5438 filter
->dlist
[direct
].alist
= NULL
;
5443 vnc_prefix_list_update(bgp
);
5448 /* Set prefix list to the peer. */
5450 peer_prefix_list_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5453 struct bgp_filter
*filter
;
5454 struct peer_group
*group
;
5455 struct listnode
*node
, *nnode
;
5457 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5458 return BGP_ERR_INVALID_VALUE
;
5460 filter
= &peer
->filter
[afi
][safi
];
5462 if (filter
->dlist
[direct
].name
)
5463 return BGP_ERR_PEER_FILTER_CONFLICT
;
5465 if (filter
->plist
[direct
].name
)
5466 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5467 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5468 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5470 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5472 peer_on_policy_change(peer
, afi
, safi
,
5473 (direct
== FILTER_OUT
) ? 1 : 0);
5477 group
= peer
->group
;
5478 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5480 filter
= &peer
->filter
[afi
][safi
];
5482 if (filter
->plist
[direct
].name
)
5483 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5484 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5485 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5486 peer_on_policy_change(peer
, afi
, safi
,
5487 (direct
== FILTER_OUT
) ? 1 : 0);
5493 peer_prefix_list_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5495 struct bgp_filter
*filter
;
5496 struct bgp_filter
*gfilter
;
5497 struct peer_group
*group
;
5498 struct listnode
*node
, *nnode
;
5500 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5501 return BGP_ERR_INVALID_VALUE
;
5503 filter
= &peer
->filter
[afi
][safi
];
5505 /* apply peer-group filter */
5506 if (peer_group_active(peer
))
5508 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5510 if (gfilter
->plist
[direct
].name
)
5512 if (filter
->plist
[direct
].name
)
5513 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5514 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[direct
].name
);
5515 filter
->plist
[direct
].plist
= gfilter
->plist
[direct
].plist
;
5516 peer_on_policy_change(peer
, afi
, safi
,
5517 (direct
== FILTER_OUT
) ? 1 : 0);
5522 if (filter
->plist
[direct
].name
)
5523 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5524 filter
->plist
[direct
].name
= NULL
;
5525 filter
->plist
[direct
].plist
= NULL
;
5527 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5529 peer_on_policy_change(peer
, afi
, safi
,
5530 (direct
== FILTER_OUT
) ? 1 : 0);
5534 group
= peer
->group
;
5535 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5537 filter
= &peer
->filter
[afi
][safi
];
5539 if (filter
->plist
[direct
].name
)
5540 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5541 filter
->plist
[direct
].name
= NULL
;
5542 filter
->plist
[direct
].plist
= NULL
;
5543 peer_on_policy_change(peer
, afi
, safi
,
5544 (direct
== FILTER_OUT
) ? 1 : 0);
5550 /* Update prefix-list list. */
5552 peer_prefix_list_update (struct prefix_list
*plist
)
5554 struct listnode
*mnode
, *mnnode
;
5555 struct listnode
*node
, *nnode
;
5558 struct peer_group
*group
;
5559 struct bgp_filter
*filter
;
5564 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5568 * Update the prefix-list on update groups.
5570 update_group_policy_update(bgp
, BGP_POLICY_PREFIX_LIST
,
5571 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5573 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5575 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5576 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5578 filter
= &peer
->filter
[afi
][safi
];
5580 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5582 if (filter
->plist
[direct
].name
)
5583 filter
->plist
[direct
].plist
=
5584 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5586 filter
->plist
[direct
].plist
= NULL
;
5590 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5592 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5593 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5595 filter
= &group
->conf
->filter
[afi
][safi
];
5597 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5599 if (filter
->plist
[direct
].name
)
5600 filter
->plist
[direct
].plist
=
5601 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5603 filter
->plist
[direct
].plist
= NULL
;
5611 peer_aslist_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5614 struct bgp_filter
*filter
;
5615 struct peer_group
*group
;
5616 struct listnode
*node
, *nnode
;
5618 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5619 return BGP_ERR_INVALID_VALUE
;
5621 filter
= &peer
->filter
[afi
][safi
];
5623 if (filter
->aslist
[direct
].name
)
5624 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5625 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5626 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5628 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5630 peer_on_policy_change(peer
, afi
, safi
,
5631 (direct
== FILTER_OUT
) ? 1 : 0);
5635 group
= peer
->group
;
5636 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5638 filter
= &peer
->filter
[afi
][safi
];
5640 if (filter
->aslist
[direct
].name
)
5641 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5642 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5643 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5644 peer_on_policy_change(peer
, afi
, safi
,
5645 (direct
== FILTER_OUT
) ? 1 : 0);
5651 peer_aslist_unset (struct peer
*peer
,afi_t afi
, safi_t safi
, int direct
)
5653 struct bgp_filter
*filter
;
5654 struct bgp_filter
*gfilter
;
5655 struct peer_group
*group
;
5656 struct listnode
*node
, *nnode
;
5658 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5659 return BGP_ERR_INVALID_VALUE
;
5661 filter
= &peer
->filter
[afi
][safi
];
5663 /* apply peer-group filter */
5664 if (peer_group_active(peer
))
5666 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5668 if (gfilter
->aslist
[direct
].name
)
5670 if (filter
->aslist
[direct
].name
)
5671 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5672 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[direct
].name
);
5673 filter
->aslist
[direct
].aslist
= gfilter
->aslist
[direct
].aslist
;
5674 peer_on_policy_change(peer
, afi
, safi
,
5675 (direct
== FILTER_OUT
) ? 1 : 0);
5680 if (filter
->aslist
[direct
].name
)
5681 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5682 filter
->aslist
[direct
].name
= NULL
;
5683 filter
->aslist
[direct
].aslist
= NULL
;
5685 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5687 peer_on_policy_change(peer
, afi
, safi
,
5688 (direct
== FILTER_OUT
) ? 1 : 0);
5692 group
= peer
->group
;
5693 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5695 filter
= &peer
->filter
[afi
][safi
];
5697 if (filter
->aslist
[direct
].name
)
5698 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5699 filter
->aslist
[direct
].name
= NULL
;
5700 filter
->aslist
[direct
].aslist
= NULL
;
5701 peer_on_policy_change(peer
, afi
, safi
,
5702 (direct
== FILTER_OUT
) ? 1 : 0);
5709 peer_aslist_update (const char *aslist_name
)
5714 struct listnode
*mnode
, *mnnode
;
5715 struct listnode
*node
, *nnode
;
5718 struct peer_group
*group
;
5719 struct bgp_filter
*filter
;
5721 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5723 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, aslist_name
,
5726 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5728 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5729 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5731 filter
= &peer
->filter
[afi
][safi
];
5733 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5735 if (filter
->aslist
[direct
].name
)
5736 filter
->aslist
[direct
].aslist
=
5737 as_list_lookup (filter
->aslist
[direct
].name
);
5739 filter
->aslist
[direct
].aslist
= NULL
;
5743 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5745 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5746 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5748 filter
= &group
->conf
->filter
[afi
][safi
];
5750 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5752 if (filter
->aslist
[direct
].name
)
5753 filter
->aslist
[direct
].aslist
=
5754 as_list_lookup (filter
->aslist
[direct
].name
);
5756 filter
->aslist
[direct
].aslist
= NULL
;
5764 peer_aslist_add (char *aslist_name
)
5766 peer_aslist_update (aslist_name
);
5767 route_map_notify_dependencies((char *)aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
5771 peer_aslist_del (const char *aslist_name
)
5773 peer_aslist_update (aslist_name
);
5774 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
5779 peer_route_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5782 struct bgp_filter
*filter
;
5783 struct peer_group
*group
;
5784 struct listnode
*node
, *nnode
;
5786 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5787 return BGP_ERR_INVALID_VALUE
;
5789 filter
= &peer
->filter
[afi
][safi
];
5791 if (filter
->map
[direct
].name
)
5792 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5794 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5795 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5797 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5799 peer_on_policy_change(peer
, afi
, safi
,
5800 (direct
== RMAP_OUT
) ? 1 : 0);
5804 group
= peer
->group
;
5805 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5807 filter
= &peer
->filter
[afi
][safi
];
5809 if (filter
->map
[direct
].name
)
5810 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5811 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5812 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5813 peer_on_policy_change(peer
, afi
, safi
,
5814 (direct
== RMAP_OUT
) ? 1 : 0);
5819 /* Unset route-map from the peer. */
5821 peer_route_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5823 struct bgp_filter
*filter
;
5824 struct bgp_filter
*gfilter
;
5825 struct peer_group
*group
;
5826 struct listnode
*node
, *nnode
;
5828 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5829 return BGP_ERR_INVALID_VALUE
;
5831 filter
= &peer
->filter
[afi
][safi
];
5833 /* apply peer-group filter */
5834 if (peer_group_active(peer
))
5836 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5838 if (gfilter
->map
[direct
].name
)
5840 if (filter
->map
[direct
].name
)
5841 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5842 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[direct
].name
);
5843 filter
->map
[direct
].map
= gfilter
->map
[direct
].map
;
5844 peer_on_policy_change(peer
, afi
, safi
,
5845 (direct
== RMAP_OUT
) ? 1 : 0);
5850 if (filter
->map
[direct
].name
)
5851 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5852 filter
->map
[direct
].name
= NULL
;
5853 filter
->map
[direct
].map
= NULL
;
5855 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5857 peer_on_policy_change(peer
, afi
, safi
,
5858 (direct
== RMAP_OUT
) ? 1 : 0);
5862 group
= peer
->group
;
5863 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5865 filter
= &peer
->filter
[afi
][safi
];
5867 if (filter
->map
[direct
].name
)
5868 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5869 filter
->map
[direct
].name
= NULL
;
5870 filter
->map
[direct
].map
= NULL
;
5871 peer_on_policy_change(peer
, afi
, safi
,
5872 (direct
== RMAP_OUT
) ? 1 : 0);
5877 /* Set unsuppress-map to the peer. */
5879 peer_unsuppress_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5882 struct bgp_filter
*filter
;
5883 struct peer_group
*group
;
5884 struct listnode
*node
, *nnode
;
5886 filter
= &peer
->filter
[afi
][safi
];
5888 if (filter
->usmap
.name
)
5889 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5891 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5892 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5894 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5896 peer_on_policy_change(peer
, afi
, safi
, 1);
5900 group
= peer
->group
;
5901 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5903 filter
= &peer
->filter
[afi
][safi
];
5905 if (filter
->usmap
.name
)
5906 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5907 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5908 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5909 peer_on_policy_change(peer
, afi
, safi
, 1);
5914 /* Unset route-map from the peer. */
5916 peer_unsuppress_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5918 struct bgp_filter
*filter
;
5919 struct peer_group
*group
;
5920 struct listnode
*node
, *nnode
;
5922 filter
= &peer
->filter
[afi
][safi
];
5924 if (filter
->usmap
.name
)
5925 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5926 filter
->usmap
.name
= NULL
;
5927 filter
->usmap
.map
= NULL
;
5929 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5931 peer_on_policy_change(peer
, afi
, safi
, 1);
5935 group
= peer
->group
;
5936 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5938 filter
= &peer
->filter
[afi
][safi
];
5940 if (filter
->usmap
.name
)
5941 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5942 filter
->usmap
.name
= NULL
;
5943 filter
->usmap
.map
= NULL
;
5944 peer_on_policy_change(peer
, afi
, safi
, 1);
5950 peer_maximum_prefix_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5951 u_int32_t max
, u_char threshold
,
5952 int warning
, u_int16_t restart
)
5954 struct peer_group
*group
;
5955 struct listnode
*node
, *nnode
;
5957 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5958 peer
->pmax
[afi
][safi
] = max
;
5959 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5960 peer
->pmax_restart
[afi
][safi
] = restart
;
5962 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5964 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5966 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5968 group
= peer
->group
;
5969 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5971 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5972 peer
->pmax
[afi
][safi
] = max
;
5973 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5974 peer
->pmax_restart
[afi
][safi
] = restart
;
5976 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5978 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5980 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5981 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
5986 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5987 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
5994 peer_maximum_prefix_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5996 struct peer_group
*group
;
5997 struct listnode
*node
, *nnode
;
5999 /* apply peer-group config */
6000 if (peer_group_active(peer
))
6002 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6003 PEER_FLAG_MAX_PREFIX
))
6004 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6006 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6008 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
6009 PEER_FLAG_MAX_PREFIX_WARNING
))
6010 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6012 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6014 peer
->pmax
[afi
][safi
] = peer
->group
->conf
->pmax
[afi
][safi
];
6015 peer
->pmax_threshold
[afi
][safi
] = peer
->group
->conf
->pmax_threshold
[afi
][safi
];
6016 peer
->pmax_restart
[afi
][safi
] = peer
->group
->conf
->pmax_restart
[afi
][safi
];
6020 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6021 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6022 peer
->pmax
[afi
][safi
] = 0;
6023 peer
->pmax_threshold
[afi
][safi
] = 0;
6024 peer
->pmax_restart
[afi
][safi
] = 0;
6026 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6029 group
= peer
->group
;
6030 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6032 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
6033 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
6034 peer
->pmax
[afi
][safi
] = 0;
6035 peer
->pmax_threshold
[afi
][safi
] = 0;
6036 peer
->pmax_restart
[afi
][safi
] = 0;
6041 int is_ebgp_multihop_configured (struct peer
*peer
)
6043 struct peer_group
*group
;
6044 struct listnode
*node
, *nnode
;
6047 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6049 group
= peer
->group
;
6050 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6051 (group
->conf
->ttl
!= 1))
6054 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
6056 if ((peer_sort (peer1
) != BGP_PEER_IBGP
) &&
6063 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
6070 /* Set # of hops between us and BGP peer. */
6072 peer_ttl_security_hops_set (struct peer
*peer
, int gtsm_hops
)
6074 struct peer_group
*group
;
6075 struct listnode
*node
, *nnode
;
6078 zlog_debug ("peer_ttl_security_hops_set: set gtsm_hops to %d for %s", gtsm_hops
, peer
->host
);
6080 /* We cannot configure ttl-security hops when ebgp-multihop is already
6081 set. For non peer-groups, the check is simple. For peer-groups, it's
6082 slightly messy, because we need to check both the peer-group structure
6083 and all peer-group members for any trace of ebgp-multihop configuration
6084 before actually applying the ttl-security rules. Cisco really made a
6085 mess of this configuration parameter, and OpenBGPD got it right.
6088 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
))
6090 if (is_ebgp_multihop_configured (peer
))
6091 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
6093 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6095 peer
->gtsm_hops
= gtsm_hops
;
6097 /* Calling ebgp multihop also resets the session.
6098 * On restart, NHT will get setup correctly as will the
6099 * min & max ttls on the socket. The return value is
6102 ret
= peer_ebgp_multihop_set (peer
, MAXTTL
);
6109 group
= peer
->group
;
6110 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6112 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6114 /* Calling ebgp multihop also resets the session.
6115 * On restart, NHT will get setup correctly as will the
6116 * min & max ttls on the socket. The return value is
6119 peer_ebgp_multihop_set (peer
, MAXTTL
);
6125 /* Post the first gtsm setup or if its ibgp, maxttl setting isn't
6126 * necessary, just set the minttl.
6128 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6130 peer
->gtsm_hops
= gtsm_hops
;
6133 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6134 MAXTTL
+ 1 - gtsm_hops
);
6135 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6136 (peer
->doppelganger
->fd
>= 0))
6137 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6138 MAXTTL
+ 1 - gtsm_hops
);
6142 group
= peer
->group
;
6143 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6145 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
6147 /* Change setting of existing peer
6148 * established then change value (may break connectivity)
6149 * not established yet (teardown session and restart)
6150 * no session then do nothing (will get handled by next connection)
6152 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6153 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6154 MAXTTL
+ 1 - peer
->gtsm_hops
);
6155 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6156 (peer
->doppelganger
->fd
>= 0))
6157 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6158 MAXTTL
+ 1 - gtsm_hops
);
6168 peer_ttl_security_hops_unset (struct peer
*peer
)
6170 struct peer_group
*group
;
6171 struct listnode
*node
, *nnode
;
6174 zlog_debug ("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s", peer
->host
);
6176 /* if a peer-group member, then reset to peer-group default rather than 0 */
6177 if (peer_group_active (peer
))
6178 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6180 peer
->gtsm_hops
= 0;
6182 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6184 /* Invoking ebgp_multihop_set will set the TTL back to the original
6185 * value as well as restting the NHT and such. The session is reset.
6187 if (peer
->sort
== BGP_PEER_EBGP
)
6188 ret
= peer_ebgp_multihop_unset (peer
);
6192 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6194 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6195 (peer
->doppelganger
->fd
>= 0))
6196 sockopt_minttl (peer
->su
.sa
.sa_family
,
6197 peer
->doppelganger
->fd
, 0);
6202 group
= peer
->group
;
6203 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6205 peer
->gtsm_hops
= 0;
6206 if (peer
->sort
== BGP_PEER_EBGP
)
6207 ret
= peer_ebgp_multihop_unset (peer
);
6211 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6213 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6214 (peer
->doppelganger
->fd
>= 0))
6215 sockopt_minttl (peer
->su
.sa
.sa_family
,
6216 peer
->doppelganger
->fd
, 0);
6225 * If peer clear is invoked in a loop for all peers on the BGP instance,
6226 * it may end up freeing the doppelganger, and if this was the next node
6227 * to the current node, we would end up accessing the freed next node.
6228 * Pass along additional parameter which can be updated if next node
6229 * is freed; only required when walking the peer list on BGP instance.
6232 peer_clear (struct peer
*peer
, struct listnode
**nnode
)
6234 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6236 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
6238 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6239 if (peer
->t_pmax_restart
)
6241 BGP_TIMER_OFF (peer
->t_pmax_restart
);
6242 if (bgp_debug_neighbor_events(peer
))
6243 zlog_debug ("%s Maximum-prefix restart timer canceled",
6246 BGP_EVENT_ADD (peer
, BGP_Start
);
6250 peer
->v_start
= BGP_INIT_START_TIMER
;
6251 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6252 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
6253 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6255 bgp_session_reset_safe(peer
, nnode
);
6261 peer_clear_soft (struct peer
*peer
, afi_t afi
, safi_t safi
,
6262 enum bgp_clear_type stype
)
6264 struct peer_af
*paf
;
6266 if (peer
->status
!= Established
)
6269 if (! peer
->afc
[afi
][safi
])
6270 return BGP_ERR_AF_UNCONFIGURED
;
6272 peer
->rtt
= sockopt_tcp_rtt (peer
->fd
);
6274 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
)
6276 /* Clear the "neighbor x.x.x.x default-originate" flag */
6277 paf
= peer_af_find (peer
, afi
, safi
);
6278 if (paf
&& paf
->subgroup
&&
6279 CHECK_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6280 UNSET_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6282 bgp_announce_route (peer
, afi
, safi
);
6285 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6287 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
)
6288 && (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
)
6289 || CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
6291 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6294 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
))
6295 prefix_type
= ORF_TYPE_PREFIX
;
6297 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6299 if (filter
->plist
[FILTER_IN
].plist
)
6301 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6302 bgp_route_refresh_send (peer
, afi
, safi
,
6303 prefix_type
, REFRESH_DEFER
, 1);
6304 bgp_route_refresh_send (peer
, afi
, safi
, prefix_type
,
6305 REFRESH_IMMEDIATE
, 0);
6309 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6310 bgp_route_refresh_send (peer
, afi
, safi
,
6311 prefix_type
, REFRESH_IMMEDIATE
, 1);
6313 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6319 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6320 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6322 /* If neighbor has soft reconfiguration inbound flag.
6323 Use Adj-RIB-In database. */
6324 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
6325 bgp_soft_reconfig_in (peer
, afi
, safi
);
6328 /* If neighbor has route refresh capability, send route refresh
6329 message to the peer. */
6330 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6331 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6332 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6334 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6340 /* Display peer uptime.*/
6342 peer_uptime (time_t uptime2
, char *buf
, size_t len
, u_char use_json
, json_object
*json
)
6344 time_t uptime1
, epoch_tbuf
;
6347 /* Check buffer length. */
6348 if (len
< BGP_UPTIME_LEN
)
6352 zlog_warn ("peer_uptime (): buffer shortage %lu", (u_long
)len
);
6353 /* XXX: should return status instead of buf... */
6354 snprintf (buf
, len
, "<error> ");
6359 /* If there is no connection has been done before print `never'. */
6364 json_object_string_add(json
, "peerUptime", "never");
6365 json_object_int_add(json
, "peerUptimeMsec", 0);
6368 snprintf (buf
, len
, "never");
6372 /* Get current time. */
6373 uptime1
= bgp_clock ();
6375 tm
= gmtime (&uptime1
);
6377 /* Making formatted timer strings. */
6378 #define ONE_DAY_SECOND 60*60*24
6379 #define ONE_WEEK_SECOND ONE_DAY_SECOND*7
6380 #define ONE_YEAR_SECOND ONE_DAY_SECOND*365
6382 if (uptime1
< ONE_DAY_SECOND
)
6383 snprintf (buf
, len
, "%02d:%02d:%02d",
6384 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6385 else if (uptime1
< ONE_WEEK_SECOND
)
6386 snprintf (buf
, len
, "%dd%02dh%02dm",
6387 tm
->tm_yday
, tm
->tm_hour
, tm
->tm_min
);
6388 else if (uptime1
< ONE_YEAR_SECOND
)
6389 snprintf (buf
, len
, "%02dw%dd%02dh",
6390 tm
->tm_yday
/7, tm
->tm_yday
- ((tm
->tm_yday
/7) * 7), tm
->tm_hour
);
6392 snprintf (buf
, len
, "%02dy%02dw%dd",
6393 tm
->tm_year
- 70, tm
->tm_yday
/7,
6394 tm
->tm_yday
- ((tm
->tm_yday
/7) * 7));
6398 epoch_tbuf
= time(NULL
) - uptime1
;
6399 json_object_string_add(json
, "peerUptime", buf
);
6400 json_object_long_add(json
, "peerUptimeMsec", uptime1
* 1000);
6401 json_object_int_add(json
, "peerUptimeEstablishedEpoch", epoch_tbuf
);
6408 afi_header_vty_out (struct vty
*vty
, afi_t afi
, safi_t safi
,
6409 int *write
, const char *format
, ...)
6415 bgp_config_write_family_header (vty
, afi
, safi
, write
);
6417 if (vty_shell (vty
))
6419 va_start (args
, format
);
6420 vprintf (format
, args
);
6425 va_start (args
, format
);
6426 len
= vsnprintf (buf
, sizeof(buf
), format
, args
);
6429 buffer_put (vty
->obuf
, (u_char
*) buf
, len
);
6434 bgp_config_write_filter (struct vty
*vty
, struct peer
*peer
,
6435 afi_t afi
, safi_t safi
, int *write
)
6437 struct bgp_filter
*filter
;
6438 struct bgp_filter
*gfilter
= NULL
;
6441 int out
= FILTER_OUT
;
6444 filter
= &peer
->filter
[afi
][safi
];
6446 if (peer_group_active(peer
))
6447 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
6449 /* distribute-list. */
6450 if (filter
->dlist
[in
].name
)
6451 if (! gfilter
|| ! gfilter
->dlist
[in
].name
6452 || strcmp (filter
->dlist
[in
].name
, gfilter
->dlist
[in
].name
) != 0)
6454 afi_header_vty_out (vty
, afi
, safi
, write
,
6455 " neighbor %s distribute-list %s in%s",
6456 addr
, filter
->dlist
[in
].name
, VTY_NEWLINE
);
6459 if (filter
->dlist
[out
].name
&& ! gfilter
)
6461 afi_header_vty_out (vty
, afi
, safi
, write
,
6462 " neighbor %s distribute-list %s out%s",
6463 addr
, filter
->dlist
[out
].name
, VTY_NEWLINE
);
6467 if (filter
->plist
[in
].name
)
6468 if (! gfilter
|| ! gfilter
->plist
[in
].name
6469 || strcmp (filter
->plist
[in
].name
, gfilter
->plist
[in
].name
) != 0)
6471 afi_header_vty_out (vty
, afi
, safi
, write
,
6472 " neighbor %s prefix-list %s in%s",
6473 addr
, filter
->plist
[in
].name
, VTY_NEWLINE
);
6476 if (filter
->plist
[out
].name
&& ! gfilter
)
6478 afi_header_vty_out (vty
, afi
, safi
, write
,
6479 " neighbor %s prefix-list %s out%s",
6480 addr
, filter
->plist
[out
].name
, VTY_NEWLINE
);
6484 if (filter
->map
[RMAP_IN
].name
)
6485 if (! gfilter
|| ! gfilter
->map
[RMAP_IN
].name
6486 || strcmp (filter
->map
[RMAP_IN
].name
, gfilter
->map
[RMAP_IN
].name
) != 0)
6488 afi_header_vty_out (vty
, afi
, safi
, write
,
6489 " neighbor %s route-map %s in%s",
6490 addr
, filter
->map
[RMAP_IN
].name
, VTY_NEWLINE
);
6493 if (filter
->map
[RMAP_OUT
].name
)
6494 if (! gfilter
|| ! gfilter
->map
[RMAP_OUT
].name
6495 || strcmp (filter
->map
[RMAP_OUT
].name
, gfilter
->map
[RMAP_OUT
].name
) != 0)
6497 afi_header_vty_out (vty
, afi
, safi
, write
,
6498 " neighbor %s route-map %s out%s",
6499 addr
, filter
->map
[RMAP_OUT
].name
, VTY_NEWLINE
);
6502 /* unsuppress-map */
6503 if (filter
->usmap
.name
&& ! gfilter
)
6505 afi_header_vty_out (vty
, afi
, safi
, write
,
6506 " neighbor %s unsuppress-map %s%s",
6507 addr
, filter
->usmap
.name
, VTY_NEWLINE
);
6511 if (filter
->aslist
[in
].name
)
6512 if (! gfilter
|| ! gfilter
->aslist
[in
].name
6513 || strcmp (filter
->aslist
[in
].name
, gfilter
->aslist
[in
].name
) != 0)
6515 afi_header_vty_out (vty
, afi
, safi
, write
,
6516 " neighbor %s filter-list %s in%s",
6517 addr
, filter
->aslist
[in
].name
, VTY_NEWLINE
);
6520 if (filter
->aslist
[out
].name
&& ! gfilter
)
6522 afi_header_vty_out (vty
, afi
, safi
, write
,
6523 " neighbor %s filter-list %s out%s",
6524 addr
, filter
->aslist
[out
].name
, VTY_NEWLINE
);
6528 /* BGP peer configuration display function. */
6530 bgp_config_write_peer_global (struct vty
*vty
, struct bgp
*bgp
,
6533 struct peer
*g_peer
= NULL
;
6534 char buf
[SU_ADDRSTRLEN
];
6536 int if_pg_printed
= FALSE
;
6537 int if_ras_printed
= FALSE
;
6539 /* Skip dynamic neighbors. */
6540 if (peer_dynamic_neighbor (peer
))
6544 addr
= peer
->conf_if
;
6548 /************************************
6549 ****** Global to the neighbor ******
6550 ************************************/
6553 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6554 vty_out (vty
, " neighbor %s interface v6only", addr
);
6556 vty_out (vty
, " neighbor %s interface", addr
);
6558 if (peer_group_active (peer
))
6560 vty_out (vty
, " peer-group %s", peer
->group
->name
);
6561 if_pg_printed
= TRUE
;
6563 else if (peer
->as_type
== AS_SPECIFIED
)
6565 vty_out (vty
, " remote-as %u", peer
->as
);
6566 if_ras_printed
= TRUE
;
6568 else if (peer
->as_type
== AS_INTERNAL
)
6570 vty_out (vty
, " remote-as internal");
6571 if_ras_printed
= TRUE
;
6573 else if (peer
->as_type
== AS_EXTERNAL
)
6575 vty_out (vty
, " remote-as external");
6576 if_ras_printed
= TRUE
;
6579 vty_out (vty
, "%s", VTY_NEWLINE
);
6582 /* remote-as and peer-group */
6583 /* peer is a member of a peer-group */
6584 if (peer_group_active (peer
))
6586 g_peer
= peer
->group
->conf
;
6588 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
)
6590 if (peer
->as_type
== AS_SPECIFIED
)
6592 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6595 else if (peer
->as_type
== AS_INTERNAL
)
6597 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6599 else if (peer
->as_type
== AS_EXTERNAL
)
6601 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6605 /* For swpX peers we displayed the peer-group
6606 * via 'neighbor swpX interface peer-group WORD' */
6608 vty_out (vty
, " neighbor %s peer-group %s%s", addr
,
6609 peer
->group
->name
, VTY_NEWLINE
);
6612 /* peer is NOT a member of a peer-group */
6615 /* peer is a peer-group, declare the peer-group */
6616 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6618 vty_out (vty
, " neighbor %s peer-group%s", addr
,
6622 if (!if_ras_printed
)
6624 if (peer
->as_type
== AS_SPECIFIED
)
6626 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6629 else if (peer
->as_type
== AS_INTERNAL
)
6631 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6633 else if (peer
->as_type
== AS_EXTERNAL
)
6635 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6641 if (peer
->change_local_as
)
6643 if (! peer_group_active (peer
)
6644 || peer
->change_local_as
!= g_peer
->change_local_as
6645 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) !=
6646 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6647 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) !=
6648 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)))
6650 vty_out (vty
, " neighbor %s local-as %u%s%s%s", addr
,
6651 peer
->change_local_as
,
6652 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) ?
6654 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) ?
6655 " replace-as" : "", VTY_NEWLINE
);
6662 vty_out (vty
, " neighbor %s description %s%s", addr
, peer
->desc
,
6667 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6669 if (! peer_group_active (peer
) ||
6670 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_SHUTDOWN
) ||
6671 peer
->tx_shutdown_message
)
6673 if (peer
->tx_shutdown_message
)
6674 vty_out (vty
, " neighbor %s shutdown message %s%s", addr
,
6675 peer
->tx_shutdown_message
, VTY_NEWLINE
);
6677 vty_out (vty
, " neighbor %s shutdown%s", addr
, VTY_NEWLINE
);
6684 if (! peer_group_active (peer
) || ! g_peer
->bfd_info
)
6686 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6693 if (!peer_group_active (peer
)
6694 || ! g_peer
->password
6695 || strcmp (peer
->password
, g_peer
->password
) != 0)
6697 vty_out (vty
, " neighbor %s password %s%s", addr
, peer
->password
,
6703 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
))
6705 if (!peer_group_active (peer
))
6707 vty_out (vty
, " neighbor %s solo%s", addr
, VTY_NEWLINE
);
6712 if (peer
->port
!= BGP_PORT_DEFAULT
)
6714 vty_out (vty
, " neighbor %s port %d%s", addr
, peer
->port
,
6718 /* Local interface name */
6721 vty_out (vty
, " neighbor %s interface %s%s", addr
, peer
->ifname
,
6726 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_PASSIVE
))
6728 if (! peer_group_active (peer
) ||
6729 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_PASSIVE
))
6731 vty_out (vty
, " neighbor %s passive%s", addr
, VTY_NEWLINE
);
6736 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1 &&
6737 !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
))
6739 if (! peer_group_active (peer
) || g_peer
->ttl
!= peer
->ttl
)
6741 vty_out (vty
, " neighbor %s ebgp-multihop %d%s", addr
, peer
->ttl
,
6746 /* ttl-security hops */
6747 if (peer
->gtsm_hops
!= 0)
6749 if (! peer_group_active (peer
) || g_peer
->gtsm_hops
!= peer
->gtsm_hops
)
6751 vty_out (vty
, " neighbor %s ttl-security hops %d%s", addr
,
6752 peer
->gtsm_hops
, VTY_NEWLINE
);
6756 /* disable-connected-check */
6757 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6759 if (! peer_group_active (peer
) ||
6760 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6762 vty_out (vty
, " neighbor %s disable-connected-check%s", addr
, VTY_NEWLINE
);
6767 if (peer
->update_if
)
6769 if (! peer_group_active (peer
) || ! g_peer
->update_if
6770 || strcmp (g_peer
->update_if
, peer
->update_if
) != 0)
6772 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6773 peer
->update_if
, VTY_NEWLINE
);
6776 if (peer
->update_source
)
6778 if (! peer_group_active (peer
) || ! g_peer
->update_source
6779 || sockunion_cmp (g_peer
->update_source
,
6780 peer
->update_source
) != 0)
6782 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6783 sockunion2str (peer
->update_source
, buf
, SU_ADDRSTRLEN
),
6788 /* advertisement-interval */
6789 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
) &&
6790 ((! peer_group_active (peer
) && peer
->v_routeadv
!= BGP_DEFAULT_EBGP_ROUTEADV
) ||
6791 (peer_group_active (peer
) && peer
->v_routeadv
!= g_peer
->v_routeadv
)))
6793 vty_out (vty
, " neighbor %s advertisement-interval %d%s",
6794 addr
, peer
->v_routeadv
, VTY_NEWLINE
);
6798 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
) &&
6799 ((! peer_group_active (peer
) && (peer
->keepalive
!= BGP_DEFAULT_KEEPALIVE
|| peer
->holdtime
!= BGP_DEFAULT_HOLDTIME
)) ||
6800 (peer_group_active (peer
) && (peer
->keepalive
!= g_peer
->keepalive
|| peer
->holdtime
!= g_peer
->holdtime
))))
6802 vty_out (vty
, " neighbor %s timers %d %d%s", addr
,
6803 peer
->keepalive
, peer
->holdtime
, VTY_NEWLINE
);
6806 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_CONNECT
) &&
6807 ((! peer_group_active (peer
) && peer
->connect
!= BGP_DEFAULT_CONNECT_RETRY
) ||
6808 (peer_group_active (peer
) && peer
->connect
!= g_peer
->connect
)))
6811 vty_out (vty
, " neighbor %s timers connect %d%s", addr
,
6812 peer
->connect
, VTY_NEWLINE
);
6815 /* capability dynamic */
6816 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6818 if (! peer_group_active (peer
) ||
6819 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6821 vty_out (vty
, " neighbor %s capability dynamic%s", addr
,
6826 /* capability extended-nexthop */
6827 if (peer
->ifp
&& !CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6829 if (! peer_group_active (peer
) ||
6830 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6832 vty_out (vty
, " no neighbor %s capability extended-nexthop%s", addr
,
6837 if (!peer
->ifp
&& CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6839 if (! peer_group_active (peer
) ||
6840 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6842 vty_out (vty
, " neighbor %s capability extended-nexthop%s", addr
,
6847 /* dont-capability-negotiation */
6848 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6850 if (! peer_group_active (peer
) ||
6851 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6853 vty_out (vty
, " neighbor %s dont-capability-negotiate%s", addr
,
6858 /* override-capability */
6859 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6861 if (! peer_group_active (peer
) ||
6862 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6864 vty_out (vty
, " neighbor %s override-capability%s", addr
,
6869 /* strict-capability-match */
6870 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6872 if (! peer_group_active (peer
) ||
6873 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6875 vty_out (vty
, " neighbor %s strict-capability-match%s", addr
,
6881 /* BGP peer configuration display function. */
6883 bgp_config_write_peer_af (struct vty
*vty
, struct bgp
*bgp
,
6884 struct peer
*peer
, afi_t afi
, safi_t safi
,
6887 struct peer
*g_peer
= NULL
;
6890 /* Skip dynamic neighbors. */
6891 if (peer_dynamic_neighbor (peer
))
6895 addr
= peer
->conf_if
;
6899 /************************************
6900 ****** Per AF to the neighbor ******
6901 ************************************/
6902 if (peer_group_active (peer
))
6904 g_peer
= peer
->group
->conf
;
6906 /* If the peer-group is active but peer is not, print a 'no activate' */
6907 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
])
6909 afi_header_vty_out (vty
, afi
, safi
, write
,
6910 " no neighbor %s activate%s",
6914 /* If the peer-group is not active but peer is, print an 'activate' */
6915 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
])
6917 afi_header_vty_out (vty
, afi
, safi
, write
,
6918 " neighbor %s activate%s",
6924 if (peer
->afc
[afi
][safi
])
6926 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6928 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6930 afi_header_vty_out(vty
, afi
, safi
, write
,
6931 " neighbor %s activate%s",
6936 afi_header_vty_out (vty
, afi
, safi
, write
,
6937 " neighbor %s activate%s",
6942 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6944 if (!bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6946 afi_header_vty_out (vty
, afi
, safi
, write
,
6947 " no neighbor %s activate%s",
6954 /* addpath TX knobs */
6955 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
6957 afi_header_vty_out (vty
, afi
, safi
, write
,
6958 " neighbor %s addpath-tx-all-paths%s",
6962 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
6964 afi_header_vty_out (vty
, afi
, safi
, write
,
6965 " neighbor %s addpath-tx-bestpath-per-AS%s",
6969 /* ORF capability. */
6970 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) ||
6971 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6973 afi_header_vty_out (vty
, afi
, safi
, write
,
6974 " neighbor %s capability orf prefix-list",
6977 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) &&
6978 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6979 vty_out (vty
, " both");
6980 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
))
6981 vty_out (vty
, " send");
6983 vty_out (vty
, " receive");
6984 vty_out (vty
, "%s", VTY_NEWLINE
);
6987 /* Route reflector client. */
6988 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REFLECTOR_CLIENT
))
6990 afi_header_vty_out (vty
, afi
, safi
, write
,
6991 " neighbor %s route-reflector-client%s",
6995 /* next-hop-self force */
6996 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
6998 afi_header_vty_out (vty
, afi
, safi
, write
,
6999 " neighbor %s next-hop-self force%s",
7004 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
))
7006 afi_header_vty_out (vty
, afi
, safi
, write
,
7007 " neighbor %s next-hop-self%s",
7011 /* remove-private-AS */
7012 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
))
7014 afi_header_vty_out (vty
, afi
, safi
, write
,
7015 " neighbor %s remove-private-AS all replace-AS%s",
7019 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
))
7021 afi_header_vty_out (vty
, afi
, safi
, write
,
7022 " neighbor %s remove-private-AS replace-AS%s",
7026 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL
))
7028 afi_header_vty_out (vty
, afi
, safi
, write
,
7029 " neighbor %s remove-private-AS all%s",
7033 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS
))
7035 afi_header_vty_out (vty
, afi
, safi
, write
,
7036 " neighbor %s remove-private-AS%s",
7041 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
))
7043 afi_header_vty_out (vty
, afi
, safi
, write
,
7044 " neighbor %s as-override%s",
7048 /* send-community print. */
7049 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7051 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)
7052 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)
7053 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7055 afi_header_vty_out (vty
, afi
, safi
, write
,
7056 " neighbor %s send-community all%s",
7059 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
))
7061 afi_header_vty_out (vty
, afi
, safi
, write
,
7062 " neighbor %s send-community large%s",
7065 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
))
7067 afi_header_vty_out (vty
, afi
, safi
, write
,
7068 " neighbor %s send-community extended%s",
7071 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
))
7073 afi_header_vty_out (vty
, afi
, safi
, write
,
7074 " neighbor %s send-community%s",
7080 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7081 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)) &&
7082 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7083 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)) &&
7084 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7085 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7087 afi_header_vty_out (vty
, afi
, safi
, write
,
7088 " no neighbor %s send-community all%s",
7091 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
) &&
7092 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_LARGE_COMMUNITY
)))
7094 afi_header_vty_out (vty
, afi
, safi
, write
,
7095 " no neighbor %s send-community large%s",
7098 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
7099 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)))
7101 afi_header_vty_out (vty
, afi
, safi
, write
,
7102 " no neighbor %s send-community extended%s",
7105 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
7106 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)))
7108 afi_header_vty_out (vty
, afi
, safi
, write
,
7109 " no neighbor %s send-community%s",
7114 /* Default information */
7115 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
) ||
7117 ((peer
->default_rmap
[afi
][safi
].name
&& !g_peer
->default_rmap
[afi
][safi
].name
) ||
7118 (!peer
->default_rmap
[afi
][safi
].name
&& g_peer
->default_rmap
[afi
][safi
].name
) ||
7119 (peer
->default_rmap
[afi
][safi
].name
&&
7120 strcmp(peer
->default_rmap
[afi
][safi
].name
, g_peer
->default_rmap
[afi
][safi
].name
)))))
7122 afi_header_vty_out (vty
, afi
, safi
, write
,
7123 " neighbor %s default-originate", addr
);
7124 if (peer
->default_rmap
[afi
][safi
].name
)
7125 vty_out (vty
, " route-map %s", peer
->default_rmap
[afi
][safi
].name
);
7126 vty_out (vty
, "%s", VTY_NEWLINE
);
7129 /* Soft reconfiguration inbound. */
7130 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
))
7132 afi_header_vty_out (vty
, afi
, safi
, write
,
7133 " neighbor %s soft-reconfiguration inbound%s",
7137 /* maximum-prefix. */
7138 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
7139 if (! peer_group_active(peer
)
7140 || g_peer
->pmax
[afi
][safi
] != peer
->pmax
[afi
][safi
]
7141 || g_peer
->pmax_threshold
[afi
][safi
] != peer
->pmax_threshold
[afi
][safi
]
7142 || CHECK_FLAG (g_peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
)
7143 != CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7145 afi_header_vty_out (vty
, afi
, safi
, write
,
7146 " neighbor %s maximum-prefix %lu",
7147 addr
, peer
->pmax
[afi
][safi
]);
7148 if (peer
->pmax_threshold
[afi
][safi
] != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
7149 vty_out (vty
, " %d", peer
->pmax_threshold
[afi
][safi
]);
7150 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
7151 vty_out (vty
, " warning-only");
7152 if (peer
->pmax_restart
[afi
][safi
])
7153 vty_out (vty
, " restart %d", peer
->pmax_restart
[afi
][safi
]);
7154 vty_out (vty
, "%s", VTY_NEWLINE
);
7157 /* Route server client. */
7158 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_RSERVER_CLIENT
))
7160 afi_header_vty_out (vty
, afi
, safi
, write
,
7161 " neighbor %s route-server-client%s",
7165 /* Nexthop-local unchanged. */
7166 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
))
7168 afi_header_vty_out (vty
, afi
, safi
, write
,
7169 " neighbor %s nexthop-local unchanged%s",
7173 /* allowas-in <1-10> */
7174 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
))
7176 if (! peer_group_active (peer
)
7177 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)
7178 || peer
->allowas_in
[afi
][safi
] != g_peer
->allowas_in
[afi
][safi
])
7180 if (peer
->allowas_in
[afi
][safi
] == 3)
7182 afi_header_vty_out (vty
, afi
, safi
, write
,
7183 " neighbor %s allowas-in%s",
7188 afi_header_vty_out (vty
, afi
, safi
, write
,
7189 " neighbor %s allowas-in %d%s",
7190 addr
, peer
->allowas_in
[afi
][safi
], VTY_NEWLINE
);
7195 /* allowas-in origin */
7196 else if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7198 if (! peer_group_active (peer
)
7199 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN_ORIGIN
))
7201 afi_header_vty_out (vty
, afi
, safi
, write
,
7202 " neighbor %s allowas-in origin%s",
7208 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7209 if (! peer_group_active (peer
)
7210 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_WEIGHT
)
7211 || peer
->weight
[afi
][safi
] != g_peer
->weight
[afi
][safi
])
7213 if (peer
->weight
[afi
][safi
])
7215 afi_header_vty_out (vty
, afi
, safi
, write
,
7216 " neighbor %s weight %d%s",
7217 addr
, peer
->weight
[afi
][safi
], VTY_NEWLINE
);
7222 bgp_config_write_filter (vty
, peer
, afi
, safi
, write
);
7224 /* atribute-unchanged. */
7225 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_AS_PATH_UNCHANGED
)
7226 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_NEXTHOP_UNCHANGED
)
7227 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MED_UNCHANGED
))
7229 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7230 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
)
7231 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
))
7233 afi_header_vty_out (vty
, afi
, safi
, write
,
7234 " neighbor %s attribute-unchanged%s",
7239 afi_header_vty_out (vty
, afi
, safi
, write
,
7240 " neighbor %s attribute-unchanged%s%s%s%s", addr
,
7241 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
) ?
7243 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
) ?
7245 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
) ?
7246 " med" : "", VTY_NEWLINE
);
7251 /* Display "address-family" configuration header. */
7253 bgp_config_write_family_header (struct vty
*vty
, afi_t afi
, safi_t safi
,
7259 vty_out (vty
, " !%s address-family ", VTY_NEWLINE
);
7263 if (safi
== SAFI_UNICAST
)
7264 vty_out (vty
, "ipv4 unicast");
7265 else if (safi
== SAFI_MULTICAST
)
7266 vty_out (vty
, "ipv4 multicast");
7267 else if (safi
== SAFI_MPLS_VPN
)
7268 vty_out (vty
, "ipv4 vpn");
7269 else if (safi
== SAFI_ENCAP
)
7270 vty_out (vty
, "ipv4 encap");
7272 else if (afi
== AFI_IP6
)
7274 if (safi
== SAFI_UNICAST
)
7275 vty_out (vty
, "ipv6 unicast");
7276 else if (safi
== SAFI_MULTICAST
)
7277 vty_out (vty
, "ipv6 multicast");
7278 else if (safi
== SAFI_MPLS_VPN
)
7279 vty_out (vty
, "ipv6 vpn");
7280 else if (safi
== SAFI_ENCAP
)
7281 vty_out (vty
, "ipv6 encap");
7283 else if (afi
== AFI_L2VPN
)
7285 if (safi
== SAFI_EVPN
)
7286 vty_out (vty
, "l2vpn evpn");
7288 vty_out (vty
, "%s", VTY_NEWLINE
);
7293 /* Address family based peer configuration display. */
7295 bgp_config_write_family (struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7300 struct peer_group
*group
;
7301 struct listnode
*node
, *nnode
;
7303 bgp_config_write_distance (vty
, bgp
, afi
, safi
, &write
);
7305 bgp_config_write_network (vty
, bgp
, afi
, safi
, &write
);
7307 bgp_config_write_redistribute (vty
, bgp
, afi
, safi
, &write
);
7309 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7310 bgp_config_write_peer_af (vty
, bgp
, group
->conf
, afi
, safi
, &write
);
7312 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7314 /* Skip dynamic neighbors. */
7315 if (peer_dynamic_neighbor (peer
))
7318 /* Do not display doppelganger peers */
7319 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7320 bgp_config_write_peer_af (vty
, bgp
, peer
, afi
, safi
, &write
);
7323 bgp_config_write_maxpaths (vty
, bgp
, afi
, safi
, &write
);
7324 bgp_config_write_table_map (vty
, bgp
, afi
, safi
, &write
);
7327 vty_out (vty
, " exit-address-family%s", VTY_NEWLINE
);
7333 bgp_config_write (struct vty
*vty
)
7337 struct peer_group
*group
;
7339 struct listnode
*node
, *nnode
;
7340 struct listnode
*mnode
, *mnnode
;
7342 /* BGP Multiple instance. */
7343 if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7345 vty_out (vty
, "no bgp multiple-instance%s", VTY_NEWLINE
);
7349 /* BGP Config type. */
7350 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7352 vty_out (vty
, "bgp config-type cisco%s", VTY_NEWLINE
);
7356 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7357 vty_out (vty
, "bgp route-map delay-timer %d%s", bm
->rmap_update_timer
,
7360 /* BGP configuration. */
7361 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7364 vty_out (vty
, "!%s", VTY_NEWLINE
);
7366 /* Router bgp ASN */
7367 vty_out (vty
, "router bgp %u", bgp
->as
);
7369 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7372 vty_out (vty
, " %s %s",
7373 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
) ?
7374 "view" : "vrf", bgp
->name
);
7376 vty_out (vty
, "%s", VTY_NEWLINE
);
7378 /* No Synchronization */
7379 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7380 vty_out (vty
, " no synchronization%s", VTY_NEWLINE
);
7382 /* BGP fast-external-failover. */
7383 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7384 vty_out (vty
, " no bgp fast-external-failover%s", VTY_NEWLINE
);
7386 /* BGP router ID. */
7387 if (bgp
->router_id_static
.s_addr
!= 0)
7388 vty_out (vty
, " bgp router-id %s%s",
7389 inet_ntoa (bgp
->router_id_static
), VTY_NEWLINE
);
7391 /* BGP log-neighbor-changes. */
7392 if (!!bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
)
7393 != DFLT_BGP_LOG_NEIGHBOR_CHANGES
)
7394 vty_out (vty
, " %sbgp log-neighbor-changes%s",
7395 bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
) ? "" : "no ",
7398 /* BGP configuration. */
7399 if (bgp_flag_check (bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7400 vty_out (vty
, " bgp always-compare-med%s", VTY_NEWLINE
);
7402 /* BGP default ipv4-unicast. */
7403 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7404 vty_out (vty
, " no bgp default ipv4-unicast%s", VTY_NEWLINE
);
7406 /* BGP default local-preference. */
7407 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7408 vty_out (vty
, " bgp default local-preference %d%s",
7409 bgp
->default_local_pref
, VTY_NEWLINE
);
7411 /* BGP default show-hostname */
7412 if (!!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
)
7413 != DFLT_BGP_SHOW_HOSTNAME
)
7414 vty_out (vty
, " %sbgp default show-hostname%s",
7415 bgp_flag_check (bgp
, BGP_FLAG_SHOW_HOSTNAME
) ? "" : "no ",
7418 /* BGP default subgroup-pkt-queue-max. */
7419 if (bgp
->default_subgroup_pkt_queue_max
!= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7420 vty_out (vty
, " bgp default subgroup-pkt-queue-max %d%s",
7421 bgp
->default_subgroup_pkt_queue_max
, VTY_NEWLINE
);
7423 /* BGP client-to-client reflection. */
7424 if (bgp_flag_check (bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7425 vty_out (vty
, " no bgp client-to-client reflection%s", VTY_NEWLINE
);
7427 /* BGP cluster ID. */
7428 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7429 vty_out (vty
, " bgp cluster-id %s%s", inet_ntoa (bgp
->cluster_id
),
7432 /* Disable ebgp connected nexthop check */
7433 if (bgp_flag_check (bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7434 vty_out (vty
, " bgp disable-ebgp-connected-route-check%s", VTY_NEWLINE
);
7436 /* Confederation identifier*/
7437 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7438 vty_out (vty
, " bgp confederation identifier %i%s", bgp
->confed_id
,
7441 /* Confederation peer */
7442 if (bgp
->confed_peers_cnt
> 0)
7446 vty_out (vty
, " bgp confederation peers");
7448 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7449 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7451 vty_out (vty
, "%s", VTY_NEWLINE
);
7454 /* BGP enforce-first-as. */
7455 if (bgp_flag_check (bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
7456 vty_out (vty
, " bgp enforce-first-as%s", VTY_NEWLINE
);
7458 /* BGP deterministic-med. */
7459 if (!!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
)
7460 != DFLT_BGP_DETERMINISTIC_MED
)
7461 vty_out (vty
, " %sbgp deterministic-med%s",
7462 bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
) ? "" : "no ",
7465 /* BGP update-delay. */
7466 bgp_config_write_update_delay (vty
, bgp
);
7468 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
7470 vty_out (vty
, " bgp max-med on-startup %d", bgp
->v_maxmed_onstartup
);
7471 if (bgp
->maxmed_onstartup_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7472 vty_out (vty
, " %d", bgp
->maxmed_onstartup_value
);
7473 vty_out (vty
, "%s", VTY_NEWLINE
);
7475 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
)
7477 vty_out (vty
, " bgp max-med administrative");
7478 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7479 vty_out (vty
, " %d", bgp
->maxmed_admin_value
);
7480 vty_out (vty
, "%s", VTY_NEWLINE
);
7484 bgp_config_write_wpkt_quanta (vty
, bgp
);
7487 bgp_config_write_coalesce_time(vty
, bgp
);
7489 /* BGP graceful-restart. */
7490 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7491 vty_out (vty
, " bgp graceful-restart stalepath-time %d%s",
7492 bgp
->stalepath_time
, VTY_NEWLINE
);
7493 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7494 vty_out (vty
, " bgp graceful-restart restart-time %d%s",
7495 bgp
->restart_time
, VTY_NEWLINE
);
7496 if (bgp_flag_check (bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7497 vty_out (vty
, " bgp graceful-restart%s", VTY_NEWLINE
);
7499 /* BGP graceful-restart Preserve State F bit. */
7500 if (bgp_flag_check (bgp
, BGP_FLAG_GR_PRESERVE_FWD
))
7501 vty_out (vty
, " bgp graceful-restart preserve-fw-state%s", VTY_NEWLINE
);
7503 /* BGP bestpath method. */
7504 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_IGNORE
))
7505 vty_out (vty
, " bgp bestpath as-path ignore%s", VTY_NEWLINE
);
7506 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_CONFED
))
7507 vty_out (vty
, " bgp bestpath as-path confed%s", VTY_NEWLINE
);
7509 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
))
7511 if (bgp_flag_check (bgp
, BGP_FLAG_MULTIPATH_RELAX_AS_SET
))
7513 vty_out (vty
, " bgp bestpath as-path multipath-relax as-set%s", VTY_NEWLINE
);
7517 vty_out (vty
, " bgp bestpath as-path multipath-relax%s", VTY_NEWLINE
);
7521 if (bgp_flag_check (bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7522 vty_out (vty
, " bgp route-reflector allow-outbound-policy%s",
7525 if (bgp_flag_check (bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7526 vty_out (vty
, " bgp bestpath compare-routerid%s", VTY_NEWLINE
);
7527 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
)
7528 || bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7530 vty_out (vty
, " bgp bestpath med");
7531 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
))
7532 vty_out (vty
, " confed");
7533 if (bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7534 vty_out (vty
, " missing-as-worst");
7535 vty_out (vty
, "%s", VTY_NEWLINE
);
7538 /* BGP network import check. */
7539 if (!!bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
)
7540 != DFLT_BGP_IMPORT_CHECK
)
7541 vty_out (vty
, " %sbgp network import-check%s",
7542 bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
) ? "" : "no ",
7545 /* BGP flag dampening. */
7546 if (CHECK_FLAG (bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7547 BGP_CONFIG_DAMPENING
))
7548 bgp_config_write_damp (vty
);
7550 /* BGP timers configuration. */
7551 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7552 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7553 vty_out (vty
, " timers bgp %d %d%s", bgp
->default_keepalive
,
7554 bgp
->default_holdtime
, VTY_NEWLINE
);
7557 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7559 bgp_config_write_peer_global (vty
, bgp
, group
->conf
);
7562 /* Normal neighbor configuration. */
7563 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7565 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7566 bgp_config_write_peer_global (vty
, bgp
, peer
);
7569 /* listen range and limit for dynamic BGP neighbors */
7570 bgp_config_write_listen (vty
, bgp
);
7572 /* No auto-summary */
7573 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7574 vty_out (vty
, " no auto-summary%s", VTY_NEWLINE
);
7576 /* IPv4 unicast configuration. */
7577 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7579 /* IPv4 multicast configuration. */
7580 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7582 /* IPv4 VPN configuration. */
7583 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7585 /* ENCAPv4 configuration. */
7586 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7588 /* IPv6 unicast configuration. */
7589 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7591 /* IPv6 multicast configuration. */
7592 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7594 /* IPv6 VPN configuration. */
7595 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7597 /* ENCAPv6 configuration. */
7598 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7600 /* EVPN configuration. */
7601 write
+= bgp_config_write_family (vty
, bgp
, AFI_L2VPN
, SAFI_EVPN
);
7604 write
+= bgp_rfapi_cfg_write(vty
, bgp
);
7613 bgp_master_init (struct thread_master
*master
)
7617 memset (&bgp_master
, 0, sizeof (struct bgp_master
));
7620 bm
->bgp
= list_new ();
7621 bm
->listen_sockets
= list_new ();
7622 bm
->port
= BGP_PORT_DEFAULT
;
7623 bm
->master
= master
;
7624 bm
->start_time
= bgp_clock ();
7625 bm
->t_rmap_update
= NULL
;
7626 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7628 bgp_process_queue_init();
7630 /* Enable multiple instances by default. */
7631 bgp_option_set (BGP_OPT_MULTIPLE_INSTANCE
);
7633 QOBJ_REG (bm
, bgp_master
);
7637 * Initialize interface list for instance, if needed. Invoked upon
7641 bgp_if_init (struct bgp
*bgp
)
7643 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7646 vrf_iflist_create (bgp
->vrf_id
);
7650 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7651 * instance delete (non-default only) or BGP exit.
7654 bgp_if_finish (struct bgp
*bgp
)
7656 struct listnode
*ifnode
, *ifnnode
;
7657 struct interface
*ifp
;
7659 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7662 for (ALL_LIST_ELEMENTS (vrf_iflist(bgp
->vrf_id
), ifnode
, ifnnode
, ifp
))
7664 struct listnode
*c_node
, *c_nnode
;
7665 struct connected
*c
;
7667 for (ALL_LIST_ELEMENTS (ifp
->connected
, c_node
, c_nnode
, c
))
7668 bgp_connected_delete (bgp
, c
);
7672 extern void bgp_snmp_init (void);
7678 /* allocates some vital data structures used by peer commands in vty_init */
7681 bgp_zebra_init(bm
->master
);
7684 vnc_zebra_init (bm
->master
);
7687 /* BGP VTY commands installation. */
7695 bgp_route_map_init ();
7696 bgp_scan_vty_init();
7697 bgp_mplsvpn_init ();
7702 bgp_ethernetvpn_init ();
7704 /* Access list initialize. */
7705 access_list_init ();
7706 access_list_add_hook (peer_distribute_update
);
7707 access_list_delete_hook (peer_distribute_update
);
7709 /* Filter list initialize. */
7711 as_list_add_hook (peer_aslist_add
);
7712 as_list_delete_hook (peer_aslist_del
);
7714 /* Prefix list initialize.*/
7715 prefix_list_init ();
7716 prefix_list_add_hook (peer_prefix_list_update
);
7717 prefix_list_delete_hook (peer_prefix_list_update
);
7719 /* Community list initialize. */
7720 bgp_clist
= community_list_init ();
7727 bgp_terminate (void)
7731 struct listnode
*node
, *nnode
;
7732 struct listnode
*mnode
, *mnnode
;
7736 /* Close the listener sockets first as this prevents peers from attempting
7737 * to reconnect on receiving the peer unconfig message. In the presence
7738 * of a large number of peers this will ensure that no peer is left with
7739 * a dangling connection
7741 /* reverse bgp_master_init */
7743 if (bm
->listen_sockets
)
7744 list_free(bm
->listen_sockets
);
7745 bm
->listen_sockets
= NULL
;
7747 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7748 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7749 if (peer
->status
== Established
||
7750 peer
->status
== OpenSent
||
7751 peer
->status
== OpenConfirm
)
7752 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
7753 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7755 if (bm
->process_main_queue
)
7757 work_queue_free (bm
->process_main_queue
);
7758 bm
->process_main_queue
= NULL
;
7761 if (bm
->t_rmap_update
)
7762 BGP_TIMER_OFF(bm
->t_rmap_update
);