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 GN5U 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
29 #include "sockunion.h"
39 #include "workqueue.h"
47 #include "bgpd/bgpd.h"
48 #include "bgpd/bgp_table.h"
49 #include "bgpd/bgp_aspath.h"
50 #include "bgpd/bgp_route.h"
51 #include "bgpd/bgp_dump.h"
52 #include "bgpd/bgp_debug.h"
53 #include "bgpd/bgp_community.h"
54 #include "bgpd/bgp_attr.h"
55 #include "bgpd/bgp_regex.h"
56 #include "bgpd/bgp_clist.h"
57 #include "bgpd/bgp_fsm.h"
58 #include "bgpd/bgp_packet.h"
59 #include "bgpd/bgp_zebra.h"
60 #include "bgpd/bgp_open.h"
61 #include "bgpd/bgp_filter.h"
62 #include "bgpd/bgp_nexthop.h"
63 #include "bgpd/bgp_damp.h"
64 #include "bgpd/bgp_mplsvpn.h"
65 #include "bgpd/bgp_encap.h"
67 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
68 #include "bgpd/rfapi/rfapi_backend.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"
76 #include "bgpd/bgp_snmp.h"
77 #endif /* HAVE_SNMP */
78 #include "bgpd/bgp_updgrp.h"
79 #include "bgpd/bgp_bfd.h"
80 #include "bgpd/bgp_memory.h"
82 /* BGP process wide configuration. */
83 static struct bgp_master bgp_master
;
85 /* BGP process wide configuration pointer to export. */
86 struct bgp_master
*bm
;
88 /* BGP community-list. */
89 struct community_list_handler
*bgp_clist
;
91 static void bgp_if_init (struct bgp
*bgp
);
92 static void bgp_if_finish (struct bgp
*bgp
);
94 extern struct zclient
*zclient
;
97 bgp_session_reset(struct peer
*peer
)
99 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
100 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
101 peer_delete(peer
->doppelganger
);
103 BGP_EVENT_ADD (peer
, BGP_Stop
);
107 * During session reset, we may delete the doppelganger peer, which would
108 * be the next node to the current node. If the session reset was invoked
109 * during walk of peer list, we would end up accessing the freed next
110 * node. This function moves the next node along.
113 bgp_session_reset_safe(struct peer
*peer
, struct listnode
**nnode
)
118 n
= (nnode
) ? *nnode
: NULL
;
119 npeer
= (n
) ? listgetdata(n
) : NULL
;
121 if (peer
->doppelganger
&& (peer
->doppelganger
->status
!= Deleted
)
122 && !(CHECK_FLAG(peer
->doppelganger
->flags
, PEER_FLAG_CONFIG_NODE
)))
124 if (peer
->doppelganger
== npeer
)
125 /* nnode and *nnode are confirmed to be non-NULL here */
126 *nnode
= (*nnode
)->next
;
127 peer_delete(peer
->doppelganger
);
130 BGP_EVENT_ADD (peer
, BGP_Stop
);
133 /* BGP global flag manipulation. */
135 bgp_option_set (int flag
)
140 case BGP_OPT_MULTIPLE_INSTANCE
:
141 case BGP_OPT_CONFIG_CISCO
:
142 case BGP_OPT_NO_LISTEN
:
143 SET_FLAG (bm
->options
, flag
);
146 return BGP_ERR_INVALID_FLAG
;
152 bgp_option_unset (int flag
)
156 case BGP_OPT_MULTIPLE_INSTANCE
:
157 if (listcount (bm
->bgp
) > 1)
158 return BGP_ERR_MULTIPLE_INSTANCE_USED
;
161 case BGP_OPT_CONFIG_CISCO
:
162 UNSET_FLAG (bm
->options
, flag
);
165 return BGP_ERR_INVALID_FLAG
;
171 bgp_option_check (int flag
)
173 return CHECK_FLAG (bm
->options
, flag
);
176 /* BGP flag manipulation. */
178 bgp_flag_set (struct bgp
*bgp
, int flag
)
180 SET_FLAG (bgp
->flags
, flag
);
185 bgp_flag_unset (struct bgp
*bgp
, int flag
)
187 UNSET_FLAG (bgp
->flags
, flag
);
192 bgp_flag_check (struct bgp
*bgp
, int flag
)
194 return CHECK_FLAG (bgp
->flags
, flag
);
197 /* Internal function to set BGP structure configureation flag. */
199 bgp_config_set (struct bgp
*bgp
, int config
)
201 SET_FLAG (bgp
->config
, config
);
205 bgp_config_unset (struct bgp
*bgp
, int config
)
207 UNSET_FLAG (bgp
->config
, config
);
211 bgp_config_check (struct bgp
*bgp
, int config
)
213 return CHECK_FLAG (bgp
->config
, config
);
216 /* Set BGP router identifier. */
218 bgp_router_id_set (struct bgp
*bgp
, const struct in_addr
*id
)
221 struct listnode
*node
, *nnode
;
223 if (IPV4_ADDR_SAME (&bgp
->router_id
, id
))
226 IPV4_ADDR_COPY (&bgp
->router_id
, id
);
228 /* Set all peer's local identifier with this value. */
229 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
231 IPV4_ADDR_COPY (&peer
->local_id
, id
);
233 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
235 peer
->last_reset
= PEER_DOWN_RID_CHANGE
;
236 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
237 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
244 bgp_router_id_zebra_bump (vrf_id_t vrf_id
, const struct prefix
*router_id
)
246 struct listnode
*node
, *nnode
;
249 if (vrf_id
== VRF_DEFAULT
)
251 /* Router-id change for default VRF has to also update all views. */
252 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
254 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
257 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
258 if (!bgp
->router_id_static
.s_addr
)
259 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
264 bgp
= bgp_lookup_by_vrf_id (vrf_id
);
267 bgp
->router_id_zebra
= router_id
->u
.prefix4
;
269 if (!bgp
->router_id_static
.s_addr
)
270 bgp_router_id_set (bgp
, &router_id
->u
.prefix4
);
276 bgp_router_id_static_set (struct bgp
*bgp
, struct in_addr id
)
278 bgp
->router_id_static
= id
;
279 bgp_router_id_set (bgp
, id
.s_addr
? &id
: &bgp
->router_id_zebra
);
283 /* BGP's cluster-id control. */
285 bgp_cluster_id_set (struct bgp
*bgp
, struct in_addr
*cluster_id
)
288 struct listnode
*node
, *nnode
;
290 if (bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
)
291 && IPV4_ADDR_SAME (&bgp
->cluster_id
, cluster_id
))
294 IPV4_ADDR_COPY (&bgp
->cluster_id
, cluster_id
);
295 bgp_config_set (bgp
, BGP_CONFIG_CLUSTER_ID
);
297 /* Clear all IBGP peer. */
298 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
300 if (peer
->sort
!= BGP_PEER_IBGP
)
303 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
305 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
306 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
307 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
314 bgp_cluster_id_unset (struct bgp
*bgp
)
317 struct listnode
*node
, *nnode
;
319 if (! bgp_config_check (bgp
, BGP_CONFIG_CLUSTER_ID
))
322 bgp
->cluster_id
.s_addr
= 0;
323 bgp_config_unset (bgp
, BGP_CONFIG_CLUSTER_ID
);
325 /* Clear all IBGP peer. */
326 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
328 if (peer
->sort
!= BGP_PEER_IBGP
)
331 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
333 peer
->last_reset
= PEER_DOWN_CLID_CHANGE
;
334 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
335 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
341 /* time_t value that is monotonicly increasing
342 * and uneffected by adjustments to system clock
344 time_t bgp_clock (void)
348 quagga_gettime(QUAGGA_CLK_MONOTONIC
, &tv
);
352 /* BGP timer configuration. */
354 bgp_timers_set (struct bgp
*bgp
, u_int32_t keepalive
, u_int32_t holdtime
)
356 bgp
->default_keepalive
= (keepalive
< holdtime
/ 3
357 ? keepalive
: holdtime
/ 3);
358 bgp
->default_holdtime
= holdtime
;
364 bgp_timers_unset (struct bgp
*bgp
)
366 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
367 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
372 /* BGP confederation configuration. */
374 bgp_confederation_id_set (struct bgp
*bgp
, as_t as
)
377 struct listnode
*node
, *nnode
;
381 return BGP_ERR_INVALID_AS
;
383 /* Remember - were we doing confederation before? */
384 already_confed
= bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
);
386 bgp_config_set (bgp
, BGP_CONFIG_CONFEDERATION
);
388 /* If we were doing confederation already, this is just an external
389 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
390 were not doing confederation before, reset all EBGP sessions. */
391 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
393 /* We're looking for peers who's AS is not local or part of our
397 if (peer_sort (peer
) == BGP_PEER_EBGP
)
400 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
402 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
403 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
404 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
407 bgp_session_reset_safe(peer
, &nnode
);
412 /* Not doign confederation before, so reset every non-local
414 if (peer_sort (peer
) != BGP_PEER_IBGP
)
416 /* Reset the local_as to be our EBGP one */
417 if (peer_sort (peer
) == BGP_PEER_EBGP
)
419 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
421 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
422 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
423 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
426 bgp_session_reset_safe(peer
, &nnode
);
434 bgp_confederation_id_unset (struct bgp
*bgp
)
437 struct listnode
*node
, *nnode
;
440 bgp_config_unset (bgp
, BGP_CONFIG_CONFEDERATION
);
442 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
444 /* We're looking for peers who's AS is not local */
445 if (peer_sort (peer
) != BGP_PEER_IBGP
)
447 peer
->local_as
= bgp
->as
;
448 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
450 peer
->last_reset
= PEER_DOWN_CONFED_ID_CHANGE
;
451 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
452 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
456 bgp_session_reset_safe(peer
, &nnode
);
462 /* Is an AS part of the confed or not? */
464 bgp_confederation_peers_check (struct bgp
*bgp
, as_t as
)
471 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
472 if (bgp
->confed_peers
[i
] == as
)
478 /* Add an AS to the confederation set. */
480 bgp_confederation_peers_add (struct bgp
*bgp
, as_t as
)
483 struct listnode
*node
, *nnode
;
486 return BGP_ERR_INVALID_BGP
;
489 return BGP_ERR_INVALID_AS
;
491 if (bgp_confederation_peers_check (bgp
, as
))
494 if (bgp
->confed_peers
)
495 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
497 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
499 bgp
->confed_peers
= XMALLOC (MTYPE_BGP_CONFED_LIST
,
500 (bgp
->confed_peers_cnt
+ 1) * sizeof (as_t
));
502 bgp
->confed_peers
[bgp
->confed_peers_cnt
] = as
;
503 bgp
->confed_peers_cnt
++;
505 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
507 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
511 peer
->local_as
= bgp
->as
;
512 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
514 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
515 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
516 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
519 bgp_session_reset_safe(peer
, &nnode
);
526 /* Delete an AS from the confederation set. */
528 bgp_confederation_peers_remove (struct bgp
*bgp
, as_t as
)
533 struct listnode
*node
, *nnode
;
538 if (! bgp_confederation_peers_check (bgp
, as
))
541 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
542 if (bgp
->confed_peers
[i
] == as
)
543 for(j
= i
+ 1; j
< bgp
->confed_peers_cnt
; j
++)
544 bgp
->confed_peers
[j
- 1] = bgp
->confed_peers
[j
];
546 bgp
->confed_peers_cnt
--;
548 if (bgp
->confed_peers_cnt
== 0)
550 if (bgp
->confed_peers
)
551 XFREE (MTYPE_BGP_CONFED_LIST
, bgp
->confed_peers
);
552 bgp
->confed_peers
= NULL
;
555 bgp
->confed_peers
= XREALLOC (MTYPE_BGP_CONFED_LIST
,
557 bgp
->confed_peers_cnt
* sizeof (as_t
));
559 /* Now reset any peer who's remote AS has just been removed from the
561 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
))
563 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
567 peer
->local_as
= bgp
->confed_id
;
568 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
570 peer
->last_reset
= PEER_DOWN_CONFED_PEER_CHANGE
;
571 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
572 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
575 bgp_session_reset_safe(peer
, &nnode
);
583 /* Local preference configuration. */
585 bgp_default_local_preference_set (struct bgp
*bgp
, u_int32_t local_pref
)
590 bgp
->default_local_pref
= local_pref
;
596 bgp_default_local_preference_unset (struct bgp
*bgp
)
601 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
606 /* Local preference configuration. */
608 bgp_default_subgroup_pkt_queue_max_set (struct bgp
*bgp
, u_int32_t queue_size
)
613 bgp
->default_subgroup_pkt_queue_max
= queue_size
;
619 bgp_default_subgroup_pkt_queue_max_unset (struct bgp
*bgp
)
623 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
628 /* Listen limit configuration. */
630 bgp_listen_limit_set (struct bgp
*bgp
, int listen_limit
)
635 bgp
->dynamic_neighbors_limit
= listen_limit
;
641 bgp_listen_limit_unset (struct bgp
*bgp
)
646 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
652 peer_af_create (struct peer
*peer
, afi_t afi
, safi_t safi
)
660 afid
= afindex(afi
, safi
);
661 if (afid
>= BGP_AF_MAX
)
664 assert(peer
->peer_af_array
[afid
] == NULL
);
666 /* Allocate new peer af */
667 af
= XCALLOC (MTYPE_BGP_PEER_AF
, sizeof (struct peer_af
));
671 zlog_err("Could not create af structure for peer %s", peer
->host
);
675 peer
->peer_af_array
[afid
] = af
;
685 peer_af_find (struct peer
*peer
, afi_t afi
, safi_t safi
)
692 afid
= afindex(afi
, safi
);
693 if (afid
>= BGP_AF_MAX
)
696 return peer
->peer_af_array
[afid
];
700 peer_af_delete (struct peer
*peer
, afi_t afi
, safi_t safi
)
708 afid
= afindex(afi
, safi
);
709 if (afid
>= BGP_AF_MAX
)
712 af
= peer
->peer_af_array
[afid
];
716 bgp_stop_announce_route_timer (af
);
720 if (BGP_DEBUG (update_groups
, UPDATE_GROUPS
))
721 zlog_debug ("u%" PRIu64
":s%" PRIu64
" remove peer %s",
722 af
->subgroup
->update_group
->id
, af
->subgroup
->id
, peer
->host
);
725 update_subgroup_remove_peer (af
->subgroup
, af
);
727 peer
->peer_af_array
[afid
] = NULL
;
728 XFREE(MTYPE_BGP_PEER_AF
, af
);
732 /* Peer comparison function for sorting. */
734 peer_cmp (struct peer
*p1
, struct peer
*p2
)
736 if (p1
->group
&& !p2
->group
)
739 if (!p1
->group
&& p2
->group
)
742 if (p1
->group
== p2
->group
)
744 if (p1
->conf_if
&& !p2
->conf_if
)
747 if (!p1
->conf_if
&& p2
->conf_if
)
750 if (p1
->conf_if
&& p2
->conf_if
)
751 return if_cmp_name_func (p1
->conf_if
, p2
->conf_if
);
754 return strcmp (p1
->group
->name
, p2
->group
->name
);
756 return sockunion_cmp (&p1
->su
, &p2
->su
);
760 peer_hash_key_make(void *p
)
762 struct peer
*peer
= p
;
763 return sockunion_hash(&peer
->su
);
767 peer_hash_cmp (const void *p1
, const void *p2
)
769 const struct peer
*peer1
= p1
;
770 const struct peer
*peer2
= p2
;
771 return (sockunion_same (&peer1
->su
, &peer2
->su
) &&
772 CHECK_FLAG (peer1
->flags
, PEER_FLAG_CONFIG_NODE
) == CHECK_FLAG (peer2
->flags
, PEER_FLAG_CONFIG_NODE
));
776 peer_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
778 return CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
);
781 /* Return true if flag is set for the peer but not the peer-group */
783 peergroup_af_flag_check (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
785 struct peer
*g_peer
= NULL
;
787 if (peer_af_flag_check (peer
, afi
, safi
, flag
))
789 if (peer_group_active (peer
))
791 g_peer
= peer
->group
->conf
;
793 /* If this flag is not set for the peer's peer-group then return true */
794 if (!peer_af_flag_check (g_peer
, afi
, safi
, flag
))
800 /* peer is not in a peer-group but the flag is set to return true */
810 /* Reset all address family specific configuration. */
812 peer_af_flag_reset (struct peer
*peer
, afi_t afi
, safi_t safi
)
815 struct bgp_filter
*filter
;
816 char orf_name
[BUFSIZ
];
818 filter
= &peer
->filter
[afi
][safi
];
820 /* Clear neighbor filter and route-map */
821 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
823 if (filter
->dlist
[i
].name
)
825 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
826 filter
->dlist
[i
].name
= NULL
;
828 if (filter
->plist
[i
].name
)
830 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
831 filter
->plist
[i
].name
= NULL
;
833 if (filter
->aslist
[i
].name
)
835 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
836 filter
->aslist
[i
].name
= NULL
;
839 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
841 if (filter
->map
[i
].name
)
843 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
844 filter
->map
[i
].name
= NULL
;
848 /* Clear unsuppress map. */
849 if (filter
->usmap
.name
)
850 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
851 filter
->usmap
.name
= NULL
;
852 filter
->usmap
.map
= NULL
;
854 /* Clear neighbor's all address family flags. */
855 peer
->af_flags
[afi
][safi
] = 0;
857 /* Clear neighbor's all address family sflags. */
858 peer
->af_sflags
[afi
][safi
] = 0;
860 /* Clear neighbor's all address family capabilities. */
861 peer
->af_cap
[afi
][safi
] = 0;
864 peer
->orf_plist
[afi
][safi
] = NULL
;
865 sprintf (orf_name
, "%s.%d.%d", peer
->host
, afi
, safi
);
866 prefix_bgp_orf_remove_all (afi
, orf_name
);
868 /* Set default neighbor send-community. */
869 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
871 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
872 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
875 /* Clear neighbor default_originate_rmap */
876 if (peer
->default_rmap
[afi
][safi
].name
)
877 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
878 peer
->default_rmap
[afi
][safi
].name
= NULL
;
879 peer
->default_rmap
[afi
][safi
].map
= NULL
;
881 /* Clear neighbor maximum-prefix */
882 peer
->pmax
[afi
][safi
] = 0;
883 peer
->pmax_threshold
[afi
][safi
] = MAXIMUM_PREFIX_THRESHOLD_DEFAULT
;
886 /* peer global config reset */
888 peer_global_config_reset (struct peer
*peer
)
893 peer
->change_local_as
= 0;
894 peer
->ttl
= (peer_sort (peer
) == BGP_PEER_IBGP
? MAXTTL
: 1);
895 if (peer
->update_source
)
897 sockunion_free (peer
->update_source
);
898 peer
->update_source
= NULL
;
902 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
903 peer
->update_if
= NULL
;
906 if (peer_sort (peer
) == BGP_PEER_IBGP
)
907 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
909 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
911 /* This is a per-peer specific flag and so we must preserve it */
912 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
917 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
923 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
925 /* Reset some other configs back to defaults. */
926 peer
->v_start
= BGP_INIT_START_TIMER
;
927 peer
->password
= NULL
;
928 peer
->local_id
= peer
->bgp
->router_id
;
929 peer
->v_holdtime
= peer
->bgp
->default_holdtime
;
930 peer
->v_keepalive
= peer
->bgp
->default_keepalive
;
932 bfd_info_free(&(peer
->bfd_info
));
934 /* Set back the CONFIG_NODE flag. */
935 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
938 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
939 static bgp_peer_sort_t
940 peer_calc_sort (struct peer
*peer
)
947 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
949 if (peer
->as_type
== AS_INTERNAL
)
950 return BGP_PEER_IBGP
;
952 else if (peer
->as_type
== AS_EXTERNAL
)
953 return BGP_PEER_EBGP
;
955 else if (peer
->as_type
== AS_SPECIFIED
&& peer
->as
)
956 return (bgp
->as
== peer
->as
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
961 peer1
= listnode_head (peer
->group
->peer
);
966 return BGP_PEER_INTERNAL
;
970 if (bgp
&& CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
972 if (peer
->local_as
== 0)
973 return BGP_PEER_INTERNAL
;
975 if (peer
->local_as
== peer
->as
)
977 if (bgp
->as
== bgp
->confed_id
)
979 if (peer
->local_as
== bgp
->as
)
980 return BGP_PEER_IBGP
;
982 return BGP_PEER_EBGP
;
986 if (peer
->local_as
== bgp
->confed_id
)
987 return BGP_PEER_EBGP
;
989 return BGP_PEER_IBGP
;
993 if (bgp_confederation_peers_check (bgp
, peer
->as
))
994 return BGP_PEER_CONFED
;
996 return BGP_PEER_EBGP
;
1000 if (peer
->as_type
!= AS_SPECIFIED
)
1001 return (peer
->as_type
== AS_INTERNAL
? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1003 return (peer
->local_as
== 0
1004 ? BGP_PEER_INTERNAL
: peer
->local_as
== peer
->as
1005 ? BGP_PEER_IBGP
: BGP_PEER_EBGP
);
1009 /* Calculate and cache the peer "sort" */
1011 peer_sort (struct peer
*peer
)
1013 peer
->sort
= peer_calc_sort (peer
);
1018 peer_free (struct peer
*peer
)
1020 assert (peer
->status
== Deleted
);
1022 bgp_unlock(peer
->bgp
);
1024 /* this /ought/ to have been done already through bgp_stop earlier,
1025 * but just to be sure..
1027 bgp_timer_set (peer
);
1028 BGP_READ_OFF (peer
->t_read
);
1029 BGP_WRITE_OFF (peer
->t_write
);
1030 BGP_EVENT_FLUSH (peer
);
1032 /* Free connected nexthop, if present */
1033 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
) &&
1034 !peer_dynamic_neighbor (peer
))
1035 bgp_delete_connected_nexthop (family2afi(peer
->su
.sa
.sa_family
), peer
);
1039 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
1043 /* Free allocated host character. */
1046 XFREE (MTYPE_BGP_PEER_HOST
, peer
->host
);
1052 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
1053 peer
->ifname
= NULL
;
1056 /* Update source configuration. */
1057 if (peer
->update_source
)
1059 sockunion_free (peer
->update_source
);
1060 peer
->update_source
= NULL
;
1063 if (peer
->update_if
)
1065 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
1066 peer
->update_if
= NULL
;
1069 if (peer
->notify
.data
)
1070 XFREE(MTYPE_TMP
, peer
->notify
.data
);
1071 memset (&peer
->notify
, 0, sizeof (struct bgp_notify
));
1073 if (peer
->clear_node_queue
)
1075 work_queue_free(peer
->clear_node_queue
);
1076 peer
->clear_node_queue
= NULL
;
1079 bgp_sync_delete (peer
);
1083 XFREE (MTYPE_PEER_CONF_IF
, peer
->conf_if
);
1084 peer
->conf_if
= NULL
;
1087 bfd_info_free(&(peer
->bfd_info
));
1089 memset (peer
, 0, sizeof (struct peer
));
1091 XFREE (MTYPE_BGP_PEER
, peer
);
1094 /* increase reference count on a struct peer */
1096 peer_lock_with_caller (const char *name
, struct peer
*peer
)
1098 assert (peer
&& (peer
->lock
>= 0));
1101 zlog_debug("%s peer_lock %p %d", name
, peer
, peer
->lock
);
1109 /* decrease reference count on a struct peer
1110 * struct peer is freed and NULL returned if last reference
1113 peer_unlock_with_caller (const char *name
, struct peer
*peer
)
1115 assert (peer
&& (peer
->lock
> 0));
1118 zlog_debug("%s peer_unlock %p %d", name
, peer
, peer
->lock
);
1123 if (peer
->lock
== 0)
1132 /* Allocate new peer object, implicitely locked. */
1134 peer_new (struct bgp
*bgp
)
1141 /* bgp argument is absolutely required */
1146 /* Allocate new peer. */
1147 peer
= XCALLOC (MTYPE_BGP_PEER
, sizeof (struct peer
));
1149 /* Set default value. */
1151 peer
->v_start
= BGP_INIT_START_TIMER
;
1152 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
1153 peer
->status
= Idle
;
1154 peer
->ostatus
= Idle
;
1155 peer
->cur_event
= peer
->last_event
= peer
->last_major_event
= 0;
1157 peer
= peer_lock (peer
); /* initial reference */
1159 peer
->password
= NULL
;
1161 /* Set default flags. */
1162 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1163 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1165 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO
))
1167 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
);
1168 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
);
1170 peer
->orf_plist
[afi
][safi
] = NULL
;
1172 SET_FLAG (peer
->sflags
, PEER_STATUS_CAPABILITY_OPEN
);
1174 /* Create buffers. */
1175 peer
->ibuf
= stream_new (BGP_MAX_PACKET_SIZE
);
1176 peer
->obuf
= stream_fifo_new ();
1178 /* We use a larger buffer for peer->work in the event that:
1179 * - We RX a BGP_UPDATE where the attributes alone are just
1180 * under BGP_MAX_PACKET_SIZE
1181 * - The user configures an outbound route-map that does many as-path
1182 * prepends or adds many communities. At most they can have CMD_ARGC_MAX
1183 * args in a route-map so there is a finite limit on how large they can
1184 * make the attributes.
1186 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid bounds
1187 * checking for every single attribute as we construct an UPDATE.
1189 peer
->work
= stream_new (BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
1190 peer
->scratch
= stream_new (BGP_MAX_PACKET_SIZE
);
1193 bgp_sync_init (peer
);
1195 /* Get service port number. */
1196 sp
= getservbyname ("bgp", "tcp");
1197 peer
->port
= (sp
== NULL
) ? BGP_PORT_DEFAULT
: ntohs (sp
->s_port
);
1203 * This function is invoked when a duplicate peer structure associated with
1204 * a neighbor is being deleted. If this about-to-be-deleted structure is
1205 * the one with all the config, then we have to copy over the info.
1208 peer_xfer_config (struct peer
*peer_dst
, struct peer
*peer_src
)
1210 struct peer_af
*paf
;
1218 /* The following function is used by both peer group config copy to
1219 * individual peer and when we transfer config
1221 if (peer_src
->change_local_as
)
1222 peer_dst
->change_local_as
= peer_src
->change_local_as
;
1224 /* peer flags apply */
1225 peer_dst
->flags
= peer_src
->flags
;
1226 peer_dst
->cap
= peer_src
->cap
;
1227 peer_dst
->config
= peer_src
->config
;
1229 peer_dst
->local_as
= peer_src
->local_as
;
1230 peer_dst
->ifindex
= peer_src
->ifindex
;
1231 peer_dst
->port
= peer_src
->port
;
1232 peer_sort(peer_dst
);
1233 peer_dst
->rmap_type
= peer_src
->rmap_type
;
1236 peer_dst
->holdtime
= peer_src
->holdtime
;
1237 peer_dst
->keepalive
= peer_src
->keepalive
;
1238 peer_dst
->connect
= peer_src
->connect
;
1239 peer_dst
->v_holdtime
= peer_src
->v_holdtime
;
1240 peer_dst
->v_keepalive
= peer_src
->v_keepalive
;
1241 peer_dst
->routeadv
= peer_src
->routeadv
;
1242 peer_dst
->v_routeadv
= peer_src
->v_routeadv
;
1244 /* password apply */
1245 if (peer_src
->password
&& !peer_dst
->password
)
1246 peer_dst
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, peer_src
->password
);
1248 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1249 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1251 peer_dst
->afc
[afi
][safi
] = peer_src
->afc
[afi
][safi
];
1252 peer_dst
->af_flags
[afi
][safi
] = peer_src
->af_flags
[afi
][safi
];
1253 peer_dst
->allowas_in
[afi
][safi
] = peer_src
->allowas_in
[afi
][safi
];
1254 peer_dst
->weight
[afi
][safi
] = peer_src
->weight
[afi
][safi
];
1257 for (afidx
= BGP_AF_START
; afidx
< BGP_AF_MAX
; afidx
++)
1259 paf
= peer_src
->peer_af_array
[afidx
];
1261 peer_af_create(peer_dst
, paf
->afi
, paf
->safi
);
1264 /* update-source apply */
1265 if (peer_src
->update_source
)
1267 if (peer_dst
->update_source
)
1268 sockunion_free (peer_dst
->update_source
);
1269 if (peer_dst
->update_if
)
1271 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1272 peer_dst
->update_if
= NULL
;
1274 peer_dst
->update_source
= sockunion_dup (peer_src
->update_source
);
1276 else if (peer_src
->update_if
)
1278 if (peer_dst
->update_if
)
1279 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer_dst
->update_if
);
1280 if (peer_dst
->update_source
)
1282 sockunion_free (peer_dst
->update_source
);
1283 peer_dst
->update_source
= NULL
;
1285 peer_dst
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, peer_src
->update_if
);
1288 if (peer_src
->ifname
)
1290 if (peer_dst
->ifname
)
1291 XFREE(MTYPE_BGP_PEER_IFNAME
, peer_dst
->ifname
);
1293 peer_dst
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, peer_src
->ifname
);
1298 bgp_peer_conf_if_to_su_update_v4 (struct peer
*peer
, struct interface
*ifp
)
1300 struct connected
*ifc
;
1303 struct listnode
*node
;
1305 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1306 * IPv4 address of the other end.
1308 for (ALL_LIST_ELEMENTS_RO(ifp
->connected
, node
, ifc
))
1310 if (ifc
->address
&& (ifc
->address
->family
== AF_INET
))
1312 PREFIX_COPY_IPV4(&p
, CONNECTED_PREFIX(ifc
));
1313 if (p
.prefixlen
== 30)
1315 peer
->su
.sa
.sa_family
= AF_INET
;
1316 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1318 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1319 else if (addr
% 4 == 2)
1320 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1321 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1322 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1323 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1326 else if (p
.prefixlen
== 31)
1328 peer
->su
.sa
.sa_family
= AF_INET
;
1329 addr
= ntohl(p
.u
.prefix4
.s_addr
);
1331 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
+1);
1333 peer
->su
.sin
.sin_addr
.s_addr
= htonl(addr
-1);
1334 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1335 peer
->su
.sin
.sin_len
= sizeof(struct sockaddr_in
);
1336 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1340 if (bgp_debug_neighbor_events(peer
))
1341 zlog_debug("%s: IPv4 interface address is not /30 or /31, v4 session not started",
1350 bgp_peer_conf_if_to_su_update_v6 (struct peer
*peer
, struct interface
*ifp
)
1352 struct nbr_connected
*ifc_nbr
;
1354 /* Have we learnt the peer's IPv6 link-local address? */
1355 if (ifp
->nbr_connected
&&
1356 (ifc_nbr
= listnode_head(ifp
->nbr_connected
)))
1358 peer
->su
.sa
.sa_family
= AF_INET6
;
1359 memcpy(&peer
->su
.sin6
.sin6_addr
, &ifc_nbr
->address
->u
.prefix
,
1360 sizeof (struct in6_addr
));
1362 peer
->su
.sin6
.sin6_len
= sizeof (struct sockaddr_in6
);
1364 peer
->su
.sin6
.sin6_scope_id
= ifp
->ifindex
;
1372 * Set or reset the peer address socketunion structure based on the
1373 * learnt/derived peer address. If the address has changed, update the
1374 * password on the listen socket, if needed.
1377 bgp_peer_conf_if_to_su_update (struct peer
*peer
)
1379 struct interface
*ifp
;
1381 int peer_addr_updated
= 0;
1386 prev_family
= peer
->su
.sa
.sa_family
;
1387 if ((ifp
= if_lookup_by_name_vrf (peer
->conf_if
, peer
->bgp
->vrf_id
)))
1390 /* If BGP unnumbered is not "v6only", we first see if we can derive the
1391 * peer's IPv4 address.
1393 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
1394 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v4 (peer
, ifp
);
1396 /* If "v6only" or we can't derive peer's IPv4 address, see if we've
1397 * learnt the peer's IPv6 link-local address. This is from the source
1398 * IPv6 address in router advertisement.
1400 if (!peer_addr_updated
)
1401 peer_addr_updated
= bgp_peer_conf_if_to_su_update_v6 (peer
, ifp
);
1403 /* If we could derive the peer address, we may need to install the password
1404 * configured for the peer, if any, on the listen socket. Otherwise, mark
1405 * that peer's address is not available and uninstall the password, if
1408 if (peer_addr_updated
)
1410 if (peer
->password
&& prev_family
== AF_UNSPEC
)
1415 if (peer
->password
&& prev_family
!= AF_UNSPEC
)
1416 bgp_md5_unset (peer
);
1417 peer
->su
.sa
.sa_family
= AF_UNSPEC
;
1418 memset(&peer
->su
.sin6
.sin6_addr
, 0, sizeof (struct in6_addr
));
1421 /* Since our su changed we need to del/add peer to the peerhash */
1422 hash_release(peer
->bgp
->peerhash
, peer
);
1423 hash_get(peer
->bgp
->peerhash
, peer
, hash_alloc_intern
);
1426 /* Force a bestpath recalculation for all prefixes. This is used
1427 * when 'bgp bestpath' commands are entered.
1430 bgp_recalculate_all_bestpaths (struct bgp
*bgp
)
1434 struct bgp_node
*rn
;
1436 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1438 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
1440 for (rn
= bgp_table_top (bgp
->rib
[afi
][safi
]); rn
; rn
= bgp_route_next (rn
))
1442 if (rn
->info
!= NULL
)
1444 bgp_process (bgp
, rn
, afi
, safi
);
1451 /* Create new BGP peer. */
1453 peer_create (union sockunion
*su
, const char *conf_if
, struct bgp
*bgp
,
1454 as_t local_as
, as_t remote_as
, int as_type
, afi_t afi
, safi_t safi
, struct peer_group
*group
)
1458 char buf
[SU_ADDRSTRLEN
];
1460 peer
= peer_new (bgp
);
1463 peer
->conf_if
= XSTRDUP (MTYPE_PEER_CONF_IF
, conf_if
);
1464 bgp_peer_conf_if_to_su_update(peer
);
1466 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1467 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, conf_if
);
1472 sockunion2str (su
, buf
, SU_ADDRSTRLEN
);
1474 XFREE(MTYPE_BGP_PEER_HOST
, peer
->host
);
1475 peer
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, buf
);
1477 peer
->local_as
= local_as
;
1478 peer
->as
= remote_as
;
1479 peer
->as_type
= as_type
;
1480 peer
->local_id
= bgp
->router_id
;
1481 peer
->v_holdtime
= bgp
->default_holdtime
;
1482 peer
->v_keepalive
= bgp
->default_keepalive
;
1483 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1484 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1486 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1488 peer
= peer_lock (peer
); /* bgp peer list reference */
1489 peer
->group
= group
;
1490 listnode_add_sort (bgp
->peer
, peer
);
1491 hash_get(bgp
->peerhash
, peer
, hash_alloc_intern
);
1493 active
= peer_active (peer
);
1495 /* Last read and reset time set */
1496 peer
->readtime
= peer
->resettime
= bgp_clock ();
1498 /* Default TTL set. */
1499 peer
->ttl
= (peer
->sort
== BGP_PEER_IBGP
) ? MAXTTL
: 1;
1501 SET_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
);
1505 peer
->afc
[afi
][safi
] = 1;
1506 peer_af_create(peer
, afi
, safi
);
1509 /* Set up peer's events and timers. */
1510 if (! active
&& peer_active (peer
))
1511 bgp_timer_set (peer
);
1516 /* Make accept BGP peer. This function is only called from the test code */
1518 peer_create_accept (struct bgp
*bgp
)
1522 peer
= peer_new (bgp
);
1524 peer
= peer_lock (peer
); /* bgp peer list reference */
1525 listnode_add_sort (bgp
->peer
, peer
);
1530 /* Change peer's AS number. */
1532 peer_as_change (struct peer
*peer
, as_t as
, int as_specified
)
1534 bgp_peer_sort_t type
;
1538 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1540 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
1542 peer
->last_reset
= PEER_DOWN_REMOTE_AS_CHANGE
;
1543 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1544 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1547 bgp_session_reset(peer
);
1549 type
= peer_sort (peer
);
1551 peer
->as_type
= as_specified
;
1553 if (bgp_config_check (peer
->bgp
, BGP_CONFIG_CONFEDERATION
)
1554 && ! bgp_confederation_peers_check (peer
->bgp
, as
)
1555 && peer
->bgp
->as
!= as
)
1556 peer
->local_as
= peer
->bgp
->confed_id
;
1558 peer
->local_as
= peer
->bgp
->as
;
1560 /* Advertisement-interval reset */
1563 conf
= peer
->group
->conf
;
1565 if (conf
&& CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
1567 peer
->v_routeadv
= conf
->routeadv
;
1569 /* Only go back to the default advertisement-interval if the user had not
1570 * already configured it */
1571 else if (!CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
))
1573 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1574 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
1576 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
1579 if (peer_sort (peer
) == BGP_PEER_IBGP
)
1581 else if (type
== BGP_PEER_IBGP
)
1584 /* reflector-client reset */
1585 if (peer_sort (peer
) != BGP_PEER_IBGP
)
1587 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_UNICAST
],
1588 PEER_FLAG_REFLECTOR_CLIENT
);
1589 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MULTICAST
],
1590 PEER_FLAG_REFLECTOR_CLIENT
);
1591 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_MPLS_VPN
],
1592 PEER_FLAG_REFLECTOR_CLIENT
);
1593 UNSET_FLAG (peer
->af_flags
[AFI_IP
][SAFI_ENCAP
],
1594 PEER_FLAG_REFLECTOR_CLIENT
);
1595 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_UNICAST
],
1596 PEER_FLAG_REFLECTOR_CLIENT
);
1597 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MULTICAST
],
1598 PEER_FLAG_REFLECTOR_CLIENT
);
1599 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_MPLS_VPN
],
1600 PEER_FLAG_REFLECTOR_CLIENT
);
1601 UNSET_FLAG (peer
->af_flags
[AFI_IP6
][SAFI_ENCAP
],
1602 PEER_FLAG_REFLECTOR_CLIENT
);
1605 /* local-as reset */
1606 if (peer_sort (peer
) != BGP_PEER_EBGP
)
1608 peer
->change_local_as
= 0;
1609 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
1610 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
1614 /* If peer does not exist, create new one. If peer already exists,
1615 set AS number to the peer. */
1617 peer_remote_as (struct bgp
*bgp
, union sockunion
*su
, const char *conf_if
,
1618 as_t
*as
, int as_type
, afi_t afi
, safi_t safi
)
1624 peer
= peer_lookup_by_conf_if (bgp
, conf_if
);
1626 peer
= peer_lookup (bgp
, su
);
1630 /* Not allowed for a dynamic peer. */
1631 if (peer_dynamic_neighbor (peer
))
1634 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER
;
1637 /* When this peer is a member of peer-group. */
1640 if (peer
->group
->conf
->as
)
1642 /* Return peer group's AS number. */
1643 *as
= peer
->group
->conf
->as
;
1644 return BGP_ERR_PEER_GROUP_MEMBER
;
1646 if (peer_sort (peer
->group
->conf
) == BGP_PEER_IBGP
)
1648 if ((as_type
!= AS_INTERNAL
) && (bgp
->as
!= *as
))
1651 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1656 if ((as_type
!= AS_EXTERNAL
) && (bgp
->as
== *as
))
1659 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
1664 /* Existing peer's AS number change. */
1665 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
1666 (peer
->as_type
!= as_type
))
1667 peer_as_change (peer
, *as
, as_type
);
1672 return BGP_ERR_NO_INTERFACE_CONFIG
;
1674 /* If the peer is not part of our confederation, and its not an
1675 iBGP peer then spoof the source AS */
1676 if (bgp_config_check (bgp
, BGP_CONFIG_CONFEDERATION
)
1677 && ! bgp_confederation_peers_check (bgp
, *as
)
1679 local_as
= bgp
->confed_id
;
1683 /* If this is IPv4 unicast configuration and "no bgp default
1684 ipv4-unicast" is specified. */
1686 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
)
1687 && afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
1688 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, 0, 0, NULL
);
1690 peer_create (su
, conf_if
, bgp
, local_as
, *as
, as_type
, afi
, safi
, NULL
);
1697 non_peergroup_activate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1701 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1703 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1707 /* Nothing to do if we've already activated this peer */
1708 if (peer
->afc
[afi
][safi
])
1711 if (peer_af_create(peer
, afi
, safi
) == NULL
)
1714 active
= peer_active (peer
);
1715 peer
->afc
[afi
][safi
] = 1;
1717 if (!active
&& peer_active (peer
))
1719 bgp_timer_set (peer
);
1723 if (peer
->status
== Established
)
1725 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1727 peer
->afc_adv
[afi
][safi
] = 1;
1728 bgp_capability_send (peer
, afi
, safi
,
1730 CAPABILITY_ACTION_SET
);
1731 if (peer
->afc_recv
[afi
][safi
])
1733 peer
->afc_nego
[afi
][safi
] = 1;
1734 bgp_announce_route (peer
, afi
, safi
);
1739 peer
->last_reset
= PEER_DOWN_AF_ACTIVATE
;
1740 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1741 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1749 /* Activate the peer or peer group for specified AFI and SAFI. */
1751 peer_activate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1754 struct peer_group
*group
;
1755 struct listnode
*node
, *nnode
;
1756 struct peer
*tmp_peer
;
1758 /* Nothing to do if we've already activated this peer */
1759 if (peer
->afc
[afi
][safi
])
1762 /* This is a peer-group so activate all of the members of the
1763 * peer-group as well */
1764 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1766 peer
->afc
[afi
][safi
] = 1;
1767 group
= peer
->group
;
1769 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1771 ret
|= non_peergroup_activate_af (tmp_peer
, afi
, safi
);
1776 ret
|= non_peergroup_activate_af (peer
, afi
, safi
);
1783 non_peergroup_deactivate_af (struct peer
*peer
, afi_t afi
, safi_t safi
)
1785 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1787 zlog_err("%s was called for peer-group %s", __func__
, peer
->host
);
1791 /* Nothing to do if we've already deactivated this peer */
1792 if (! peer
->afc
[afi
][safi
])
1795 /* De-activate the address family configuration. */
1796 peer
->afc
[afi
][safi
] = 0;
1798 if (peer_af_delete(peer
, afi
, safi
) != 0)
1800 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1804 if (peer
->status
== Established
)
1806 if (CHECK_FLAG (peer
->cap
, PEER_CAP_DYNAMIC_RCV
))
1808 peer
->afc_adv
[afi
][safi
] = 0;
1809 peer
->afc_nego
[afi
][safi
] = 0;
1811 if (peer_active_nego (peer
))
1813 bgp_capability_send (peer
, afi
, safi
,
1815 CAPABILITY_ACTION_UNSET
);
1816 bgp_clear_route (peer
, afi
, safi
);
1817 peer
->pcount
[afi
][safi
] = 0;
1821 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1822 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1823 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1828 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1829 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
1830 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
1838 peer_deactivate (struct peer
*peer
, afi_t afi
, safi_t safi
)
1841 struct peer_group
*group
;
1842 struct peer
*tmp_peer
;
1843 struct listnode
*node
, *nnode
;
1845 /* Nothing to do if we've already de-activated this peer */
1846 if (! peer
->afc
[afi
][safi
])
1849 /* This is a peer-group so de-activate all of the members of the
1850 * peer-group as well */
1851 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1853 peer
->afc
[afi
][safi
] = 0;
1854 group
= peer
->group
;
1856 if (peer_af_delete(peer
, afi
, safi
) != 0)
1858 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
1861 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
1863 ret
|= non_peergroup_deactivate_af (tmp_peer
, afi
, safi
);
1868 ret
|= non_peergroup_deactivate_af (peer
, afi
, safi
);
1875 peer_afc_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int enable
)
1878 return peer_activate (peer
, afi
, safi
);
1880 return peer_deactivate (peer
, afi
, safi
);
1884 peer_nsf_stop (struct peer
*peer
)
1889 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
);
1890 UNSET_FLAG (peer
->sflags
, PEER_STATUS_NSF_MODE
);
1892 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
1893 for (safi
= SAFI_UNICAST
; safi
< SAFI_RESERVED_3
; safi
++)
1894 peer
->nsf
[afi
][safi
] = 0;
1896 if (peer
->t_gr_restart
)
1898 BGP_TIMER_OFF (peer
->t_gr_restart
);
1899 if (bgp_debug_neighbor_events(peer
))
1900 zlog_debug ("%s graceful restart timer stopped", peer
->host
);
1902 if (peer
->t_gr_stale
)
1904 BGP_TIMER_OFF (peer
->t_gr_stale
);
1905 if (bgp_debug_neighbor_events(peer
))
1906 zlog_debug ("%s graceful restart stalepath timer stopped", peer
->host
);
1908 bgp_clear_route_all (peer
);
1911 /* Delete peer from confguration.
1913 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
1914 * it to "cool off" and refcounts to hit 0, at which state it is freed.
1916 * This function /should/ take care to be idempotent, to guard against
1917 * it being called multiple times through stray events that come in
1918 * that happen to result in this function being called again. That
1919 * said, getting here for a "Deleted" peer is a bug in the neighbour
1923 peer_delete (struct peer
*peer
)
1929 struct bgp_filter
*filter
;
1930 struct listnode
*pn
;
1933 assert (peer
->status
!= Deleted
);
1936 accept_peer
= CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1938 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
1939 peer_nsf_stop (peer
);
1941 SET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
1943 /* If this peer belongs to peer group, clear up the
1947 if (peer_dynamic_neighbor(peer
))
1948 peer_drop_dynamic_neighbor(peer
);
1950 if ((pn
= listnode_lookup (peer
->group
->peer
, peer
)))
1952 peer
= peer_unlock (peer
); /* group->peer list reference */
1953 list_delete_node (peer
->group
->peer
, pn
);
1958 /* Withdraw all information from routing table. We can not use
1959 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
1960 * executed after peer structure is deleted.
1962 peer
->last_reset
= PEER_DOWN_NEIGHBOR_DELETE
;
1964 UNSET_FLAG(peer
->flags
, PEER_FLAG_DELETE
);
1966 if (peer
->doppelganger
)
1968 peer
->doppelganger
->doppelganger
= NULL
;
1969 peer
->doppelganger
= NULL
;
1972 UNSET_FLAG(peer
->sflags
, PEER_STATUS_ACCEPT_PEER
);
1973 bgp_fsm_change_status (peer
, Deleted
);
1975 /* Password configuration */
1978 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
1979 peer
->password
= NULL
;
1982 ! BGP_PEER_SU_UNSPEC(peer
) &&
1983 ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
1984 bgp_md5_unset (peer
);
1987 bgp_timer_set (peer
); /* stops all timers for Deleted */
1989 /* Delete from all peer list. */
1990 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
1991 && (pn
= listnode_lookup (bgp
->peer
, peer
)))
1993 peer_unlock (peer
); /* bgp peer list reference */
1994 list_delete_node (bgp
->peer
, pn
);
1995 hash_release(bgp
->peerhash
, peer
);
2001 stream_free (peer
->ibuf
);
2007 stream_fifo_free (peer
->obuf
);
2013 stream_free (peer
->work
);
2019 stream_free(peer
->scratch
);
2020 peer
->scratch
= NULL
;
2023 /* Local and remote addresses. */
2026 sockunion_free (peer
->su_local
);
2027 peer
->su_local
= NULL
;
2030 if (peer
->su_remote
)
2032 sockunion_free (peer
->su_remote
);
2033 peer
->su_remote
= NULL
;
2036 /* Free filter related memory. */
2037 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2038 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2040 filter
= &peer
->filter
[afi
][safi
];
2042 for (i
= FILTER_IN
; i
< FILTER_MAX
; i
++)
2044 if (filter
->dlist
[i
].name
)
2046 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[i
].name
);
2047 filter
->dlist
[i
].name
= NULL
;
2050 if (filter
->plist
[i
].name
)
2052 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[i
].name
);
2053 filter
->plist
[i
].name
= NULL
;
2056 if (filter
->aslist
[i
].name
)
2058 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[i
].name
);
2059 filter
->aslist
[i
].name
= NULL
;
2063 for (i
= RMAP_IN
; i
< RMAP_MAX
; i
++)
2065 if (filter
->map
[i
].name
)
2067 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[i
].name
);
2068 filter
->map
[i
].name
= NULL
;
2072 if (filter
->usmap
.name
)
2074 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
2075 filter
->usmap
.name
= NULL
;
2078 if (peer
->default_rmap
[afi
][safi
].name
)
2080 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2081 peer
->default_rmap
[afi
][safi
].name
= NULL
;
2085 FOREACH_AFI_SAFI (afi
, safi
)
2086 peer_af_delete (peer
, afi
, safi
);
2090 XFREE(MTYPE_BGP_PEER_HOST
, peer
->hostname
);
2091 peer
->hostname
= NULL
;
2094 if (peer
->domainname
)
2096 XFREE(MTYPE_BGP_PEER_HOST
, peer
->domainname
);
2097 peer
->domainname
= NULL
;
2100 peer_unlock (peer
); /* initial reference */
2106 peer_group_cmp (struct peer_group
*g1
, struct peer_group
*g2
)
2108 return strcmp (g1
->name
, g2
->name
);
2111 /* Peer group cofiguration. */
2112 static struct peer_group
*
2113 peer_group_new (void)
2115 return (struct peer_group
*) XCALLOC (MTYPE_PEER_GROUP
,
2116 sizeof (struct peer_group
));
2120 peer_group_free (struct peer_group
*group
)
2122 XFREE (MTYPE_PEER_GROUP
, group
);
2126 peer_group_lookup (struct bgp
*bgp
, const char *name
)
2128 struct peer_group
*group
;
2129 struct listnode
*node
, *nnode
;
2131 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
2133 if (strcmp (group
->name
, name
) == 0)
2140 peer_group_get (struct bgp
*bgp
, const char *name
)
2142 struct peer_group
*group
;
2145 group
= peer_group_lookup (bgp
, name
);
2149 group
= peer_group_new ();
2152 XFREE(MTYPE_PEER_GROUP_HOST
, group
->name
);
2153 group
->name
= XSTRDUP(MTYPE_PEER_GROUP_HOST
, name
);
2154 group
->peer
= list_new ();
2155 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2156 group
->listen_range
[afi
] = list_new ();
2157 group
->conf
= peer_new (bgp
);
2158 if (! bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
2159 group
->conf
->afc
[AFI_IP
][SAFI_UNICAST
] = 1;
2160 if (group
->conf
->host
)
2161 XFREE(MTYPE_BGP_PEER_HOST
, group
->conf
->host
);
2162 group
->conf
->host
= XSTRDUP (MTYPE_BGP_PEER_HOST
, name
);
2163 group
->conf
->group
= group
;
2164 group
->conf
->as
= 0;
2165 group
->conf
->ttl
= 1;
2166 group
->conf
->gtsm_hops
= 0;
2167 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2168 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_TIMER
);
2169 UNSET_FLAG (group
->conf
->config
, PEER_CONFIG_CONNECT
);
2170 group
->conf
->keepalive
= 0;
2171 group
->conf
->holdtime
= 0;
2172 group
->conf
->connect
= 0;
2173 SET_FLAG (group
->conf
->sflags
, PEER_STATUS_GROUP
);
2174 listnode_add_sort (bgp
->group
, group
);
2180 peer_group2peer_config_copy (struct peer_group
*group
, struct peer
*peer
)
2189 peer
->as
= conf
->as
;
2192 if (conf
->change_local_as
)
2193 peer
->change_local_as
= conf
->change_local_as
;
2196 peer
->ttl
= conf
->ttl
;
2199 peer
->gtsm_hops
= conf
->gtsm_hops
;
2201 /* this flag is per-neighbor and so has to be preserved */
2202 v6only
= CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2204 /* peer flags apply */
2205 peer
->flags
= conf
->flags
;
2208 SET_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
);
2210 /* peer config apply */
2211 peer
->config
= conf
->config
;
2213 /* peer timers apply */
2214 peer
->holdtime
= conf
->holdtime
;
2215 peer
->keepalive
= conf
->keepalive
;
2216 peer
->connect
= conf
->connect
;
2217 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_CONNECT
))
2218 peer
->v_connect
= conf
->connect
;
2220 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
2222 /* advertisement-interval reset */
2223 if (CHECK_FLAG (conf
->config
, PEER_CONFIG_ROUTEADV
))
2224 peer
->v_routeadv
= conf
->routeadv
;
2226 if (peer_sort (peer
) == BGP_PEER_IBGP
)
2227 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2229 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2231 /* password apply */
2232 if (conf
->password
&& !peer
->password
)
2233 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, conf
->password
);
2235 if (! BGP_PEER_SU_UNSPEC(peer
))
2238 /* update-source apply */
2239 if (conf
->update_source
)
2241 if (peer
->update_source
)
2242 sockunion_free (peer
->update_source
);
2243 if (peer
->update_if
)
2245 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2246 peer
->update_if
= NULL
;
2248 peer
->update_source
= sockunion_dup (conf
->update_source
);
2250 else if (conf
->update_if
)
2252 if (peer
->update_if
)
2253 XFREE(MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
2254 if (peer
->update_source
)
2256 sockunion_free (peer
->update_source
);
2257 peer
->update_source
= NULL
;
2259 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, conf
->update_if
);
2262 bgp_bfd_peer_group2peer_copy(conf
, peer
);
2266 peer_group2peer_config_copy_af (struct peer_group
*group
, struct peer
*peer
,
2267 afi_t afi
, safi_t safi
)
2270 int out
= FILTER_OUT
;
2272 struct bgp_filter
*pfilter
;
2273 struct bgp_filter
*gfilter
;
2276 pfilter
= &peer
->filter
[afi
][safi
];
2277 gfilter
= &conf
->filter
[afi
][safi
];
2279 /* peer af_flags apply */
2280 peer
->af_flags
[afi
][safi
] = conf
->af_flags
[afi
][safi
];
2282 /* maximum-prefix */
2283 peer
->pmax
[afi
][safi
] = conf
->pmax
[afi
][safi
];
2284 peer
->pmax_threshold
[afi
][safi
] = conf
->pmax_threshold
[afi
][safi
];
2285 peer
->pmax_restart
[afi
][safi
] = conf
->pmax_restart
[afi
][safi
];
2288 peer
->allowas_in
[afi
][safi
] = conf
->allowas_in
[afi
][safi
];
2291 peer
->weight
[afi
][safi
] = conf
->weight
[afi
][safi
];
2293 /* default-originate route-map */
2294 if (conf
->default_rmap
[afi
][safi
].name
)
2296 if (peer
->default_rmap
[afi
][safi
].name
)
2297 XFREE(MTYPE_BGP_FILTER_NAME
, peer
->default_rmap
[afi
][safi
].name
);
2298 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, conf
->default_rmap
[afi
][safi
].name
);
2299 peer
->default_rmap
[afi
][safi
].map
= conf
->default_rmap
[afi
][safi
].map
;
2302 /* inbound filter apply */
2303 if (gfilter
->dlist
[in
].name
&& ! pfilter
->dlist
[in
].name
)
2305 if (pfilter
->dlist
[in
].name
)
2306 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[in
].name
);
2307 pfilter
->dlist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[in
].name
);
2308 pfilter
->dlist
[in
].alist
= gfilter
->dlist
[in
].alist
;
2311 if (gfilter
->plist
[in
].name
&& ! pfilter
->plist
[in
].name
)
2313 if (pfilter
->plist
[in
].name
)
2314 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[in
].name
);
2315 pfilter
->plist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[in
].name
);
2316 pfilter
->plist
[in
].plist
= gfilter
->plist
[in
].plist
;
2319 if (gfilter
->aslist
[in
].name
&& ! pfilter
->aslist
[in
].name
)
2321 if (pfilter
->aslist
[in
].name
)
2322 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[in
].name
);
2323 pfilter
->aslist
[in
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[in
].name
);
2324 pfilter
->aslist
[in
].aslist
= gfilter
->aslist
[in
].aslist
;
2327 if (gfilter
->map
[RMAP_IN
].name
&& ! pfilter
->map
[RMAP_IN
].name
)
2329 if (pfilter
->map
[RMAP_IN
].name
)
2330 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_IN
].name
);
2331 pfilter
->map
[RMAP_IN
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_IN
].name
);
2332 pfilter
->map
[RMAP_IN
].map
= gfilter
->map
[RMAP_IN
].map
;
2335 /* outbound filter apply */
2336 if (gfilter
->dlist
[out
].name
)
2338 if (pfilter
->dlist
[out
].name
)
2339 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2340 pfilter
->dlist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[out
].name
);
2341 pfilter
->dlist
[out
].alist
= gfilter
->dlist
[out
].alist
;
2345 if (pfilter
->dlist
[out
].name
)
2346 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->dlist
[out
].name
);
2347 pfilter
->dlist
[out
].name
= NULL
;
2348 pfilter
->dlist
[out
].alist
= NULL
;
2351 if (gfilter
->plist
[out
].name
)
2353 if (pfilter
->plist
[out
].name
)
2354 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2355 pfilter
->plist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[out
].name
);
2356 pfilter
->plist
[out
].plist
= gfilter
->plist
[out
].plist
;
2360 if (pfilter
->plist
[out
].name
)
2361 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->plist
[out
].name
);
2362 pfilter
->plist
[out
].name
= NULL
;
2363 pfilter
->plist
[out
].plist
= NULL
;
2366 if (gfilter
->aslist
[out
].name
)
2368 if (pfilter
->aslist
[out
].name
)
2369 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2370 pfilter
->aslist
[out
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[out
].name
);
2371 pfilter
->aslist
[out
].aslist
= gfilter
->aslist
[out
].aslist
;
2375 if (pfilter
->aslist
[out
].name
)
2376 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->aslist
[out
].name
);
2377 pfilter
->aslist
[out
].name
= NULL
;
2378 pfilter
->aslist
[out
].aslist
= NULL
;
2381 if (gfilter
->map
[RMAP_OUT
].name
)
2383 if (pfilter
->map
[RMAP_OUT
].name
)
2384 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2385 pfilter
->map
[RMAP_OUT
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[RMAP_OUT
].name
);
2386 pfilter
->map
[RMAP_OUT
].map
= gfilter
->map
[RMAP_OUT
].map
;
2390 if (pfilter
->map
[RMAP_OUT
].name
)
2391 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->map
[RMAP_OUT
].name
);
2392 pfilter
->map
[RMAP_OUT
].name
= NULL
;
2393 pfilter
->map
[RMAP_OUT
].map
= NULL
;
2396 if (gfilter
->usmap
.name
)
2398 if (pfilter
->usmap
.name
)
2399 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2400 pfilter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->usmap
.name
);
2401 pfilter
->usmap
.map
= gfilter
->usmap
.map
;
2405 if (pfilter
->usmap
.name
)
2406 XFREE(MTYPE_BGP_FILTER_NAME
, pfilter
->usmap
.name
);
2407 pfilter
->usmap
.name
= NULL
;
2408 pfilter
->usmap
.map
= NULL
;
2412 /* Peer group's remote AS configuration. */
2414 peer_group_remote_as (struct bgp
*bgp
, const char *group_name
,
2415 as_t
*as
, int as_type
)
2417 struct peer_group
*group
;
2419 struct listnode
*node
, *nnode
;
2421 group
= peer_group_lookup (bgp
, group_name
);
2425 if ((as_type
== group
->conf
->as_type
) && (group
->conf
->as
== *as
))
2429 /* When we setup peer-group AS number all peer group member's AS
2430 number must be updated to same number. */
2431 peer_as_change (group
->conf
, *as
, as_type
);
2433 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2435 if (((peer
->as_type
== AS_SPECIFIED
) && peer
->as
!= *as
) ||
2436 (peer
->as_type
!= as_type
))
2437 peer_as_change (peer
, *as
, as_type
);
2444 peer_group_delete (struct peer_group
*group
)
2448 struct prefix
*prefix
;
2450 struct listnode
*node
, *nnode
;
2455 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2457 other
= peer
->doppelganger
;
2459 if (other
&& other
->status
!= Deleted
)
2461 other
->group
= NULL
;
2465 list_delete (group
->peer
);
2467 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2469 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2471 prefix_free(prefix
);
2473 list_delete (group
->listen_range
[afi
]);
2476 XFREE(MTYPE_BGP_PEER_HOST
, group
->name
);
2479 group
->conf
->group
= NULL
;
2480 peer_delete (group
->conf
);
2482 /* Delete from all peer_group list. */
2483 listnode_delete (bgp
->group
, group
);
2485 bfd_info_free(&(group
->conf
->bfd_info
));
2487 peer_group_free (group
);
2493 peer_group_remote_as_delete (struct peer_group
*group
)
2495 struct peer
*peer
, *other
;
2496 struct listnode
*node
, *nnode
;
2498 if ((group
->conf
->as_type
== AS_UNSPECIFIED
) ||
2499 ((! group
->conf
->as
) && (group
->conf
->as_type
== AS_SPECIFIED
)))
2502 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2504 other
= peer
->doppelganger
;
2508 if (other
&& other
->status
!= Deleted
)
2510 other
->group
= NULL
;
2514 list_delete_all_node (group
->peer
);
2516 group
->conf
->as
= 0;
2517 group
->conf
->as_type
= AS_UNSPECIFIED
;
2523 peer_group_listen_range_add (struct peer_group
*group
, struct prefix
*range
)
2525 struct prefix
*prefix
;
2526 struct listnode
*node
, *nnode
;
2529 afi
= family2afi(range
->family
);
2531 /* Group needs remote AS configured. */
2532 if (group
->conf
->as_type
== AS_UNSPECIFIED
)
2533 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2535 /* Ensure no duplicates. Currently we don't care about overlaps. */
2536 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2538 if (prefix_same(range
, prefix
))
2542 prefix
= prefix_new();
2543 prefix_copy(prefix
, range
);
2544 listnode_add(group
->listen_range
[afi
], prefix
);
2549 peer_group_listen_range_del (struct peer_group
*group
, struct prefix
*range
)
2551 struct prefix
*prefix
, prefix2
;
2552 struct listnode
*node
, *nnode
;
2555 char buf
[PREFIX2STR_BUFFER
];
2557 afi
= family2afi(range
->family
);
2559 /* Identify the listen range. */
2560 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, prefix
))
2562 if (prefix_same(range
, prefix
))
2567 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND
;
2569 prefix2str(prefix
, buf
, sizeof(buf
));
2571 /* Dispose off any dynamic neighbors that exist due to this listen range */
2572 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
2574 if (!peer_dynamic_neighbor (peer
))
2577 sockunion2hostprefix(&peer
->su
, &prefix2
);
2578 if (prefix_match(prefix
, &prefix2
))
2580 if (bgp_debug_neighbor_events(peer
))
2581 zlog_debug ("Deleting dynamic neighbor %s group %s upon "
2582 "delete of listen range %s",
2583 peer
->host
, group
->name
, buf
);
2588 /* Get rid of the listen range */
2589 listnode_delete(group
->listen_range
[afi
], prefix
);
2594 /* Bind specified peer to peer group. */
2596 peer_group_bind (struct bgp
*bgp
, union sockunion
*su
, struct peer
*peer
,
2597 struct peer_group
*group
, as_t
*as
)
2599 int first_member
= 0;
2602 int cap_enhe_preset
= 0;
2604 /* Lookup the peer. */
2606 peer
= peer_lookup (bgp
, su
);
2608 /* The peer exist, bind it to the peer-group */
2611 /* When the peer already belongs to peer group, check the consistency. */
2612 if (peer_group_active (peer
) && strcmp (peer
->group
->name
, group
->name
) != 0)
2613 return BGP_ERR_PEER_GROUP_CANT_CHANGE
;
2615 /* The peer has not specified a remote-as, inherit it from the
2617 if (peer
->as_type
== AS_UNSPECIFIED
)
2619 peer
->as_type
= group
->conf
->as_type
;
2620 peer
->as
= group
->conf
->as
;
2623 if (! group
->conf
->as
)
2625 if (peer_sort (group
->conf
) != BGP_PEER_INTERNAL
2626 && peer_sort (group
->conf
) != peer_sort (peer
))
2630 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT
;
2633 if (peer_sort (group
->conf
) == BGP_PEER_INTERNAL
)
2637 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
2638 cap_enhe_preset
= 1;
2640 peer_group2peer_config_copy(group
, peer
);
2643 * Capability extended-nexthop is enabled for an interface neighbor by
2644 * default. So, fix that up here.
2646 if (peer
->ifp
&& cap_enhe_preset
)
2647 peer_flag_set (peer
, PEER_FLAG_CAPABILITY_ENHE
);
2649 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2650 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2652 if (group
->conf
->afc
[afi
][safi
])
2654 peer
->afc
[afi
][safi
] = 1;
2656 if (peer_af_find(peer
, afi
, safi
) || peer_af_create(peer
, afi
, safi
))
2658 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2665 assert (group
&& peer
->group
== group
);
2669 struct listnode
*pn
;
2670 pn
= listnode_lookup (bgp
->peer
, peer
);
2671 list_delete_node (bgp
->peer
, pn
);
2672 peer
->group
= group
;
2673 listnode_add_sort (bgp
->peer
, peer
);
2675 peer
= peer_lock (peer
); /* group->peer list reference */
2676 listnode_add (group
->peer
, peer
);
2681 /* Advertisement-interval reset */
2682 if (! CHECK_FLAG (group
->conf
->config
, PEER_CONFIG_ROUTEADV
))
2684 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2685 group
->conf
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
2687 group
->conf
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
2690 /* ebgp-multihop reset */
2691 if (peer_sort (group
->conf
) == BGP_PEER_IBGP
)
2692 group
->conf
->ttl
= MAXTTL
;
2694 /* local-as reset */
2695 if (peer_sort (group
->conf
) != BGP_PEER_EBGP
)
2697 group
->conf
->change_local_as
= 0;
2698 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
2699 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
2703 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2705 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2707 peer
->last_reset
= PEER_DOWN_RMAP_BIND
;
2708 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2709 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2713 bgp_session_reset(peer
);
2717 /* Create a new peer. */
2720 if ((group
->conf
->as_type
== AS_SPECIFIED
) && (! group
->conf
->as
))
2722 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS
;
2725 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
2727 peer
= peer_lock (peer
); /* group->peer list reference */
2728 listnode_add (group
->peer
, peer
);
2730 peer_group2peer_config_copy(group
, peer
);
2732 /* If the peer-group is active for this afi/safi then activate for this peer */
2733 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2734 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2735 if (group
->conf
->afc
[afi
][safi
])
2737 peer
->afc
[afi
][safi
] = 1;
2738 peer_af_create(peer
, afi
, safi
);
2739 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
2742 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
2744 /* Set up peer's events and timers. */
2745 if (peer_active (peer
))
2746 bgp_timer_set (peer
);
2753 peer_group_unbind (struct bgp
*bgp
, struct peer
*peer
,
2754 struct peer_group
*group
)
2760 if (group
!= peer
->group
)
2761 return BGP_ERR_PEER_GROUP_MISMATCH
;
2763 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2764 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2766 if (peer
->afc
[afi
][safi
])
2768 peer
->afc
[afi
][safi
] = 0;
2769 peer_af_flag_reset (peer
, afi
, safi
);
2771 if (peer_af_delete(peer
, afi
, safi
) != 0)
2773 zlog_err("couldn't delete af structure for peer %s", peer
->host
);
2778 assert (listnode_lookup (group
->peer
, peer
));
2779 peer_unlock (peer
); /* peer group list reference */
2780 listnode_delete (group
->peer
, peer
);
2782 other
= peer
->doppelganger
;
2784 if (group
->conf
->as
)
2787 if (other
&& other
->status
!= Deleted
)
2792 listnode_delete(group
->peer
, other
);
2794 other
->group
= NULL
;
2800 bgp_bfd_deregister_peer(peer
);
2801 peer_global_config_reset (peer
);
2803 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
2805 peer
->last_reset
= PEER_DOWN_RMAP_UNBIND
;
2806 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
2807 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
2810 bgp_session_reset(peer
);
2816 bgp_startup_timer_expire (struct thread
*thread
)
2820 bgp
= THREAD_ARG (thread
);
2821 bgp
->t_startup
= NULL
;
2826 /* BGP instance creation by `router bgp' commands. */
2828 bgp_create (as_t
*as
, const char *name
, enum bgp_instance_type inst_type
)
2834 if ( (bgp
= XCALLOC (MTYPE_BGP
, sizeof (struct bgp
))) == NULL
)
2837 if (BGP_DEBUG (zebra
, ZEBRA
))
2839 if (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2840 zlog_debug("Creating Default VRF, AS %u", *as
);
2842 zlog_debug("Creating %s %s, AS %u",
2843 (inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
2848 bgp
->inst_type
= inst_type
;
2849 bgp
->vrf_id
= (inst_type
== BGP_INSTANCE_TYPE_DEFAULT
) ?
2850 VRF_DEFAULT
: VRF_UNKNOWN
;
2851 bgp
->peer_self
= peer_new (bgp
);
2852 if (bgp
->peer_self
->host
)
2853 XFREE(MTYPE_BGP_PEER_HOST
, bgp
->peer_self
->host
);
2854 bgp
->peer_self
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, "Static announcement");
2855 bgp
->peer
= list_new ();
2856 bgp
->peer
->cmp
= (int (*)(void *, void *)) peer_cmp
;
2857 bgp
->peerhash
= hash_create (peer_hash_key_make
, peer_hash_cmp
);
2859 bgp
->group
= list_new ();
2860 bgp
->group
->cmp
= (int (*)(void *, void *)) peer_group_cmp
;
2862 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
2863 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
2865 bgp
->route
[afi
][safi
] = bgp_table_init (afi
, safi
);
2866 bgp
->aggregate
[afi
][safi
] = bgp_table_init (afi
, safi
);
2867 bgp
->rib
[afi
][safi
] = bgp_table_init (afi
, safi
);
2869 /* Enable maximum-paths */
2870 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_EBGP
, MULTIPATH_NUM
, 0);
2871 bgp_maximum_paths_set (bgp
, afi
, safi
, BGP_PEER_IBGP
, MULTIPATH_NUM
, 0);
2874 bgp
->v_update_delay
= BGP_UPDATE_DELAY_DEF
;
2875 bgp
->default_local_pref
= BGP_DEFAULT_LOCAL_PREF
;
2876 bgp
->default_subgroup_pkt_queue_max
= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
;
2877 bgp
->default_holdtime
= BGP_DEFAULT_HOLDTIME
;
2878 bgp
->default_keepalive
= BGP_DEFAULT_KEEPALIVE
;
2879 bgp
->restart_time
= BGP_DEFAULT_RESTART_TIME
;
2880 bgp
->stalepath_time
= BGP_DEFAULT_STALEPATH_TIME
;
2881 bgp
->dynamic_neighbors_limit
= BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT
;
2882 bgp
->dynamic_neighbors_count
= 0;
2883 bgp_flag_set (bgp
, BGP_FLAG_IMPORT_CHECK
);
2884 bgp_flag_set (bgp
, BGP_FLAG_SHOW_HOSTNAME
);
2885 bgp_flag_set (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
);
2886 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
2887 bgp
->addpath_tx_id
= BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
;
2892 bgp
->rfapi
= bgp_rfapi_new(bgp
);
2894 assert(bgp
->rfapi_cfg
);
2895 #endif /* ENABLE_BGP_VNC */
2899 bgp
->name
= XSTRDUP(MTYPE_BGP
, name
);
2903 /* TODO - The startup timer needs to be run for the whole of BGP */
2904 THREAD_TIMER_ON (bm
->master
, bgp
->t_startup
, bgp_startup_timer_expire
,
2905 bgp
, bgp
->restart_time
);
2908 bgp
->wpkt_quanta
= BGP_WRITE_PACKET_MAX
;
2909 bgp
->coalesce_time
= BGP_DEFAULT_SUBGROUP_COALESCE_TIME
;
2911 update_bgp_group_init(bgp
);
2915 /* Return the "default VRF" instance of BGP. */
2917 bgp_get_default (void)
2920 struct listnode
*node
, *nnode
;
2922 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
2923 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
2928 /* Lookup BGP entry. */
2930 bgp_lookup (as_t as
, const char *name
)
2933 struct listnode
*node
, *nnode
;
2935 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
2937 && ((bgp
->name
== NULL
&& name
== NULL
)
2938 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0)))
2943 /* Lookup BGP structure by view name. */
2945 bgp_lookup_by_name (const char *name
)
2948 struct listnode
*node
, *nnode
;
2950 for (ALL_LIST_ELEMENTS (bm
->bgp
, node
, nnode
, bgp
))
2951 if ((bgp
->name
== NULL
&& name
== NULL
)
2952 || (bgp
->name
&& name
&& strcmp (bgp
->name
, name
) == 0))
2957 /* Lookup BGP instance based on VRF id. */
2958 /* Note: Only to be used for incoming messages from Zebra. */
2960 bgp_lookup_by_vrf_id (vrf_id_t vrf_id
)
2964 /* Lookup VRF (in tree) and follow link. */
2965 vrf
= vrf_lookup (vrf_id
);
2968 return (vrf
->info
) ? (struct bgp
*)vrf
->info
: NULL
;
2971 /* Called from VTY commands. */
2973 bgp_get (struct bgp
**bgp_val
, as_t
*as
, const char *name
,
2974 enum bgp_instance_type inst_type
)
2978 /* Multiple instance check. */
2979 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
2982 bgp
= bgp_lookup_by_name (name
);
2984 bgp
= bgp_get_default ();
2986 /* Already exists. */
2992 return BGP_ERR_INSTANCE_MISMATCH
;
2994 if (bgp
->inst_type
!= inst_type
)
2995 return BGP_ERR_INSTANCE_MISMATCH
;
3002 /* BGP instance name can not be specified for single instance. */
3004 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
;
3006 /* Get default BGP structure if exists. */
3007 bgp
= bgp_get_default ();
3014 return BGP_ERR_AS_MISMATCH
;
3021 bgp
= bgp_create (as
, name
, inst_type
);
3022 bgp_router_id_set(bgp
, &bgp
->router_id_zebra
);
3023 bgp_address_init (bgp
);
3024 bgp_scan_init (bgp
);
3027 bgp
->t_rmap_def_originate_eval
= NULL
;
3029 /* Create BGP server socket, if first instance. */
3030 if (list_isempty(bm
->bgp
)
3031 && !bgp_option_check (BGP_OPT_NO_LISTEN
))
3033 if (bgp_socket (bm
->port
, bm
->address
) < 0)
3034 return BGP_ERR_INVALID_VALUE
;
3037 listnode_add (bm
->bgp
, bgp
);
3039 /* If Default instance or VRF, link to the VRF structure, if present. */
3040 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
||
3041 bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3045 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3048 bgp_vrf_link (bgp
, vrf
);
3053 /* Register with Zebra, if needed */
3054 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3055 bgp_zebra_instance_register (bgp
);
3062 * Make BGP instance "up". Applies only to VRFs (non-default) and
3063 * implies the VRF has been learnt from Zebra.
3066 bgp_instance_up (struct bgp
*bgp
)
3069 struct listnode
*node
, *next
;
3071 /* Register with zebra. */
3072 bgp_zebra_instance_register (bgp
);
3074 /* Kick off any peers that may have been configured. */
3075 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3077 if (!BGP_PEER_START_SUPPRESSED (peer
))
3078 BGP_EVENT_ADD (peer
, BGP_Start
);
3081 /* Process any networks that have been configured. */
3082 bgp_static_add (bgp
);
3086 * Make BGP instance "down". Applies only to VRFs (non-default) and
3087 * implies the VRF has been deleted by Zebra.
3090 bgp_instance_down (struct bgp
*bgp
)
3093 struct listnode
*node
;
3094 struct listnode
*next
;
3097 if (bgp
->t_rmap_def_originate_eval
)
3099 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3100 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3103 /* Bring down peers, so corresponding routes are purged. */
3104 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3106 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3107 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3109 bgp_session_reset(peer
);
3112 /* Purge network and redistributed routes. */
3113 bgp_purge_static_redist_routes (bgp
);
3116 /* Delete BGP instance. */
3118 bgp_delete (struct bgp
*bgp
)
3121 struct peer_group
*group
;
3122 struct listnode
*node
, *next
;
3126 THREAD_OFF (bgp
->t_startup
);
3128 if (BGP_DEBUG (zebra
, ZEBRA
))
3130 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_DEFAULT
)
3131 zlog_debug("Deleting Default VRF");
3133 zlog_debug("Deleting %s %s",
3134 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) ? "VRF" : "VIEW",
3139 if (bgp
->t_rmap_def_originate_eval
)
3141 BGP_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
3142 bgp_unlock(bgp
); /* TODO - This timer is started with a lock - why? */
3145 /* Inform peers we're going down. */
3146 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3148 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3149 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3152 /* Delete static routes (networks). */
3153 bgp_static_delete (bgp
);
3155 /* Unset redistribution. */
3156 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3157 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++)
3158 if (i
!= ZEBRA_ROUTE_BGP
)
3159 bgp_redistribute_unset (bgp
, afi
, i
, 0);
3161 /* Free peers and peer-groups. */
3162 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, next
, group
))
3163 peer_group_delete (group
);
3165 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, next
, peer
))
3168 if (bgp
->peer_self
) {
3169 peer_delete(bgp
->peer_self
);
3170 bgp
->peer_self
= NULL
;
3173 update_bgp_group_free (bgp
);
3175 /* TODO - Other memory may need to be freed - e.g., NHT */
3179 bgp_cleanup_routes(); /* rfapi cleanup can create route entries! */
3182 /* Remove visibility via the master list - there may however still be
3183 * routes to be processed still referencing the struct bgp.
3185 listnode_delete (bm
->bgp
, bgp
);
3186 if (list_isempty(bm
->bgp
))
3189 /* Deregister from Zebra, if needed */
3190 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
3191 bgp_zebra_instance_deregister (bgp
);
3193 /* Free interfaces in this instance. */
3194 bgp_if_finish (bgp
);
3196 thread_master_free_unused(bm
->master
);
3197 bgp_unlock(bgp
); /* initial reference */
3202 static void bgp_free (struct bgp
*);
3205 bgp_lock (struct bgp
*bgp
)
3211 bgp_unlock(struct bgp
*bgp
)
3213 assert(bgp
->lock
> 0);
3214 if (--bgp
->lock
== 0)
3219 bgp_free (struct bgp
*bgp
)
3225 list_delete (bgp
->group
);
3226 list_delete (bgp
->peer
);
3230 hash_free(bgp
->peerhash
);
3231 bgp
->peerhash
= NULL
;
3234 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3235 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3237 if (bgp
->route
[afi
][safi
])
3238 bgp_table_finish (&bgp
->route
[afi
][safi
]);
3239 if (bgp
->aggregate
[afi
][safi
])
3240 bgp_table_finish (&bgp
->aggregate
[afi
][safi
]) ;
3241 if (bgp
->rib
[afi
][safi
])
3242 bgp_table_finish (&bgp
->rib
[afi
][safi
]);
3245 bgp_address_destroy (bgp
);
3247 /* If Default instance or VRF, unlink from the VRF structure. */
3248 vrf
= bgp_vrf_lookup_by_instance_type (bgp
);
3250 bgp_vrf_unlink (bgp
, vrf
);
3253 XFREE(MTYPE_BGP
, bgp
->name
);
3255 XFREE (MTYPE_BGP
, bgp
);
3259 peer_lookup_by_conf_if (struct bgp
*bgp
, const char *conf_if
)
3262 struct listnode
*node
, *nnode
;
3269 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3270 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3271 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3274 else if (bm
->bgp
!= NULL
)
3276 struct listnode
*bgpnode
, *nbgpnode
;
3278 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3279 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3280 if (peer
->conf_if
&& !strcmp(peer
->conf_if
, conf_if
)
3281 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3288 peer_lookup_by_hostname (struct bgp
*bgp
, const char *hostname
)
3291 struct listnode
*node
, *nnode
;
3298 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3299 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3300 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3303 else if (bm
->bgp
!= NULL
)
3305 struct listnode
*bgpnode
, *nbgpnode
;
3307 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3308 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
3309 if (peer
->hostname
&& !strcmp(peer
->hostname
, hostname
)
3310 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_ACCEPT_PEER
))
3317 peer_lookup (struct bgp
*bgp
, union sockunion
*su
)
3319 struct peer
*peer
= NULL
;
3320 struct peer tmp_peer
;
3322 memset(&tmp_peer
, 0, sizeof(struct peer
));
3325 * We do not want to find the doppelganger peer so search for the peer in
3326 * the hash that has PEER_FLAG_CONFIG_NODE
3328 SET_FLAG (tmp_peer
.flags
, PEER_FLAG_CONFIG_NODE
);
3334 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3336 else if (bm
->bgp
!= NULL
)
3338 struct listnode
*bgpnode
, *nbgpnode
;
3340 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3342 /* Skip VRFs, this function will not be invoked without an instance
3343 * when examining VRFs.
3345 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
)
3348 peer
= hash_lookup(bgp
->peerhash
, &tmp_peer
);
3359 peer_create_bind_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
,
3360 struct peer_group
*group
)
3366 /* Create peer first; we've already checked group config is valid. */
3367 peer
= peer_create (su
, NULL
, bgp
, bgp
->as
, group
->conf
->as
, group
->conf
->as_type
, 0, 0, group
);
3372 peer
= peer_lock (peer
);
3373 listnode_add (group
->peer
, peer
);
3375 peer_group2peer_config_copy(group
, peer
);
3378 * Bind peer for all AFs configured for the group. We don't call
3379 * peer_group_bind as that is sub-optimal and does some stuff we don't want.
3381 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
3382 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
3384 if (!group
->conf
->afc
[afi
][safi
])
3386 peer
->afc
[afi
][safi
] = 1;
3388 if (!peer_af_find(peer
, afi
, safi
))
3389 peer_af_create(peer
, afi
, safi
);
3391 peer_group2peer_config_copy_af (group
, peer
, afi
, safi
);
3394 /* Mark as dynamic, but also as a "config node" for other things to work. */
3395 SET_FLAG(peer
->flags
, PEER_FLAG_DYNAMIC_NEIGHBOR
);
3396 SET_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
);
3402 peer_group_lookup_dynamic_neighbor_range (struct peer_group
* group
,
3403 struct prefix
* prefix
)
3405 struct listnode
*node
, *nnode
;
3406 struct prefix
*range
;
3409 afi
= family2afi(prefix
->family
);
3411 if (group
->listen_range
[afi
])
3412 for (ALL_LIST_ELEMENTS (group
->listen_range
[afi
], node
, nnode
, range
))
3413 if (prefix_match(range
, prefix
))
3420 peer_group_lookup_dynamic_neighbor (struct bgp
*bgp
, struct prefix
*prefix
,
3421 struct prefix
**listen_range
)
3423 struct prefix
*range
= NULL
;
3424 struct peer_group
*group
= NULL
;
3425 struct listnode
*node
, *nnode
;
3427 *listen_range
= NULL
;
3430 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3431 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3434 else if (bm
->bgp
!= NULL
)
3436 struct listnode
*bgpnode
, *nbgpnode
;
3438 for (ALL_LIST_ELEMENTS (bm
->bgp
, bgpnode
, nbgpnode
, bgp
))
3439 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
3440 if ((range
= peer_group_lookup_dynamic_neighbor_range(group
, prefix
)))
3445 *listen_range
= range
;
3446 return (group
&& range
) ? group
: NULL
;
3450 peer_lookup_dynamic_neighbor (struct bgp
*bgp
, union sockunion
*su
)
3452 struct peer_group
*group
;
3455 struct prefix prefix
;
3456 struct prefix
*listen_range
;
3458 char buf
[PREFIX2STR_BUFFER
];
3459 char buf1
[PREFIX2STR_BUFFER
];
3461 sockunion2hostprefix(su
, &prefix
);
3463 /* See if incoming connection matches a configured listen range. */
3464 group
= peer_group_lookup_dynamic_neighbor (bgp
, &prefix
, &listen_range
);
3475 prefix2str(&prefix
, buf
, sizeof(buf
));
3476 prefix2str(listen_range
, buf1
, sizeof(buf1
));
3478 if (bgp_debug_neighbor_events(NULL
))
3479 zlog_debug ("Dynamic Neighbor %s matches group %s listen range %s",
3480 buf
, group
->name
, buf1
);
3482 /* Are we within the listen limit? */
3483 dncount
= gbgp
->dynamic_neighbors_count
;
3485 if (dncount
>= gbgp
->dynamic_neighbors_limit
)
3487 if (bgp_debug_neighbor_events(NULL
))
3488 zlog_debug ("Dynamic Neighbor %s rejected - at limit %d",
3489 inet_sutop (su
, buf
), gbgp
->dynamic_neighbors_limit
);
3493 /* Ensure group is not disabled. */
3494 if (CHECK_FLAG (group
->conf
->flags
, PEER_FLAG_SHUTDOWN
))
3496 if (bgp_debug_neighbor_events(NULL
))
3497 zlog_debug ("Dynamic Neighbor %s rejected - group %s disabled",
3502 /* Check that at least one AF is activated for the group. */
3503 if (!peer_group_af_configured (group
))
3505 if (bgp_debug_neighbor_events(NULL
))
3506 zlog_debug ("Dynamic Neighbor %s rejected - no AF activated for group %s",
3511 /* Create dynamic peer and bind to associated group. */
3512 peer
= peer_create_bind_dynamic_neighbor (gbgp
, su
, group
);
3515 gbgp
->dynamic_neighbors_count
= ++dncount
;
3517 if (bgp_debug_neighbor_events(peer
))
3518 zlog_debug ("%s Dynamic Neighbor added, group %s count %d",
3519 peer
->host
, group
->name
, dncount
);
3524 void peer_drop_dynamic_neighbor (struct peer
*peer
)
3527 if (peer
->group
&& peer
->group
->bgp
)
3529 dncount
= peer
->group
->bgp
->dynamic_neighbors_count
;
3531 peer
->group
->bgp
->dynamic_neighbors_count
= --dncount
;
3533 if (bgp_debug_neighbor_events(peer
))
3534 zlog_debug ("%s dropped from group %s, count %d",
3535 peer
->host
, peer
->group
->name
, dncount
);
3539 /* If peer is configured at least one address family return 1. */
3541 peer_active (struct peer
*peer
)
3543 if (BGP_PEER_SU_UNSPEC(peer
))
3545 if (peer
->afc
[AFI_IP
][SAFI_UNICAST
]
3546 || peer
->afc
[AFI_IP
][SAFI_MULTICAST
]
3547 || peer
->afc
[AFI_IP
][SAFI_MPLS_VPN
]
3548 || peer
->afc
[AFI_IP
][SAFI_ENCAP
]
3549 || peer
->afc
[AFI_IP6
][SAFI_UNICAST
]
3550 || peer
->afc
[AFI_IP6
][SAFI_MULTICAST
]
3551 || peer
->afc
[AFI_IP6
][SAFI_MPLS_VPN
]
3552 || peer
->afc
[AFI_IP6
][SAFI_ENCAP
])
3557 /* If peer is negotiated at least one address family return 1. */
3559 peer_active_nego (struct peer
*peer
)
3561 if (peer
->afc_nego
[AFI_IP
][SAFI_UNICAST
]
3562 || peer
->afc_nego
[AFI_IP
][SAFI_MULTICAST
]
3563 || peer
->afc_nego
[AFI_IP
][SAFI_MPLS_VPN
]
3564 || peer
->afc_nego
[AFI_IP
][SAFI_ENCAP
]
3565 || peer
->afc_nego
[AFI_IP6
][SAFI_UNICAST
]
3566 || peer
->afc_nego
[AFI_IP6
][SAFI_MULTICAST
]
3567 || peer
->afc_nego
[AFI_IP6
][SAFI_MPLS_VPN
]
3568 || peer
->afc_nego
[AFI_IP6
][SAFI_ENCAP
])
3573 /* peer_flag_change_type. */
3574 enum peer_change_type
3578 peer_change_reset_in
,
3579 peer_change_reset_out
,
3583 peer_change_action (struct peer
*peer
, afi_t afi
, safi_t safi
,
3584 enum peer_change_type type
)
3586 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3589 if (peer
->status
!= Established
)
3592 if (type
== peer_change_reset
)
3594 /* If we're resetting session, we've to delete both peer struct */
3595 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3596 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3597 PEER_FLAG_CONFIG_NODE
)))
3598 peer_delete(peer
->doppelganger
);
3600 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3601 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3603 else if (type
== peer_change_reset_in
)
3605 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
3606 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
3607 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
3610 if ((peer
->doppelganger
) && (peer
->doppelganger
->status
!= Deleted
)
3611 && (!CHECK_FLAG(peer
->doppelganger
->flags
,
3612 PEER_FLAG_CONFIG_NODE
)))
3613 peer_delete(peer
->doppelganger
);
3615 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3616 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3619 else if (type
== peer_change_reset_out
)
3621 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
3622 bgp_announce_route (peer
, afi
, safi
);
3626 struct peer_flag_action
3631 /* This flag can be set for peer-group member. */
3632 u_char not_for_member
;
3634 /* Action when the flag is changed. */
3635 enum peer_change_type type
;
3637 /* Peer down cause */
3641 static const struct peer_flag_action peer_flag_action_list
[] =
3643 { PEER_FLAG_PASSIVE
, 0, peer_change_reset
},
3644 { PEER_FLAG_SHUTDOWN
, 0, peer_change_reset
},
3645 { PEER_FLAG_DONT_CAPABILITY
, 0, peer_change_none
},
3646 { PEER_FLAG_OVERRIDE_CAPABILITY
, 0, peer_change_none
},
3647 { PEER_FLAG_STRICT_CAP_MATCH
, 0, peer_change_none
},
3648 { PEER_FLAG_DYNAMIC_CAPABILITY
, 0, peer_change_reset
},
3649 { PEER_FLAG_DISABLE_CONNECTED_CHECK
, 0, peer_change_reset
},
3650 { PEER_FLAG_CAPABILITY_ENHE
, 0, peer_change_reset
},
3654 static const struct peer_flag_action peer_af_flag_action_list
[] =
3656 { PEER_FLAG_SEND_COMMUNITY
, 1, peer_change_reset_out
},
3657 { PEER_FLAG_SEND_EXT_COMMUNITY
, 1, peer_change_reset_out
},
3658 { PEER_FLAG_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3659 { PEER_FLAG_REFLECTOR_CLIENT
, 1, peer_change_reset
},
3660 { PEER_FLAG_RSERVER_CLIENT
, 1, peer_change_reset
},
3661 { PEER_FLAG_SOFT_RECONFIG
, 0, peer_change_reset_in
},
3662 { PEER_FLAG_AS_PATH_UNCHANGED
, 1, peer_change_reset_out
},
3663 { PEER_FLAG_NEXTHOP_UNCHANGED
, 1, peer_change_reset_out
},
3664 { PEER_FLAG_MED_UNCHANGED
, 1, peer_change_reset_out
},
3665 // PEER_FLAG_DEFAULT_ORIGINATE
3666 { PEER_FLAG_REMOVE_PRIVATE_AS
, 1, peer_change_reset_out
},
3667 { PEER_FLAG_ALLOWAS_IN
, 0, peer_change_reset_in
},
3668 { PEER_FLAG_ORF_PREFIX_SM
, 1, peer_change_reset
},
3669 { PEER_FLAG_ORF_PREFIX_RM
, 1, peer_change_reset
},
3670 // PEER_FLAG_MAX_PREFIX
3671 // PEER_FLAG_MAX_PREFIX_WARNING
3672 { PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
, 0, peer_change_reset_out
},
3673 { PEER_FLAG_FORCE_NEXTHOP_SELF
, 1, peer_change_reset_out
},
3674 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL
, 1, peer_change_reset_out
},
3675 { PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
,1, peer_change_reset_out
},
3676 { PEER_FLAG_AS_OVERRIDE
, 1, peer_change_reset_out
},
3677 { PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
,1, peer_change_reset_out
},
3678 { PEER_FLAG_ADDPATH_TX_ALL_PATHS
, 1, peer_change_reset
},
3679 { PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
, 1, peer_change_reset
},
3680 { PEER_FLAG_WEIGHT
, 0, peer_change_reset_in
},
3684 /* Proper action set. */
3686 peer_flag_action_set (const struct peer_flag_action
*action_list
, int size
,
3687 struct peer_flag_action
*action
, u_int32_t flag
)
3693 const struct peer_flag_action
*match
= NULL
;
3695 /* Check peer's frag action. */
3696 for (i
= 0; i
< size
; i
++)
3698 match
= &action_list
[i
];
3700 if (match
->flag
== 0)
3703 if (match
->flag
& flag
)
3707 if (match
->type
== peer_change_reset_in
)
3709 if (match
->type
== peer_change_reset_out
)
3711 if (match
->type
== peer_change_reset
)
3716 if (match
->not_for_member
)
3717 action
->not_for_member
= 1;
3721 /* Set peer clear type. */
3722 if (reset_in
&& reset_out
)
3723 action
->type
= peer_change_reset
;
3725 action
->type
= peer_change_reset_in
;
3727 action
->type
= peer_change_reset_out
;
3729 action
->type
= peer_change_none
;
3735 peer_flag_modify_action (struct peer
*peer
, u_int32_t flag
)
3737 if (flag
== PEER_FLAG_SHUTDOWN
)
3739 if (CHECK_FLAG (peer
->flags
, flag
))
3741 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3742 peer_nsf_stop (peer
);
3744 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
3745 if (peer
->t_pmax_restart
)
3747 BGP_TIMER_OFF (peer
->t_pmax_restart
);
3748 if (bgp_debug_neighbor_events(peer
))
3749 zlog_debug ("%s Maximum-prefix restart timer canceled",
3753 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_NSF_WAIT
))
3754 peer_nsf_stop (peer
);
3756 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3757 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3758 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
);
3760 bgp_session_reset(peer
);
3764 peer
->v_start
= BGP_INIT_START_TIMER
;
3765 BGP_EVENT_ADD (peer
, BGP_Stop
);
3768 else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
3770 if (flag
== PEER_FLAG_DYNAMIC_CAPABILITY
)
3771 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3772 else if (flag
== PEER_FLAG_PASSIVE
)
3773 peer
->last_reset
= PEER_DOWN_PASSIVE_CHANGE
;
3774 else if (flag
== PEER_FLAG_DISABLE_CONNECTED_CHECK
)
3775 peer
->last_reset
= PEER_DOWN_MULTIHOP_CHANGE
;
3777 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
3778 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
3781 bgp_session_reset(peer
);
3784 /* Change specified peer flag. */
3786 peer_flag_modify (struct peer
*peer
, u_int32_t flag
, int set
)
3790 struct peer_group
*group
;
3791 struct peer
*tmp_peer
;
3792 struct listnode
*node
, *nnode
;
3793 struct peer_flag_action action
;
3795 memset (&action
, 0, sizeof (struct peer_flag_action
));
3796 size
= sizeof peer_flag_action_list
/ sizeof (struct peer_flag_action
);
3798 found
= peer_flag_action_set (peer_flag_action_list
, size
, &action
, flag
);
3800 /* No flag action is found. */
3802 return BGP_ERR_INVALID_FLAG
;
3804 /* When unset the peer-group member's flag we have to check
3805 peer-group configuration. */
3806 if (! set
&& peer_group_active (peer
))
3807 if (CHECK_FLAG (peer
->group
->conf
->flags
, flag
))
3809 if (flag
== PEER_FLAG_SHUTDOWN
)
3810 return BGP_ERR_PEER_GROUP_SHUTDOWN
;
3813 /* Flag conflict check. */
3815 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_STRICT_CAP_MATCH
)
3816 && CHECK_FLAG (peer
->flags
| flag
, PEER_FLAG_OVERRIDE_CAPABILITY
))
3817 return BGP_ERR_PEER_FLAG_CONFLICT
;
3819 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3821 if (set
&& CHECK_FLAG (peer
->flags
, flag
) == flag
)
3823 if (! set
&& ! CHECK_FLAG (peer
->flags
, flag
))
3828 SET_FLAG (peer
->flags
, flag
);
3830 UNSET_FLAG (peer
->flags
, flag
);
3832 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3834 if (action
.type
== peer_change_reset
)
3835 peer_flag_modify_action (peer
, flag
);
3840 /* peer-group member updates. */
3841 group
= peer
->group
;
3843 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
3846 if (set
&& CHECK_FLAG (tmp_peer
->flags
, flag
) == flag
)
3849 if (! set
&& ! CHECK_FLAG (tmp_peer
->flags
, flag
))
3853 SET_FLAG (tmp_peer
->flags
, flag
);
3855 UNSET_FLAG (tmp_peer
->flags
, flag
);
3857 if (action
.type
== peer_change_reset
)
3858 peer_flag_modify_action (tmp_peer
, flag
);
3864 peer_flag_set (struct peer
*peer
, u_int32_t flag
)
3866 return peer_flag_modify (peer
, flag
, 1);
3870 peer_flag_unset (struct peer
*peer
, u_int32_t flag
)
3872 return peer_flag_modify (peer
, flag
, 0);
3876 peer_af_flag_modify (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
,
3881 struct listnode
*node
, *nnode
;
3882 struct peer_group
*group
;
3883 struct peer_flag_action action
;
3884 struct peer
*tmp_peer
;
3886 int addpath_tx_used
;
3888 memset (&action
, 0, sizeof (struct peer_flag_action
));
3889 size
= sizeof peer_af_flag_action_list
/ sizeof (struct peer_flag_action
);
3891 found
= peer_flag_action_set (peer_af_flag_action_list
, size
, &action
, flag
);
3893 /* No flag action is found. */
3895 return BGP_ERR_INVALID_FLAG
;
3897 /* Special check for reflector client. */
3898 if (flag
& PEER_FLAG_REFLECTOR_CLIENT
3899 && peer_sort (peer
) != BGP_PEER_IBGP
)
3900 return BGP_ERR_NOT_INTERNAL_PEER
;
3902 /* Special check for remove-private-AS. */
3903 if (flag
& PEER_FLAG_REMOVE_PRIVATE_AS
3904 && peer_sort (peer
) == BGP_PEER_IBGP
)
3905 return BGP_ERR_REMOVE_PRIVATE_AS
;
3907 /* as-override is not allowed for IBGP peers */
3908 if (flag
& PEER_FLAG_AS_OVERRIDE
3909 && peer_sort (peer
) == BGP_PEER_IBGP
)
3910 return BGP_ERR_AS_OVERRIDE
;
3912 /* When current flag configuration is same as requested one. */
3913 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3915 if (set
&& CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
) == flag
)
3917 if (! set
&& ! CHECK_FLAG (peer
->af_flags
[afi
][safi
], flag
))
3922 SET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
3924 UNSET_FLAG (peer
->af_flags
[afi
][safi
], flag
);
3926 /* Execute action when peer is established. */
3927 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
3928 && peer
->status
== Established
)
3930 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
3931 bgp_clear_adj_in (peer
, afi
, safi
);
3934 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
3935 peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
3936 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
3937 peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
3938 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
3939 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3940 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
3941 peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3943 peer_change_action (peer
, afi
, safi
, action
.type
);
3948 /* Peer group member updates. */
3949 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
3951 group
= peer
->group
;
3953 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, tmp_peer
))
3955 if (set
&& CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
) == flag
)
3958 if (! set
&& ! CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
))
3962 SET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
3964 UNSET_FLAG (tmp_peer
->af_flags
[afi
][safi
], flag
);
3966 if (tmp_peer
->status
== Established
)
3968 if (! set
&& flag
== PEER_FLAG_SOFT_RECONFIG
)
3969 bgp_clear_adj_in (tmp_peer
, afi
, safi
);
3972 if (flag
== PEER_FLAG_REFLECTOR_CLIENT
)
3973 tmp_peer
->last_reset
= PEER_DOWN_RR_CLIENT_CHANGE
;
3974 else if (flag
== PEER_FLAG_RSERVER_CLIENT
)
3975 tmp_peer
->last_reset
= PEER_DOWN_RS_CLIENT_CHANGE
;
3976 else if (flag
== PEER_FLAG_ORF_PREFIX_SM
)
3977 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3978 else if (flag
== PEER_FLAG_ORF_PREFIX_RM
)
3979 tmp_peer
->last_reset
= PEER_DOWN_CAPABILITY_CHANGE
;
3981 peer_change_action (tmp_peer
, afi
, safi
, action
.type
);
3987 /* Track if addpath TX is in use */
3988 if (flag
& (PEER_FLAG_ADDPATH_TX_ALL_PATHS
|PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
3991 addpath_tx_used
= 0;
3995 addpath_tx_used
= 1;
3997 if (flag
& PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)
3999 if (!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
))
4001 zlog_warn("%s: enabling bgp deterministic-med, this is required"\
4002 " for addpath-tx-bestpath-per-AS",
4004 bgp_flag_set (bgp
, BGP_FLAG_DETERMINISTIC_MED
);
4005 bgp_recalculate_all_bestpaths (bgp
);
4011 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, tmp_peer
))
4013 if (CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_ALL_PATHS
) ||
4014 CHECK_FLAG (tmp_peer
->af_flags
[afi
][safi
], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
4016 addpath_tx_used
= 1;
4022 bgp
->addpath_tx_used
[afi
][safi
] = addpath_tx_used
;
4029 peer_af_flag_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4031 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 1);
4035 peer_af_flag_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int32_t flag
)
4037 return peer_af_flag_modify (peer
, afi
, safi
, flag
, 0);
4040 /* EBGP multihop configuration. */
4042 peer_ebgp_multihop_set (struct peer
*peer
, int ttl
)
4044 struct peer_group
*group
;
4045 struct listnode
*node
, *nnode
;
4048 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->conf_if
)
4051 /* see comment in peer_ttl_security_hops_set() */
4054 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4056 group
= peer
->group
;
4057 if (group
->conf
->gtsm_hops
!= 0)
4058 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4060 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
4062 if (peer1
->sort
== BGP_PEER_IBGP
)
4065 if (peer1
->gtsm_hops
!= 0)
4066 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4071 if (peer
->gtsm_hops
!= 0)
4072 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4078 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4080 if (peer
->fd
>= 0 && peer
->sort
!= BGP_PEER_IBGP
)
4082 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4083 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4084 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4086 bgp_session_reset(peer
);
4091 group
= peer
->group
;
4092 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4094 if (peer
->sort
== BGP_PEER_IBGP
)
4097 peer
->ttl
= group
->conf
->ttl
;
4099 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4100 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4101 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4103 bgp_session_reset(peer
);
4110 peer_ebgp_multihop_unset (struct peer
*peer
)
4112 struct peer_group
*group
;
4113 struct listnode
*node
, *nnode
;
4115 if (peer
->sort
== BGP_PEER_IBGP
)
4118 if (peer
->gtsm_hops
!= 0 && peer
->ttl
!= MAXTTL
)
4119 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
4121 if (peer_group_active (peer
))
4122 peer
->ttl
= peer
->group
->conf
->ttl
;
4126 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4128 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4129 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4130 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4132 bgp_session_reset(peer
);
4136 group
= peer
->group
;
4137 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4139 if (peer
->sort
== BGP_PEER_IBGP
)
4146 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4147 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4148 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4150 bgp_session_reset(peer
);
4157 /* Neighbor description. */
4159 peer_description_set (struct peer
*peer
, const char *desc
)
4162 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4164 peer
->desc
= XSTRDUP (MTYPE_PEER_DESC
, desc
);
4170 peer_description_unset (struct peer
*peer
)
4173 XFREE (MTYPE_PEER_DESC
, peer
->desc
);
4180 /* Neighbor update-source. */
4182 peer_update_source_if_set (struct peer
*peer
, const char *ifname
)
4184 struct peer_group
*group
;
4185 struct listnode
*node
, *nnode
;
4187 if (peer
->update_if
)
4189 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4190 && strcmp (peer
->update_if
, ifname
) == 0)
4193 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4194 peer
->update_if
= NULL
;
4197 if (peer
->update_source
)
4199 sockunion_free (peer
->update_source
);
4200 peer
->update_source
= NULL
;
4203 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4205 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4207 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4209 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4210 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4211 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4214 bgp_session_reset(peer
);
4218 /* peer-group member updates. */
4219 group
= peer
->group
;
4220 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4222 if (peer
->update_if
)
4224 if (strcmp (peer
->update_if
, ifname
) == 0)
4227 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4228 peer
->update_if
= NULL
;
4231 if (peer
->update_source
)
4233 sockunion_free (peer
->update_source
);
4234 peer
->update_source
= NULL
;
4237 peer
->update_if
= XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, ifname
);
4239 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4241 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4242 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4243 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4246 bgp_session_reset(peer
);
4252 peer_update_source_addr_set (struct peer
*peer
, const union sockunion
*su
)
4254 struct peer_group
*group
;
4255 struct listnode
*node
, *nnode
;
4257 if (peer
->update_source
)
4259 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4260 && sockunion_cmp (peer
->update_source
, su
) == 0)
4262 sockunion_free (peer
->update_source
);
4263 peer
->update_source
= NULL
;
4266 if (peer
->update_if
)
4268 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4269 peer
->update_if
= NULL
;
4273 peer
->update_source
= sockunion_dup (su
);
4275 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4277 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4279 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4280 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4281 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4284 bgp_session_reset(peer
);
4288 /* peer-group member updates. */
4289 group
= peer
->group
;
4290 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4292 if (peer
->update_source
)
4294 if (sockunion_cmp (peer
->update_source
, su
) == 0)
4296 sockunion_free (peer
->update_source
);
4297 peer
->update_source
= NULL
;
4300 if (peer
->update_if
)
4302 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4303 peer
->update_if
= NULL
;
4306 peer
->update_source
= sockunion_dup (su
);
4308 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4310 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4311 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4312 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4315 bgp_session_reset(peer
);
4321 peer_update_source_unset (struct peer
*peer
)
4323 union sockunion
*su
;
4324 struct peer_group
*group
;
4325 struct listnode
*node
, *nnode
;
4327 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)
4328 && ! peer
->update_source
4329 && ! peer
->update_if
)
4332 if (peer
->update_source
)
4334 sockunion_free (peer
->update_source
);
4335 peer
->update_source
= NULL
;
4337 if (peer
->update_if
)
4339 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4340 peer
->update_if
= NULL
;
4343 if (peer_group_active (peer
))
4345 group
= peer
->group
;
4347 if (group
->conf
->update_source
)
4349 su
= sockunion_dup (group
->conf
->update_source
);
4350 peer
->update_source
= su
;
4352 else if (group
->conf
->update_if
)
4354 XSTRDUP (MTYPE_PEER_UPDATE_SOURCE
, group
->conf
->update_if
);
4357 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4359 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4361 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4362 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4363 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4366 bgp_session_reset(peer
);
4370 /* peer-group member updates. */
4371 group
= peer
->group
;
4372 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4374 if (! peer
->update_source
&& ! peer
->update_if
)
4377 if (peer
->update_source
)
4379 sockunion_free (peer
->update_source
);
4380 peer
->update_source
= NULL
;
4383 if (peer
->update_if
)
4385 XFREE (MTYPE_PEER_UPDATE_SOURCE
, peer
->update_if
);
4386 peer
->update_if
= NULL
;
4389 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4391 peer
->last_reset
= PEER_DOWN_UPDATE_SOURCE_CHANGE
;
4392 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4393 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4396 bgp_session_reset(peer
);
4402 peer_default_originate_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
4405 struct peer_group
*group
;
4406 struct listnode
*node
, *nnode
;
4408 if (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
)
4409 || (rmap
&& ! peer
->default_rmap
[afi
][safi
].name
)
4410 || (rmap
&& strcmp (rmap
, peer
->default_rmap
[afi
][safi
].name
) != 0))
4412 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4416 if (peer
->default_rmap
[afi
][safi
].name
)
4417 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4418 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4419 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4423 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4425 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4426 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4427 bgp_default_originate (peer
, afi
, safi
, 0);
4428 bgp_announce_route (peer
, afi
, safi
);
4433 /* peer-group member updates. */
4434 group
= peer
->group
;
4435 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4437 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4441 if (peer
->default_rmap
[afi
][safi
].name
)
4442 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4443 peer
->default_rmap
[afi
][safi
].name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
4444 peer
->default_rmap
[afi
][safi
].map
= route_map_lookup_by_name (rmap
);
4447 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4448 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4449 bgp_default_originate (peer
, afi
, safi
, 0);
4450 bgp_announce_route (peer
, afi
, safi
);
4457 peer_default_originate_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4459 struct peer_group
*group
;
4460 struct listnode
*node
, *nnode
;
4462 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
))
4464 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4466 if (peer
->default_rmap
[afi
][safi
].name
)
4467 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4468 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4469 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4472 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4474 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4475 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4476 bgp_default_originate (peer
, afi
, safi
, 1);
4477 bgp_announce_route (peer
, afi
, safi
);
4482 /* peer-group member updates. */
4483 group
= peer
->group
;
4484 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4486 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_DEFAULT_ORIGINATE
);
4488 if (peer
->default_rmap
[afi
][safi
].name
)
4489 XFREE(MTYPE_ROUTE_MAP_NAME
, peer
->default_rmap
[afi
][safi
].name
);
4490 peer
->default_rmap
[afi
][safi
].name
= NULL
;
4491 peer
->default_rmap
[afi
][safi
].map
= NULL
;
4493 if (peer
->status
== Established
&& peer
->afc_nego
[afi
][safi
]) {
4494 update_group_adjust_peer(peer_af_find(peer
, afi
, safi
));
4495 bgp_default_originate (peer
, afi
, safi
, 1);
4496 bgp_announce_route (peer
, afi
, safi
);
4503 peer_port_set (struct peer
*peer
, u_int16_t port
)
4510 peer_port_unset (struct peer
*peer
)
4512 peer
->port
= BGP_PORT_DEFAULT
;
4517 * Helper function that is called after the name of the policy
4518 * being used by a peer has changed (AF specific). Automatically
4519 * initiates inbound or outbound processing as needed.
4522 peer_on_policy_change (struct peer
*peer
, afi_t afi
, safi_t safi
, int outbound
)
4526 update_group_adjust_peer (peer_af_find (peer
, afi
, safi
));
4527 if (peer
->status
== Established
)
4528 bgp_announce_route(peer
, afi
, safi
);
4532 if (peer
->status
!= Established
)
4535 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
4536 bgp_soft_reconfig_in (peer
, afi
, safi
);
4537 else if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
4538 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
4539 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
4544 /* neighbor weight. */
4546 peer_weight_set (struct peer
*peer
, afi_t afi
, safi_t safi
, u_int16_t weight
)
4548 struct peer_group
*group
;
4549 struct listnode
*node
, *nnode
;
4551 if (peer
->weight
[afi
][safi
] != weight
)
4553 peer
->weight
[afi
][safi
] = weight
;
4554 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4555 peer_on_policy_change (peer
, afi
, safi
, 0);
4558 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4561 /* peer-group member updates. */
4562 group
= peer
->group
;
4563 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4565 if (peer
->weight
[afi
][safi
] != weight
)
4567 peer
->weight
[afi
][safi
] = weight
;
4568 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
);
4569 peer_on_policy_change (peer
, afi
, safi
, 0);
4576 peer_weight_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4578 struct peer_group
*group
;
4579 struct listnode
*node
, *nnode
;
4581 /* not the peer-group itself but a peer in a peer-group */
4582 if (peer_group_active(peer
))
4584 group
= peer
->group
;
4586 /* inherit weight from the peer-group */
4587 if (CHECK_FLAG (group
->conf
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4589 peer
->weight
[afi
][safi
] = group
->conf
->weight
[afi
][safi
];
4590 peer_af_flag_set (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4591 peer_on_policy_change (peer
, afi
, safi
, 0);
4595 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4597 peer
->weight
[afi
][safi
] = 0;
4598 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4599 peer_on_policy_change (peer
, afi
, safi
, 0);
4606 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4608 peer
->weight
[afi
][safi
] = 0;
4609 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4610 peer_on_policy_change (peer
, afi
, safi
, 0);
4613 /* peer-group member updates. */
4614 group
= peer
->group
;
4618 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4620 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_WEIGHT
))
4622 peer
->weight
[afi
][safi
] = 0;
4623 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_WEIGHT
);
4624 peer_on_policy_change (peer
, afi
, safi
, 0);
4633 peer_timers_set (struct peer
*peer
, u_int32_t keepalive
, u_int32_t holdtime
)
4635 struct peer_group
*group
;
4636 struct listnode
*node
, *nnode
;
4638 /* keepalive value check. */
4639 if (keepalive
> 65535)
4640 return BGP_ERR_INVALID_VALUE
;
4642 /* Holdtime value check. */
4643 if (holdtime
> 65535)
4644 return BGP_ERR_INVALID_VALUE
;
4646 /* Holdtime value must be either 0 or greater than 3. */
4647 if (holdtime
< 3 && holdtime
!= 0)
4648 return BGP_ERR_INVALID_VALUE
;
4650 /* Set value to the configuration. */
4651 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4652 peer
->holdtime
= holdtime
;
4653 peer
->keepalive
= (keepalive
< holdtime
/ 3 ? keepalive
: holdtime
/ 3);
4655 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4658 /* peer-group member updates. */
4659 group
= peer
->group
;
4660 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4662 SET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4663 peer
->holdtime
= group
->conf
->holdtime
;
4664 peer
->keepalive
= group
->conf
->keepalive
;
4670 peer_timers_unset (struct peer
*peer
)
4672 struct peer_group
*group
;
4673 struct listnode
*node
, *nnode
;
4675 /* Clear configuration. */
4676 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4677 peer
->keepalive
= 0;
4680 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4683 /* peer-group member updates. */
4684 group
= peer
->group
;
4685 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4687 UNSET_FLAG (peer
->config
, PEER_CONFIG_TIMER
);
4689 peer
->keepalive
= 0;
4696 peer_timers_connect_set (struct peer
*peer
, u_int32_t connect
)
4698 struct peer_group
*group
;
4699 struct listnode
*node
, *nnode
;
4701 if (connect
> 65535)
4702 return BGP_ERR_INVALID_VALUE
;
4704 /* Set value to the configuration. */
4705 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4706 peer
->connect
= connect
;
4708 /* Set value to timer setting. */
4709 peer
->v_connect
= connect
;
4711 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4714 /* peer-group member updates. */
4715 group
= peer
->group
;
4716 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4718 SET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4719 peer
->connect
= connect
;
4720 peer
->v_connect
= connect
;
4726 peer_timers_connect_unset (struct peer
*peer
)
4728 struct peer_group
*group
;
4729 struct listnode
*node
, *nnode
;
4731 /* Clear configuration. */
4732 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4735 /* Set timer setting to default value. */
4736 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4738 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4741 /* peer-group member updates. */
4742 group
= peer
->group
;
4743 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4745 UNSET_FLAG (peer
->config
, PEER_CONFIG_CONNECT
);
4747 peer
->v_connect
= BGP_DEFAULT_CONNECT_RETRY
;
4753 peer_advertise_interval_set (struct peer
*peer
, u_int32_t routeadv
)
4755 struct peer_group
*group
;
4756 struct listnode
*node
, *nnode
;
4759 return BGP_ERR_INVALID_VALUE
;
4761 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4762 peer
->routeadv
= routeadv
;
4763 peer
->v_routeadv
= routeadv
;
4765 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4766 update_group_adjust_peer_afs (peer
);
4767 if (peer
->status
== Established
)
4768 bgp_announce_route_all (peer
);
4772 /* peer-group member updates. */
4773 group
= peer
->group
;
4774 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4776 SET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4777 peer
->routeadv
= routeadv
;
4778 peer
->v_routeadv
= routeadv
;
4779 update_group_adjust_peer_afs (peer
);
4780 if (peer
->status
== Established
)
4781 bgp_announce_route_all (peer
);
4788 peer_advertise_interval_unset (struct peer
*peer
)
4790 struct peer_group
*group
;
4791 struct listnode
*node
, *nnode
;
4793 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4796 if (peer
->sort
== BGP_PEER_IBGP
)
4797 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4799 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4801 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
)) {
4802 update_group_adjust_peer_afs (peer
);
4803 if (peer
->status
== Established
)
4804 bgp_announce_route_all (peer
);
4808 /* peer-group member updates. */
4809 group
= peer
->group
;
4810 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4812 UNSET_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
);
4815 if (peer
->sort
== BGP_PEER_IBGP
)
4816 peer
->v_routeadv
= BGP_DEFAULT_IBGP_ROUTEADV
;
4818 peer
->v_routeadv
= BGP_DEFAULT_EBGP_ROUTEADV
;
4820 update_group_adjust_peer_afs (peer
);
4821 if (peer
->status
== Established
)
4822 bgp_announce_route_all (peer
);
4828 /* neighbor interface */
4830 peer_interface_set (struct peer
*peer
, const char *str
)
4833 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4834 peer
->ifname
= XSTRDUP(MTYPE_BGP_PEER_IFNAME
, str
);
4838 peer_interface_unset (struct peer
*peer
)
4841 XFREE(MTYPE_BGP_PEER_IFNAME
, peer
->ifname
);
4842 peer
->ifname
= NULL
;
4847 peer_allowas_in_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int allow_num
)
4849 struct peer_group
*group
;
4850 struct listnode
*node
, *nnode
;
4852 if (allow_num
< 1 || allow_num
> 10)
4853 return BGP_ERR_INVALID_VALUE
;
4855 if (peer
->allowas_in
[afi
][safi
] != allow_num
)
4857 peer
->allowas_in
[afi
][safi
] = allow_num
;
4858 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
4859 peer_on_policy_change (peer
, afi
, safi
, 0);
4862 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4865 group
= peer
->group
;
4866 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4868 if (peer
->allowas_in
[afi
][safi
] != allow_num
)
4870 peer
->allowas_in
[afi
][safi
] = allow_num
;
4871 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
);
4872 peer_on_policy_change (peer
, afi
, safi
, 0);
4880 peer_allowas_in_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
4882 struct peer_group
*group
;
4883 struct listnode
*node
, *nnode
;
4885 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
4887 peer
->allowas_in
[afi
][safi
] = 0;
4888 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4889 peer_on_policy_change (peer
, afi
, safi
, 0);
4892 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4895 group
= peer
->group
;
4896 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4898 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_ALLOWAS_IN
))
4900 peer
->allowas_in
[afi
][safi
] = 0;
4901 peer_af_flag_unset (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
);
4902 peer_on_policy_change (peer
, afi
, safi
, 0);
4909 peer_local_as_set (struct peer
*peer
, as_t as
, int no_prepend
, int replace_as
)
4911 struct bgp
*bgp
= peer
->bgp
;
4912 struct peer_group
*group
;
4913 struct listnode
*node
, *nnode
;
4915 if (peer_sort (peer
) != BGP_PEER_EBGP
4916 && peer_sort (peer
) != BGP_PEER_INTERNAL
)
4917 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP
;
4920 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS
;
4923 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS
;
4925 if (peer
->change_local_as
== as
&&
4926 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && no_prepend
)
4927 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) && ! no_prepend
)) &&
4928 ((CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && replace_as
)
4929 || (! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) && ! replace_as
)))
4932 peer
->change_local_as
= as
;
4934 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
4936 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
4939 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
4941 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
4943 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4945 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4947 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
4948 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4949 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4952 bgp_session_reset(peer
);
4956 group
= peer
->group
;
4957 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
4959 peer
->change_local_as
= as
;
4961 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
4963 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
4966 SET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
4968 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
4970 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
4972 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
4973 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
4974 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
4977 BGP_EVENT_ADD (peer
, BGP_Stop
);
4984 peer_local_as_unset (struct peer
*peer
)
4986 struct peer_group
*group
;
4987 struct listnode
*node
, *nnode
;
4989 if (! peer
->change_local_as
)
4992 peer
->change_local_as
= 0;
4993 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
4994 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
4996 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
4998 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5000 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5001 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5002 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5005 BGP_EVENT_ADD (peer
, BGP_Stop
);
5010 group
= peer
->group
;
5011 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5013 peer
->change_local_as
= 0;
5014 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
);
5015 UNSET_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
);
5017 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5019 peer
->last_reset
= PEER_DOWN_LOCAL_AS_CHANGE
;
5020 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
5021 BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5024 bgp_session_reset(peer
);
5029 /* Set password for authenticating with the peer. */
5031 peer_password_set (struct peer
*peer
, const char *password
)
5033 struct listnode
*nn
, *nnode
;
5034 int len
= password
? strlen(password
) : 0;
5035 int ret
= BGP_SUCCESS
;
5037 if ((len
< PEER_PASSWORD_MINLEN
) || (len
> PEER_PASSWORD_MAXLEN
))
5038 return BGP_ERR_INVALID_VALUE
;
5040 if (peer
->password
&& strcmp (peer
->password
, password
) == 0
5041 && ! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5045 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5047 peer
->password
= XSTRDUP (MTYPE_PEER_PASSWORD
, password
);
5049 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5051 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5052 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5054 bgp_session_reset(peer
);
5056 if (BGP_PEER_SU_UNSPEC(peer
))
5059 return (bgp_md5_set (peer
) >= 0) ? BGP_SUCCESS
: BGP_ERR_TCPSIG_FAILED
;
5062 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5064 if (peer
->password
&& strcmp (peer
->password
, password
) == 0)
5068 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5070 peer
->password
= XSTRDUP(MTYPE_PEER_PASSWORD
, password
);
5072 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5073 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5075 bgp_session_reset(peer
);
5077 if (! BGP_PEER_SU_UNSPEC(peer
))
5079 if (bgp_md5_set (peer
) < 0)
5080 ret
= BGP_ERR_TCPSIG_FAILED
;
5088 peer_password_unset (struct peer
*peer
)
5090 struct listnode
*nn
, *nnode
;
5093 && !CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5096 if (!CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5098 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5099 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5101 bgp_session_reset(peer
);
5104 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5106 peer
->password
= NULL
;
5108 if (! BGP_PEER_SU_UNSPEC(peer
))
5109 bgp_md5_unset (peer
);
5114 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5115 peer
->password
= NULL
;
5117 for (ALL_LIST_ELEMENTS (peer
->group
->peer
, nn
, nnode
, peer
))
5119 if (!peer
->password
)
5122 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
5123 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
, BGP_NOTIFY_CEASE_CONFIG_CHANGE
);
5125 bgp_session_reset(peer
);
5127 XFREE (MTYPE_PEER_PASSWORD
, peer
->password
);
5128 peer
->password
= NULL
;
5130 if (! BGP_PEER_SU_UNSPEC(peer
))
5131 bgp_md5_unset (peer
);
5138 /* Set distribute list to the peer. */
5140 peer_distribute_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5143 struct bgp_filter
*filter
;
5144 struct peer_group
*group
;
5145 struct listnode
*node
, *nnode
;
5147 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5148 return BGP_ERR_INVALID_VALUE
;
5150 filter
= &peer
->filter
[afi
][safi
];
5152 if (filter
->plist
[direct
].name
)
5153 return BGP_ERR_PEER_FILTER_CONFLICT
;
5155 if (filter
->dlist
[direct
].name
)
5156 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5157 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5158 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5160 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5162 peer_on_policy_change(peer
, afi
, safi
,
5163 (direct
== FILTER_OUT
) ? 1 : 0);
5167 group
= peer
->group
;
5168 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5170 filter
= &peer
->filter
[afi
][safi
];
5172 if (filter
->dlist
[direct
].name
)
5173 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5174 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5175 filter
->dlist
[direct
].alist
= access_list_lookup (afi
, name
);
5176 peer_on_policy_change(peer
, afi
, safi
,
5177 (direct
== FILTER_OUT
) ? 1 : 0);
5184 peer_distribute_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5186 struct bgp_filter
*filter
;
5187 struct bgp_filter
*gfilter
;
5188 struct peer_group
*group
;
5189 struct listnode
*node
, *nnode
;
5191 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5192 return BGP_ERR_INVALID_VALUE
;
5194 filter
= &peer
->filter
[afi
][safi
];
5196 /* apply peer-group filter */
5197 if (peer_group_active(peer
))
5199 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5201 if (gfilter
->dlist
[direct
].name
)
5203 if (filter
->dlist
[direct
].name
)
5204 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5205 filter
->dlist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->dlist
[direct
].name
);
5206 filter
->dlist
[direct
].alist
= gfilter
->dlist
[direct
].alist
;
5207 peer_on_policy_change(peer
, afi
, safi
,
5208 (direct
== FILTER_OUT
) ? 1 : 0);
5213 if (filter
->dlist
[direct
].name
)
5214 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5215 filter
->dlist
[direct
].name
= NULL
;
5216 filter
->dlist
[direct
].alist
= NULL
;
5218 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5220 peer_on_policy_change(peer
, afi
, safi
,
5221 (direct
== FILTER_OUT
) ? 1 : 0);
5225 group
= peer
->group
;
5226 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5228 filter
= &peer
->filter
[afi
][safi
];
5230 if (filter
->dlist
[direct
].name
)
5231 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->dlist
[direct
].name
);
5232 filter
->dlist
[direct
].name
= NULL
;
5233 filter
->dlist
[direct
].alist
= NULL
;
5234 peer_on_policy_change(peer
, afi
, safi
,
5235 (direct
== FILTER_OUT
) ? 1 : 0);
5241 /* Update distribute list. */
5243 peer_distribute_update (struct access_list
*access
)
5248 struct listnode
*mnode
, *mnnode
;
5249 struct listnode
*node
, *nnode
;
5252 struct peer_group
*group
;
5253 struct bgp_filter
*filter
;
5255 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5258 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, access
->name
,
5260 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5262 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5263 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5265 filter
= &peer
->filter
[afi
][safi
];
5267 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5269 if (filter
->dlist
[direct
].name
)
5270 filter
->dlist
[direct
].alist
=
5271 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5273 filter
->dlist
[direct
].alist
= NULL
;
5277 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5279 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5280 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5282 filter
= &group
->conf
->filter
[afi
][safi
];
5284 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5286 if (filter
->dlist
[direct
].name
)
5287 filter
->dlist
[direct
].alist
=
5288 access_list_lookup (afi
, filter
->dlist
[direct
].name
);
5290 filter
->dlist
[direct
].alist
= NULL
;
5295 vnc_prefix_list_update(bgp
);
5300 /* Set prefix list to the peer. */
5302 peer_prefix_list_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5305 struct bgp_filter
*filter
;
5306 struct peer_group
*group
;
5307 struct listnode
*node
, *nnode
;
5309 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5310 return BGP_ERR_INVALID_VALUE
;
5312 filter
= &peer
->filter
[afi
][safi
];
5314 if (filter
->dlist
[direct
].name
)
5315 return BGP_ERR_PEER_FILTER_CONFLICT
;
5317 if (filter
->plist
[direct
].name
)
5318 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5319 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5320 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5322 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5324 peer_on_policy_change(peer
, afi
, safi
,
5325 (direct
== FILTER_OUT
) ? 1 : 0);
5329 group
= peer
->group
;
5330 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5332 filter
= &peer
->filter
[afi
][safi
];
5334 if (filter
->plist
[direct
].name
)
5335 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5336 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5337 filter
->plist
[direct
].plist
= prefix_list_lookup (afi
, name
);
5338 peer_on_policy_change(peer
, afi
, safi
,
5339 (direct
== FILTER_OUT
) ? 1 : 0);
5345 peer_prefix_list_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5347 struct bgp_filter
*filter
;
5348 struct bgp_filter
*gfilter
;
5349 struct peer_group
*group
;
5350 struct listnode
*node
, *nnode
;
5352 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5353 return BGP_ERR_INVALID_VALUE
;
5355 filter
= &peer
->filter
[afi
][safi
];
5357 /* apply peer-group filter */
5358 if (peer_group_active(peer
))
5360 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5362 if (gfilter
->plist
[direct
].name
)
5364 if (filter
->plist
[direct
].name
)
5365 XSTRDUP(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5366 filter
->plist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->plist
[direct
].name
);
5367 filter
->plist
[direct
].plist
= gfilter
->plist
[direct
].plist
;
5368 peer_on_policy_change(peer
, afi
, safi
,
5369 (direct
== FILTER_OUT
) ? 1 : 0);
5374 if (filter
->plist
[direct
].name
)
5375 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5376 filter
->plist
[direct
].name
= NULL
;
5377 filter
->plist
[direct
].plist
= NULL
;
5379 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5381 peer_on_policy_change(peer
, afi
, safi
,
5382 (direct
== FILTER_OUT
) ? 1 : 0);
5386 group
= peer
->group
;
5387 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5389 filter
= &peer
->filter
[afi
][safi
];
5391 if (filter
->plist
[direct
].name
)
5392 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->plist
[direct
].name
);
5393 filter
->plist
[direct
].name
= NULL
;
5394 filter
->plist
[direct
].plist
= NULL
;
5395 peer_on_policy_change(peer
, afi
, safi
,
5396 (direct
== FILTER_OUT
) ? 1 : 0);
5402 /* Update prefix-list list. */
5404 peer_prefix_list_update (struct prefix_list
*plist
)
5406 struct listnode
*mnode
, *mnnode
;
5407 struct listnode
*node
, *nnode
;
5410 struct peer_group
*group
;
5411 struct bgp_filter
*filter
;
5416 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5420 * Update the prefix-list on update groups.
5422 update_group_policy_update(bgp
, BGP_POLICY_PREFIX_LIST
,
5423 plist
? prefix_list_name(plist
) : NULL
, 0, 0);
5425 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5427 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5428 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5430 filter
= &peer
->filter
[afi
][safi
];
5432 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5434 if (filter
->plist
[direct
].name
)
5435 filter
->plist
[direct
].plist
=
5436 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5438 filter
->plist
[direct
].plist
= NULL
;
5442 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5444 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5445 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5447 filter
= &group
->conf
->filter
[afi
][safi
];
5449 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5451 if (filter
->plist
[direct
].name
)
5452 filter
->plist
[direct
].plist
=
5453 prefix_list_lookup (afi
, filter
->plist
[direct
].name
);
5455 filter
->plist
[direct
].plist
= NULL
;
5463 peer_aslist_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5466 struct bgp_filter
*filter
;
5467 struct peer_group
*group
;
5468 struct listnode
*node
, *nnode
;
5470 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5471 return BGP_ERR_INVALID_VALUE
;
5473 filter
= &peer
->filter
[afi
][safi
];
5475 if (filter
->aslist
[direct
].name
)
5476 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5477 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5478 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5480 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5482 peer_on_policy_change(peer
, afi
, safi
,
5483 (direct
== FILTER_OUT
) ? 1 : 0);
5487 group
= peer
->group
;
5488 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5490 filter
= &peer
->filter
[afi
][safi
];
5492 if (filter
->aslist
[direct
].name
)
5493 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5494 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5495 filter
->aslist
[direct
].aslist
= as_list_lookup (name
);
5496 peer_on_policy_change(peer
, afi
, safi
,
5497 (direct
== FILTER_OUT
) ? 1 : 0);
5503 peer_aslist_unset (struct peer
*peer
,afi_t afi
, safi_t safi
, int direct
)
5505 struct bgp_filter
*filter
;
5506 struct bgp_filter
*gfilter
;
5507 struct peer_group
*group
;
5508 struct listnode
*node
, *nnode
;
5510 if (direct
!= FILTER_IN
&& direct
!= FILTER_OUT
)
5511 return BGP_ERR_INVALID_VALUE
;
5513 filter
= &peer
->filter
[afi
][safi
];
5515 /* apply peer-group filter */
5516 if (peer_group_active(peer
))
5518 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5520 if (gfilter
->aslist
[direct
].name
)
5522 if (filter
->aslist
[direct
].name
)
5523 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5524 filter
->aslist
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->aslist
[direct
].name
);
5525 filter
->aslist
[direct
].aslist
= gfilter
->aslist
[direct
].aslist
;
5526 peer_on_policy_change(peer
, afi
, safi
,
5527 (direct
== FILTER_OUT
) ? 1 : 0);
5532 if (filter
->aslist
[direct
].name
)
5533 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5534 filter
->aslist
[direct
].name
= NULL
;
5535 filter
->aslist
[direct
].aslist
= NULL
;
5537 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5539 peer_on_policy_change(peer
, afi
, safi
,
5540 (direct
== FILTER_OUT
) ? 1 : 0);
5544 group
= peer
->group
;
5545 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5547 filter
= &peer
->filter
[afi
][safi
];
5549 if (filter
->aslist
[direct
].name
)
5550 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->aslist
[direct
].name
);
5551 filter
->aslist
[direct
].name
= NULL
;
5552 filter
->aslist
[direct
].aslist
= NULL
;
5553 peer_on_policy_change(peer
, afi
, safi
,
5554 (direct
== FILTER_OUT
) ? 1 : 0);
5561 peer_aslist_update (const char *aslist_name
)
5566 struct listnode
*mnode
, *mnnode
;
5567 struct listnode
*node
, *nnode
;
5570 struct peer_group
*group
;
5571 struct bgp_filter
*filter
;
5573 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
5575 update_group_policy_update(bgp
, BGP_POLICY_FILTER_LIST
, aslist_name
,
5578 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
5580 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5581 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5583 filter
= &peer
->filter
[afi
][safi
];
5585 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5587 if (filter
->aslist
[direct
].name
)
5588 filter
->aslist
[direct
].aslist
=
5589 as_list_lookup (filter
->aslist
[direct
].name
);
5591 filter
->aslist
[direct
].aslist
= NULL
;
5595 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
5597 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
5598 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++)
5600 filter
= &group
->conf
->filter
[afi
][safi
];
5602 for (direct
= FILTER_IN
; direct
< FILTER_MAX
; direct
++)
5604 if (filter
->aslist
[direct
].name
)
5605 filter
->aslist
[direct
].aslist
=
5606 as_list_lookup (filter
->aslist
[direct
].name
);
5608 filter
->aslist
[direct
].aslist
= NULL
;
5616 peer_aslist_add (char *aslist_name
)
5618 peer_aslist_update (aslist_name
);
5619 route_map_notify_dependencies((char *)aslist_name
, RMAP_EVENT_ASLIST_ADDED
);
5623 peer_aslist_del (const char *aslist_name
)
5625 peer_aslist_update (aslist_name
);
5626 route_map_notify_dependencies(aslist_name
, RMAP_EVENT_ASLIST_DELETED
);
5631 peer_route_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
,
5634 struct bgp_filter
*filter
;
5635 struct peer_group
*group
;
5636 struct listnode
*node
, *nnode
;
5638 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5639 return BGP_ERR_INVALID_VALUE
;
5641 filter
= &peer
->filter
[afi
][safi
];
5643 if (filter
->map
[direct
].name
)
5644 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5646 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5647 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5649 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5651 peer_on_policy_change(peer
, afi
, safi
,
5652 (direct
== RMAP_OUT
) ? 1 : 0);
5656 group
= peer
->group
;
5657 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5659 filter
= &peer
->filter
[afi
][safi
];
5661 if (filter
->map
[direct
].name
)
5662 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5663 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5664 filter
->map
[direct
].map
= route_map_lookup_by_name (name
);
5665 peer_on_policy_change(peer
, afi
, safi
,
5666 (direct
== RMAP_OUT
) ? 1 : 0);
5671 /* Unset route-map from the peer. */
5673 peer_route_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
, int direct
)
5675 struct bgp_filter
*filter
;
5676 struct bgp_filter
*gfilter
;
5677 struct peer_group
*group
;
5678 struct listnode
*node
, *nnode
;
5680 if (direct
!= RMAP_IN
&& direct
!= RMAP_OUT
)
5681 return BGP_ERR_INVALID_VALUE
;
5683 filter
= &peer
->filter
[afi
][safi
];
5685 /* apply peer-group filter */
5686 if (peer_group_active(peer
))
5688 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
5690 if (gfilter
->map
[direct
].name
)
5692 if (filter
->map
[direct
].name
)
5693 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5694 filter
->map
[direct
].name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, gfilter
->map
[direct
].name
);
5695 filter
->map
[direct
].map
= gfilter
->map
[direct
].map
;
5696 peer_on_policy_change(peer
, afi
, safi
,
5697 (direct
== RMAP_OUT
) ? 1 : 0);
5702 if (filter
->map
[direct
].name
)
5703 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5704 filter
->map
[direct
].name
= NULL
;
5705 filter
->map
[direct
].map
= NULL
;
5707 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5709 peer_on_policy_change(peer
, afi
, safi
,
5710 (direct
== RMAP_OUT
) ? 1 : 0);
5714 group
= peer
->group
;
5715 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5717 filter
= &peer
->filter
[afi
][safi
];
5719 if (filter
->map
[direct
].name
)
5720 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->map
[direct
].name
);
5721 filter
->map
[direct
].name
= NULL
;
5722 filter
->map
[direct
].map
= NULL
;
5723 peer_on_policy_change(peer
, afi
, safi
,
5724 (direct
== RMAP_OUT
) ? 1 : 0);
5729 /* Set unsuppress-map to the peer. */
5731 peer_unsuppress_map_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5734 struct bgp_filter
*filter
;
5735 struct peer_group
*group
;
5736 struct listnode
*node
, *nnode
;
5738 filter
= &peer
->filter
[afi
][safi
];
5740 if (filter
->usmap
.name
)
5741 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5743 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5744 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5746 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5748 peer_on_policy_change(peer
, afi
, safi
, 1);
5752 group
= peer
->group
;
5753 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5755 filter
= &peer
->filter
[afi
][safi
];
5757 if (filter
->usmap
.name
)
5758 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5759 filter
->usmap
.name
= XSTRDUP(MTYPE_BGP_FILTER_NAME
, name
);
5760 filter
->usmap
.map
= route_map_lookup_by_name (name
);
5761 peer_on_policy_change(peer
, afi
, safi
, 1);
5766 /* Unset route-map from the peer. */
5768 peer_unsuppress_map_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5770 struct bgp_filter
*filter
;
5771 struct peer_group
*group
;
5772 struct listnode
*node
, *nnode
;
5774 filter
= &peer
->filter
[afi
][safi
];
5776 if (filter
->usmap
.name
)
5777 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5778 filter
->usmap
.name
= NULL
;
5779 filter
->usmap
.map
= NULL
;
5781 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5783 peer_on_policy_change(peer
, afi
, safi
, 1);
5787 group
= peer
->group
;
5788 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5790 filter
= &peer
->filter
[afi
][safi
];
5792 if (filter
->usmap
.name
)
5793 XFREE(MTYPE_BGP_FILTER_NAME
, filter
->usmap
.name
);
5794 filter
->usmap
.name
= NULL
;
5795 filter
->usmap
.map
= NULL
;
5796 peer_on_policy_change(peer
, afi
, safi
, 1);
5802 peer_maximum_prefix_set (struct peer
*peer
, afi_t afi
, safi_t safi
,
5803 u_int32_t max
, u_char threshold
,
5804 int warning
, u_int16_t restart
)
5806 struct peer_group
*group
;
5807 struct listnode
*node
, *nnode
;
5809 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5810 peer
->pmax
[afi
][safi
] = max
;
5811 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5812 peer
->pmax_restart
[afi
][safi
] = restart
;
5814 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5816 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5818 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5820 group
= peer
->group
;
5821 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5823 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5824 peer
->pmax
[afi
][safi
] = max
;
5825 peer
->pmax_threshold
[afi
][safi
] = threshold
;
5826 peer
->pmax_restart
[afi
][safi
] = restart
;
5828 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5830 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5832 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5833 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
5838 if ((peer
->status
== Established
) && (peer
->afc
[afi
][safi
]))
5839 bgp_maximum_prefix_overflow (peer
, afi
, safi
, 1);
5846 peer_maximum_prefix_unset (struct peer
*peer
, afi_t afi
, safi_t safi
)
5848 struct peer_group
*group
;
5849 struct listnode
*node
, *nnode
;
5851 /* apply peer-group config */
5852 if (peer_group_active(peer
))
5854 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
5855 PEER_FLAG_MAX_PREFIX
))
5856 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5858 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5860 if (CHECK_FLAG (peer
->group
->conf
->af_flags
[afi
][safi
],
5861 PEER_FLAG_MAX_PREFIX_WARNING
))
5862 SET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5864 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5866 peer
->pmax
[afi
][safi
] = peer
->group
->conf
->pmax
[afi
][safi
];
5867 peer
->pmax_threshold
[afi
][safi
] = peer
->group
->conf
->pmax_threshold
[afi
][safi
];
5868 peer
->pmax_restart
[afi
][safi
] = peer
->group
->conf
->pmax_restart
[afi
][safi
];
5872 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5873 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5874 peer
->pmax
[afi
][safi
] = 0;
5875 peer
->pmax_threshold
[afi
][safi
] = 0;
5876 peer
->pmax_restart
[afi
][safi
] = 0;
5878 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5881 group
= peer
->group
;
5882 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5884 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
);
5885 UNSET_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
);
5886 peer
->pmax
[afi
][safi
] = 0;
5887 peer
->pmax_threshold
[afi
][safi
] = 0;
5888 peer
->pmax_restart
[afi
][safi
] = 0;
5893 int is_ebgp_multihop_configured (struct peer
*peer
)
5895 struct peer_group
*group
;
5896 struct listnode
*node
, *nnode
;
5899 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5901 group
= peer
->group
;
5902 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
5903 (group
->conf
->ttl
!= 1))
5906 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer1
))
5908 if ((peer_sort (peer1
) != BGP_PEER_IBGP
) &&
5915 if ((peer_sort(peer
) != BGP_PEER_IBGP
) &&
5922 /* Set # of hops between us and BGP peer. */
5924 peer_ttl_security_hops_set (struct peer
*peer
, int gtsm_hops
)
5926 struct peer_group
*group
;
5927 struct listnode
*node
, *nnode
;
5930 zlog_debug ("peer_ttl_security_hops_set: set gtsm_hops to %d for %s", gtsm_hops
, peer
->host
);
5932 /* We cannot configure ttl-security hops when ebgp-multihop is already
5933 set. For non peer-groups, the check is simple. For peer-groups, it's
5934 slightly messy, because we need to check both the peer-group structure
5935 and all peer-group members for any trace of ebgp-multihop configuration
5936 before actually applying the ttl-security rules. Cisco really made a
5937 mess of this configuration parameter, and OpenBGPD got it right.
5940 if ((peer
->gtsm_hops
== 0) && (peer
->sort
!= BGP_PEER_IBGP
))
5942 if (is_ebgp_multihop_configured (peer
))
5943 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK
;
5945 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5947 peer
->gtsm_hops
= gtsm_hops
;
5949 /* Calling ebgp multihop also resets the session.
5950 * On restart, NHT will get setup correctly as will the
5951 * min & max ttls on the socket. The return value is
5954 ret
= peer_ebgp_multihop_set (peer
, MAXTTL
);
5961 group
= peer
->group
;
5962 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5964 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
5966 /* Calling ebgp multihop also resets the session.
5967 * On restart, NHT will get setup correctly as will the
5968 * min & max ttls on the socket. The return value is
5971 ret
= peer_ebgp_multihop_set (peer
, MAXTTL
);
5977 /* Post the first gtsm setup or if its ibgp, maxttl setting isn't
5978 * necessary, just set the minttl.
5980 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
5982 peer
->gtsm_hops
= gtsm_hops
;
5985 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
5986 MAXTTL
+ 1 - gtsm_hops
);
5987 if ((peer
->status
< Established
) && peer
->doppelganger
&&
5988 (peer
->doppelganger
->fd
>= 0))
5989 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
5990 MAXTTL
+ 1 - gtsm_hops
);
5994 group
= peer
->group
;
5995 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
5997 peer
->gtsm_hops
= group
->conf
->gtsm_hops
;
5999 /* Change setting of existing peer
6000 * established then change value (may break connectivity)
6001 * not established yet (teardown session and restart)
6002 * no session then do nothing (will get handled by next connection)
6004 if (peer
->fd
>= 0 && peer
->gtsm_hops
!= 0)
6005 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
,
6006 MAXTTL
+ 1 - peer
->gtsm_hops
);
6007 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6008 (peer
->doppelganger
->fd
>= 0))
6009 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->doppelganger
->fd
,
6010 MAXTTL
+ 1 - gtsm_hops
);
6020 peer_ttl_security_hops_unset (struct peer
*peer
)
6022 struct peer_group
*group
;
6023 struct listnode
*node
, *nnode
;
6026 zlog_debug ("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s", peer
->host
);
6028 /* if a peer-group member, then reset to peer-group default rather than 0 */
6029 if (peer_group_active (peer
))
6030 peer
->gtsm_hops
= peer
->group
->conf
->gtsm_hops
;
6032 peer
->gtsm_hops
= 0;
6034 if (! CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6036 /* Invoking ebgp_multihop_set will set the TTL back to the original
6037 * value as well as restting the NHT and such. The session is reset.
6039 if (peer
->sort
== BGP_PEER_EBGP
)
6040 ret
= peer_ebgp_multihop_unset (peer
);
6044 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6046 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6047 (peer
->doppelganger
->fd
>= 0))
6048 sockopt_minttl (peer
->su
.sa
.sa_family
,
6049 peer
->doppelganger
->fd
, 0);
6054 group
= peer
->group
;
6055 for (ALL_LIST_ELEMENTS (group
->peer
, node
, nnode
, peer
))
6057 peer
->gtsm_hops
= 0;
6058 if (peer
->sort
== BGP_PEER_EBGP
)
6059 ret
= peer_ebgp_multihop_unset (peer
);
6063 sockopt_minttl (peer
->su
.sa
.sa_family
, peer
->fd
, 0);
6065 if ((peer
->status
< Established
) && peer
->doppelganger
&&
6066 (peer
->doppelganger
->fd
>= 0))
6067 sockopt_minttl (peer
->su
.sa
.sa_family
,
6068 peer
->doppelganger
->fd
, 0);
6077 * If peer clear is invoked in a loop for all peers on the BGP instance,
6078 * it may end up freeing the doppelganger, and if this was the next node
6079 * to the current node, we would end up accessing the freed next node.
6080 * Pass along additional parameter which can be updated if next node
6081 * is freed; only required when walking the peer list on BGP instance.
6084 peer_clear (struct peer
*peer
, struct listnode
**nnode
)
6086 if (! CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6088 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
))
6090 UNSET_FLAG (peer
->sflags
, PEER_STATUS_PREFIX_OVERFLOW
);
6091 if (peer
->t_pmax_restart
)
6093 BGP_TIMER_OFF (peer
->t_pmax_restart
);
6094 if (bgp_debug_neighbor_events(peer
))
6095 zlog_debug ("%s Maximum-prefix restart timer canceled",
6098 BGP_EVENT_ADD (peer
, BGP_Start
);
6102 peer
->v_start
= BGP_INIT_START_TIMER
;
6103 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer
->status
))
6104 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
6105 BGP_NOTIFY_CEASE_ADMIN_RESET
);
6107 bgp_session_reset_safe(peer
, nnode
);
6113 peer_clear_soft (struct peer
*peer
, afi_t afi
, safi_t safi
,
6114 enum bgp_clear_type stype
)
6116 struct peer_af
*paf
;
6118 if (peer
->status
!= Established
)
6121 if (! peer
->afc
[afi
][safi
])
6122 return BGP_ERR_AF_UNCONFIGURED
;
6124 peer
->rtt
= sockopt_tcp_rtt (peer
->fd
);
6126 if (stype
== BGP_CLEAR_SOFT_OUT
|| stype
== BGP_CLEAR_SOFT_BOTH
)
6128 /* Clear the "neighbor x.x.x.x default-originate" flag */
6129 paf
= peer_af_find (peer
, afi
, safi
);
6130 if (paf
&& paf
->subgroup
&&
6131 CHECK_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
6132 UNSET_FLAG (paf
->subgroup
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
6134 bgp_announce_route (peer
, afi
, safi
);
6137 if (stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6139 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_ADV
)
6140 && (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
)
6141 || CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_OLD_RCV
)))
6143 struct bgp_filter
*filter
= &peer
->filter
[afi
][safi
];
6146 if (CHECK_FLAG (peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_RM_RCV
))
6147 prefix_type
= ORF_TYPE_PREFIX
;
6149 prefix_type
= ORF_TYPE_PREFIX_OLD
;
6151 if (filter
->plist
[FILTER_IN
].plist
)
6153 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6154 bgp_route_refresh_send (peer
, afi
, safi
,
6155 prefix_type
, REFRESH_DEFER
, 1);
6156 bgp_route_refresh_send (peer
, afi
, safi
, prefix_type
,
6157 REFRESH_IMMEDIATE
, 0);
6161 if (CHECK_FLAG (peer
->af_sflags
[afi
][safi
], PEER_STATUS_ORF_PREFIX_SEND
))
6162 bgp_route_refresh_send (peer
, afi
, safi
,
6163 prefix_type
, REFRESH_IMMEDIATE
, 1);
6165 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6171 if (stype
== BGP_CLEAR_SOFT_IN
|| stype
== BGP_CLEAR_SOFT_BOTH
6172 || stype
== BGP_CLEAR_SOFT_IN_ORF_PREFIX
)
6174 /* If neighbor has soft reconfiguration inbound flag.
6175 Use Adj-RIB-In database. */
6176 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SOFT_RECONFIG
))
6177 bgp_soft_reconfig_in (peer
, afi
, safi
);
6180 /* If neighbor has route refresh capability, send route refresh
6181 message to the peer. */
6182 if (CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_OLD_RCV
)
6183 || CHECK_FLAG (peer
->cap
, PEER_CAP_REFRESH_NEW_RCV
))
6184 bgp_route_refresh_send (peer
, afi
, safi
, 0, 0, 0);
6186 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED
;
6192 /* Display peer uptime.*/
6193 /* XXX: why does this function return char * when it takes buffer? */
6195 peer_uptime (time_t uptime2
, char *buf
, size_t len
, u_char use_json
, json_object
*json
)
6200 /* Check buffer length. */
6201 if (len
< BGP_UPTIME_LEN
)
6205 zlog_warn ("peer_uptime (): buffer shortage %lu", (u_long
)len
);
6206 /* XXX: should return status instead of buf... */
6207 snprintf (buf
, len
, "<error> ");
6212 /* If there is no connection has been done before print `never'. */
6216 json_object_string_add(json
, "peerUptime", "never");
6218 snprintf (buf
, len
, "never");
6222 /* Get current time. */
6223 uptime1
= bgp_clock ();
6225 tm
= gmtime (&uptime1
);
6227 /* Making formatted timer strings. */
6228 #define ONE_DAY_SECOND 60*60*24
6229 #define ONE_WEEK_SECOND ONE_DAY_SECOND*7
6230 #define ONE_YEAR_SECOND ONE_DAY_SECOND*365
6234 unsigned long time_store
;
6235 unsigned long sec_msec
= 1000;
6236 unsigned long minute_msec
= sec_msec
* 60;
6237 unsigned long hour_msec
= minute_msec
* 60;
6238 unsigned long day_msec
= hour_msec
* 24;
6239 unsigned long year_msec
= day_msec
*365;
6242 year_msec
* tm
->tm_year
+
6243 day_msec
* tm
->tm_yday
+
6244 hour_msec
* tm
->tm_hour
+
6245 minute_msec
* tm
->tm_min
+
6246 sec_msec
* tm
->tm_sec
;
6247 json_object_int_add(json
, "peerUptimeMsec", time_store
);
6250 if (uptime1
< ONE_DAY_SECOND
)
6251 snprintf (buf
, len
, "%02d:%02d:%02d",
6252 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6253 else if (uptime1
< ONE_WEEK_SECOND
)
6254 snprintf (buf
, len
, "%dd%02dh%02dm",
6255 tm
->tm_yday
, tm
->tm_hour
, tm
->tm_min
);
6256 else if (uptime1
< ONE_YEAR_SECOND
)
6257 snprintf (buf
, len
, "%02dw%dd%02dh",
6258 tm
->tm_yday
/7, tm
->tm_yday
- ((tm
->tm_yday
/7) * 7), tm
->tm_hour
);
6260 snprintf (buf
, len
, "%02dy%02dw%dd",
6261 tm
->tm_year
- 70, tm
->tm_yday
/7,
6262 tm
->tm_yday
- ((tm
->tm_yday
/7) * 7));
6268 afi_header_vty_out (struct vty
*vty
, afi_t afi
, safi_t safi
,
6269 int *write
, const char *format
, ...)
6275 bgp_config_write_family_header (vty
, afi
, safi
, write
);
6277 if (vty_shell (vty
))
6279 va_start (args
, format
);
6280 vprintf (format
, args
);
6285 va_start (args
, format
);
6286 len
= vsnprintf (buf
, sizeof(buf
), format
, args
);
6289 buffer_put (vty
->obuf
, (u_char
*) buf
, len
);
6294 bgp_config_write_filter (struct vty
*vty
, struct peer
*peer
,
6295 afi_t afi
, safi_t safi
, int *write
)
6297 struct bgp_filter
*filter
;
6298 struct bgp_filter
*gfilter
= NULL
;
6301 int out
= FILTER_OUT
;
6304 filter
= &peer
->filter
[afi
][safi
];
6306 if (peer_group_active(peer
))
6307 gfilter
= &peer
->group
->conf
->filter
[afi
][safi
];
6309 /* distribute-list. */
6310 if (filter
->dlist
[in
].name
)
6311 if (! gfilter
|| ! gfilter
->dlist
[in
].name
6312 || strcmp (filter
->dlist
[in
].name
, gfilter
->dlist
[in
].name
) != 0)
6314 afi_header_vty_out (vty
, afi
, safi
, write
,
6315 " neighbor %s distribute-list %s in%s",
6316 addr
, filter
->dlist
[in
].name
, VTY_NEWLINE
);
6319 if (filter
->dlist
[out
].name
&& ! gfilter
)
6321 afi_header_vty_out (vty
, afi
, safi
, write
,
6322 " neighbor %s distribute-list %s out%s",
6323 addr
, filter
->dlist
[out
].name
, VTY_NEWLINE
);
6327 if (filter
->plist
[in
].name
)
6328 if (! gfilter
|| ! gfilter
->plist
[in
].name
6329 || strcmp (filter
->plist
[in
].name
, gfilter
->plist
[in
].name
) != 0)
6331 afi_header_vty_out (vty
, afi
, safi
, write
,
6332 " neighbor %s prefix-list %s in%s",
6333 addr
, filter
->plist
[in
].name
, VTY_NEWLINE
);
6336 if (filter
->plist
[out
].name
&& ! gfilter
)
6338 afi_header_vty_out (vty
, afi
, safi
, write
,
6339 " neighbor %s prefix-list %s out%s",
6340 addr
, filter
->plist
[out
].name
, VTY_NEWLINE
);
6344 if (filter
->map
[RMAP_IN
].name
)
6345 if (! gfilter
|| ! gfilter
->map
[RMAP_IN
].name
6346 || strcmp (filter
->map
[RMAP_IN
].name
, gfilter
->map
[RMAP_IN
].name
) != 0)
6348 afi_header_vty_out (vty
, afi
, safi
, write
,
6349 " neighbor %s route-map %s in%s",
6350 addr
, filter
->map
[RMAP_IN
].name
, VTY_NEWLINE
);
6353 if (filter
->map
[RMAP_OUT
].name
)
6354 if (! gfilter
|| ! gfilter
->map
[RMAP_OUT
].name
6355 || strcmp (filter
->map
[RMAP_OUT
].name
, gfilter
->map
[RMAP_OUT
].name
) != 0)
6357 afi_header_vty_out (vty
, afi
, safi
, write
,
6358 " neighbor %s route-map %s out%s",
6359 addr
, filter
->map
[RMAP_OUT
].name
, VTY_NEWLINE
);
6362 /* unsuppress-map */
6363 if (filter
->usmap
.name
&& ! gfilter
)
6365 afi_header_vty_out (vty
, afi
, safi
, write
,
6366 " neighbor %s unsuppress-map %s%s",
6367 addr
, filter
->usmap
.name
, VTY_NEWLINE
);
6371 if (filter
->aslist
[in
].name
)
6372 if (! gfilter
|| ! gfilter
->aslist
[in
].name
6373 || strcmp (filter
->aslist
[in
].name
, gfilter
->aslist
[in
].name
) != 0)
6375 afi_header_vty_out (vty
, afi
, safi
, write
,
6376 " neighbor %s filter-list %s in%s",
6377 addr
, filter
->aslist
[in
].name
, VTY_NEWLINE
);
6380 if (filter
->aslist
[out
].name
&& ! gfilter
)
6382 afi_header_vty_out (vty
, afi
, safi
, write
,
6383 " neighbor %s filter-list %s out%s",
6384 addr
, filter
->aslist
[out
].name
, VTY_NEWLINE
);
6388 /* BGP peer configuration display function. */
6390 bgp_config_write_peer_global (struct vty
*vty
, struct bgp
*bgp
,
6393 struct peer
*g_peer
= NULL
;
6394 char buf
[SU_ADDRSTRLEN
];
6396 int if_pg_printed
= FALSE
;
6397 int if_ras_printed
= FALSE
;
6399 /* Skip dynamic neighbors. */
6400 if (peer_dynamic_neighbor (peer
))
6404 addr
= peer
->conf_if
;
6408 /************************************
6409 ****** Global to the neighbor ******
6410 ************************************/
6413 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_IFPEER_V6ONLY
))
6414 vty_out (vty
, " neighbor %s interface v6only", addr
);
6416 vty_out (vty
, " neighbor %s interface", addr
);
6418 if (peer_group_active (peer
))
6420 vty_out (vty
, " peer-group %s", peer
->group
->name
);
6421 if_pg_printed
= TRUE
;
6423 else if (peer
->as_type
== AS_SPECIFIED
)
6425 vty_out (vty
, " remote-as %u", peer
->as
);
6426 if_ras_printed
= TRUE
;
6428 else if (peer
->as_type
== AS_INTERNAL
)
6430 vty_out (vty
, " remote-as internal");
6431 if_ras_printed
= TRUE
;
6433 else if (peer
->as_type
== AS_EXTERNAL
)
6435 vty_out (vty
, " remote-as external");
6436 if_ras_printed
= TRUE
;
6439 vty_out (vty
, "%s", VTY_NEWLINE
);
6442 /* remote-as and peer-group */
6443 /* peer is a member of a peer-group */
6444 if (peer_group_active (peer
))
6446 g_peer
= peer
->group
->conf
;
6448 if (g_peer
->as_type
== AS_UNSPECIFIED
&& !if_ras_printed
)
6450 if (peer
->as_type
== AS_SPECIFIED
)
6452 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6455 else if (peer
->as_type
== AS_INTERNAL
)
6457 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6459 else if (peer
->as_type
== AS_EXTERNAL
)
6461 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6465 /* For swpX peers we displayed the peer-group
6466 * via 'neighbor swpX interface peer-group WORD' */
6468 vty_out (vty
, " neighbor %s peer-group %s%s", addr
,
6469 peer
->group
->name
, VTY_NEWLINE
);
6472 /* peer is NOT a member of a peer-group */
6475 /* peer is a peer-group, declare the peer-group */
6476 if (CHECK_FLAG (peer
->sflags
, PEER_STATUS_GROUP
))
6478 vty_out (vty
, " neighbor %s peer-group%s", addr
,
6482 if (!if_ras_printed
)
6484 if (peer
->as_type
== AS_SPECIFIED
)
6486 vty_out (vty
, " neighbor %s remote-as %u%s", addr
, peer
->as
,
6489 else if (peer
->as_type
== AS_INTERNAL
)
6491 vty_out (vty
, " neighbor %s remote-as internal%s", addr
, VTY_NEWLINE
);
6493 else if (peer
->as_type
== AS_EXTERNAL
)
6495 vty_out (vty
, " neighbor %s remote-as external%s", addr
, VTY_NEWLINE
);
6501 if (peer
->change_local_as
)
6503 if (! peer_group_active (peer
)
6504 || peer
->change_local_as
!= g_peer
->change_local_as
6505 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) !=
6506 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
))
6507 || (CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) !=
6508 CHECK_FLAG (g_peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
)))
6510 vty_out (vty
, " neighbor %s local-as %u%s%s%s", addr
,
6511 peer
->change_local_as
,
6512 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
) ?
6514 CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) ?
6515 " replace-as" : "", VTY_NEWLINE
);
6522 vty_out (vty
, " neighbor %s description %s%s", addr
, peer
->desc
,
6527 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_SHUTDOWN
))
6529 if (! peer_group_active (peer
) ||
6530 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_SHUTDOWN
))
6532 vty_out (vty
, " neighbor %s shutdown%s", addr
, VTY_NEWLINE
);
6539 if (! peer_group_active (peer
) || ! g_peer
->bfd_info
)
6541 bgp_bfd_peer_config_write(vty
, peer
, addr
);
6548 if (!peer_group_active (peer
)
6549 || ! g_peer
->password
6550 || strcmp (peer
->password
, g_peer
->password
) != 0)
6552 vty_out (vty
, " neighbor %s password %s%s", addr
, peer
->password
,
6558 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
))
6560 if (!peer_group_active (peer
))
6562 vty_out (vty
, " neighbor %s solo%s", addr
, VTY_NEWLINE
);
6567 if (peer
->port
!= BGP_PORT_DEFAULT
)
6569 vty_out (vty
, " neighbor %s port %d%s", addr
, peer
->port
,
6573 /* Local interface name */
6576 vty_out (vty
, " neighbor %s interface %s%s", addr
, peer
->ifname
,
6581 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_PASSIVE
))
6583 if (! peer_group_active (peer
) ||
6584 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_PASSIVE
))
6586 vty_out (vty
, " neighbor %s passive%s", addr
, VTY_NEWLINE
);
6591 if (peer
->sort
!= BGP_PEER_IBGP
&& peer
->ttl
!= 1 &&
6592 !(peer
->gtsm_hops
!= 0 && peer
->ttl
== MAXTTL
))
6594 if (! peer_group_active (peer
) || g_peer
->ttl
!= peer
->ttl
)
6596 vty_out (vty
, " neighbor %s ebgp-multihop %d%s", addr
, peer
->ttl
,
6601 /* ttl-security hops */
6602 if (peer
->gtsm_hops
!= 0)
6604 if (! peer_group_active (peer
) || g_peer
->gtsm_hops
!= peer
->gtsm_hops
)
6606 vty_out (vty
, " neighbor %s ttl-security hops %d%s", addr
,
6607 peer
->gtsm_hops
, VTY_NEWLINE
);
6611 /* disable-connected-check */
6612 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6614 if (! peer_group_active (peer
) ||
6615 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DISABLE_CONNECTED_CHECK
))
6617 vty_out (vty
, " neighbor %s disable-connected-check%s", addr
, VTY_NEWLINE
);
6622 if (peer
->update_if
)
6624 if (! peer_group_active (peer
) || ! g_peer
->update_if
6625 || strcmp (g_peer
->update_if
, peer
->update_if
) != 0)
6627 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6628 peer
->update_if
, VTY_NEWLINE
);
6631 if (peer
->update_source
)
6633 if (! peer_group_active (peer
) || ! g_peer
->update_source
6634 || sockunion_cmp (g_peer
->update_source
,
6635 peer
->update_source
) != 0)
6637 vty_out (vty
, " neighbor %s update-source %s%s", addr
,
6638 sockunion2str (peer
->update_source
, buf
, SU_ADDRSTRLEN
),
6643 /* advertisement-interval */
6644 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_ROUTEADV
)
6645 && peer
->v_routeadv
!= BGP_DEFAULT_EBGP_ROUTEADV
6646 && ! peer_group_active (peer
))
6648 vty_out (vty
, " neighbor %s advertisement-interval %d%s",
6649 addr
, peer
->v_routeadv
, VTY_NEWLINE
);
6653 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_TIMER
)
6654 && (peer
->keepalive
!= BGP_DEFAULT_KEEPALIVE
|| peer
->holdtime
!= BGP_DEFAULT_HOLDTIME
)
6655 && ! peer_group_active (peer
))
6657 vty_out (vty
, " neighbor %s timers %d %d%s", addr
,
6658 peer
->keepalive
, peer
->holdtime
, VTY_NEWLINE
);
6661 if (CHECK_FLAG (peer
->config
, PEER_CONFIG_CONNECT
) &&
6662 peer
->connect
!= BGP_DEFAULT_CONNECT_RETRY
&&
6663 ! peer_group_active (peer
))
6665 vty_out (vty
, " neighbor %s timers connect %d%s", addr
,
6666 peer
->connect
, VTY_NEWLINE
);
6669 /* capability dynamic */
6670 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6672 if (! peer_group_active (peer
) ||
6673 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DYNAMIC_CAPABILITY
))
6675 vty_out (vty
, " neighbor %s capability dynamic%s", addr
,
6680 /* capability extended-nexthop */
6681 if (peer
->ifp
&& !CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6683 if (! peer_group_active (peer
) ||
6684 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6686 vty_out (vty
, " no neighbor %s capability extended-nexthop%s", addr
,
6691 if (!peer
->ifp
&& CHECK_FLAG (peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6693 if (! peer_group_active (peer
) ||
6694 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_CAPABILITY_ENHE
))
6696 vty_out (vty
, " neighbor %s capability extended-nexthop%s", addr
,
6701 /* dont-capability-negotiation */
6702 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6704 if (! peer_group_active (peer
) ||
6705 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_DONT_CAPABILITY
))
6707 vty_out (vty
, " neighbor %s dont-capability-negotiate%s", addr
,
6712 /* override-capability */
6713 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6715 if (! peer_group_active (peer
) ||
6716 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_OVERRIDE_CAPABILITY
))
6718 vty_out (vty
, " neighbor %s override-capability%s", addr
,
6723 /* strict-capability-match */
6724 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6726 if (! peer_group_active (peer
) ||
6727 ! CHECK_FLAG (g_peer
->flags
, PEER_FLAG_STRICT_CAP_MATCH
))
6729 vty_out (vty
, " neighbor %s strict-capability-match%s", addr
,
6735 /* BGP peer configuration display function. */
6737 bgp_config_write_peer_af (struct vty
*vty
, struct bgp
*bgp
,
6738 struct peer
*peer
, afi_t afi
, safi_t safi
,
6741 struct peer
*g_peer
= NULL
;
6744 /* Skip dynamic neighbors. */
6745 if (peer_dynamic_neighbor (peer
))
6749 addr
= peer
->conf_if
;
6753 /************************************
6754 ****** Per AF to the neighbor ******
6755 ************************************/
6756 if (peer_group_active (peer
))
6758 g_peer
= peer
->group
->conf
;
6760 /* If the peer-group is active but peer is not, print a 'no activate' */
6761 if (g_peer
->afc
[afi
][safi
] && !peer
->afc
[afi
][safi
])
6763 afi_header_vty_out (vty
, afi
, safi
, write
,
6764 " no neighbor %s activate%s",
6768 /* If the peer-group is not active but peer is, print an 'activate' */
6769 else if (!g_peer
->afc
[afi
][safi
] && peer
->afc
[afi
][safi
])
6771 afi_header_vty_out (vty
, afi
, safi
, write
,
6772 " neighbor %s activate%s",
6778 if (peer
->afc
[afi
][safi
])
6780 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6782 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6784 afi_header_vty_out(vty
, afi
, safi
, write
,
6785 " neighbor %s activate%s",
6790 afi_header_vty_out (vty
, afi
, safi
, write
,
6791 " neighbor %s activate%s",
6796 if ((afi
== AFI_IP
) && (safi
== SAFI_UNICAST
))
6798 if (!bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
6800 afi_header_vty_out (vty
, afi
, safi
, write
,
6801 " no neighbor %s activate%s",
6808 /* addpath TX knobs */
6809 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
6811 afi_header_vty_out (vty
, afi
, safi
, write
,
6812 " neighbor %s addpath-tx-all-paths%s",
6816 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
))
6818 afi_header_vty_out (vty
, afi
, safi
, write
,
6819 " neighbor %s addpath-tx-bestpath-per-AS%s",
6823 /* ORF capability. */
6824 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) ||
6825 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6827 afi_header_vty_out (vty
, afi
, safi
, write
,
6828 " neighbor %s capability orf prefix-list",
6831 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
) &&
6832 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_RM
))
6833 vty_out (vty
, " both");
6834 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ORF_PREFIX_SM
))
6835 vty_out (vty
, " send");
6837 vty_out (vty
, " receive");
6838 vty_out (vty
, "%s", VTY_NEWLINE
);
6841 /* Route reflector client. */
6842 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REFLECTOR_CLIENT
))
6844 afi_header_vty_out (vty
, afi
, safi
, write
,
6845 " neighbor %s route-reflector-client%s",
6849 /* next-hop-self force */
6850 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_FORCE_NEXTHOP_SELF
))
6852 afi_header_vty_out (vty
, afi
, safi
, write
,
6853 " neighbor %s next-hop-self force%s",
6858 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_SELF
))
6860 afi_header_vty_out (vty
, afi
, safi
, write
,
6861 " neighbor %s next-hop-self%s",
6865 /* remove-private-AS */
6866 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
))
6868 afi_header_vty_out (vty
, afi
, safi
, write
,
6869 " neighbor %s remove-private-AS all replace-AS%s",
6873 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
))
6875 afi_header_vty_out (vty
, afi
, safi
, write
,
6876 " neighbor %s remove-private-AS replace-AS%s",
6880 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS_ALL
))
6882 afi_header_vty_out (vty
, afi
, safi
, write
,
6883 " neighbor %s remove-private-AS all%s",
6887 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_REMOVE_PRIVATE_AS
))
6889 afi_header_vty_out (vty
, afi
, safi
, write
,
6890 " neighbor %s remove-private-AS%s",
6895 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_OVERRIDE
))
6897 afi_header_vty_out (vty
, afi
, safi
, write
,
6898 " neighbor %s as-override%s",
6902 /* send-community print. */
6903 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
6905 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)
6906 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
))
6908 afi_header_vty_out (vty
, afi
, safi
, write
,
6909 " neighbor %s send-community both%s",
6912 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
))
6914 afi_header_vty_out (vty
, afi
, safi
, write
,
6915 " neighbor %s send-community extended%s",
6918 else if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
))
6920 afi_header_vty_out (vty
, afi
, safi
, write
,
6921 " neighbor %s send-community%s",
6927 if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
6928 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)) &&
6929 !peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
6930 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)))
6932 afi_header_vty_out (vty
, afi
, safi
, write
,
6933 " no neighbor %s send-community both%s",
6936 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
) &&
6937 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_EXT_COMMUNITY
)))
6939 afi_header_vty_out (vty
, afi
, safi
, write
,
6940 " no neighbor %s send-community extended%s",
6943 else if (!peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
) &&
6944 (!g_peer
|| peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_SEND_COMMUNITY
)))
6946 afi_header_vty_out (vty
, afi
, safi
, write
,
6947 " no neighbor %s send-community%s",
6952 /* Default information */
6953 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_DEFAULT_ORIGINATE
) ||
6955 ((peer
->default_rmap
[afi
][safi
].name
&& !g_peer
->default_rmap
[afi
][safi
].name
) ||
6956 (!peer
->default_rmap
[afi
][safi
].name
&& g_peer
->default_rmap
[afi
][safi
].name
) ||
6957 (peer
->default_rmap
[afi
][safi
].name
&&
6958 strcmp(peer
->default_rmap
[afi
][safi
].name
, g_peer
->default_rmap
[afi
][safi
].name
)))))
6960 afi_header_vty_out (vty
, afi
, safi
, write
,
6961 " neighbor %s default-originate", addr
);
6962 if (peer
->default_rmap
[afi
][safi
].name
)
6963 vty_out (vty
, " route-map %s", peer
->default_rmap
[afi
][safi
].name
);
6964 vty_out (vty
, "%s", VTY_NEWLINE
);
6967 /* Soft reconfiguration inbound. */
6968 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_SOFT_RECONFIG
))
6970 afi_header_vty_out (vty
, afi
, safi
, write
,
6971 " neighbor %s soft-reconfiguration inbound%s",
6975 /* maximum-prefix. */
6976 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX
))
6977 if (! peer_group_active(peer
)
6978 || g_peer
->pmax
[afi
][safi
] != peer
->pmax
[afi
][safi
]
6979 || g_peer
->pmax_threshold
[afi
][safi
] != peer
->pmax_threshold
[afi
][safi
]
6980 || CHECK_FLAG (g_peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
)
6981 != CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
6983 afi_header_vty_out (vty
, afi
, safi
, write
,
6984 " neighbor %s maximum-prefix %lu",
6985 addr
, peer
->pmax
[afi
][safi
]);
6986 if (peer
->pmax_threshold
[afi
][safi
] != MAXIMUM_PREFIX_THRESHOLD_DEFAULT
)
6987 vty_out (vty
, " %d", peer
->pmax_threshold
[afi
][safi
]);
6988 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_WARNING
))
6989 vty_out (vty
, " warning-only");
6990 if (peer
->pmax_restart
[afi
][safi
])
6991 vty_out (vty
, " restart %d", peer
->pmax_restart
[afi
][safi
]);
6992 vty_out (vty
, "%s", VTY_NEWLINE
);
6995 /* Route server client. */
6996 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_RSERVER_CLIENT
))
6998 afi_header_vty_out (vty
, afi
, safi
, write
,
6999 " neighbor %s route-server-client%s",
7003 /* Nexthop-local unchanged. */
7004 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED
))
7006 afi_header_vty_out (vty
, afi
, safi
, write
,
7007 " neighbor %s nexthop-local unchanged%s",
7012 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
))
7013 if (! peer_group_active (peer
)
7014 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_ALLOWAS_IN
)
7015 || peer
->allowas_in
[afi
][safi
] != g_peer
->allowas_in
[afi
][safi
])
7017 if (peer
->allowas_in
[afi
][safi
] == 3)
7019 afi_header_vty_out (vty
, afi
, safi
, write
,
7020 " neighbor %s allowas-in%s",
7025 afi_header_vty_out (vty
, afi
, safi
, write
,
7026 " neighbor %s allowas-in %d%s",
7027 addr
, peer
->allowas_in
[afi
][safi
], VTY_NEWLINE
);
7032 if (peer_af_flag_check (peer
, afi
, safi
, PEER_FLAG_WEIGHT
))
7033 if (! peer_group_active (peer
)
7034 || ! peer_af_flag_check (g_peer
, afi
, safi
, PEER_FLAG_WEIGHT
)
7035 || peer
->weight
[afi
][safi
] != g_peer
->weight
[afi
][safi
])
7037 if (peer
->weight
[afi
][safi
])
7039 afi_header_vty_out (vty
, afi
, safi
, write
,
7040 " neighbor %s weight %d%s",
7041 addr
, peer
->weight
[afi
][safi
], VTY_NEWLINE
);
7046 bgp_config_write_filter (vty
, peer
, afi
, safi
, write
);
7048 /* atribute-unchanged. */
7049 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_AS_PATH_UNCHANGED
)
7050 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_NEXTHOP_UNCHANGED
)
7051 || CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_MED_UNCHANGED
))
7053 if (peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
)
7054 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
)
7055 && peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
))
7057 afi_header_vty_out (vty
, afi
, safi
, write
,
7058 " neighbor %s attribute-unchanged%s",
7063 afi_header_vty_out (vty
, afi
, safi
, write
,
7064 " neighbor %s attribute-unchanged%s%s%s%s", addr
,
7065 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_AS_PATH_UNCHANGED
) ?
7067 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_NEXTHOP_UNCHANGED
) ?
7069 peergroup_af_flag_check (peer
, afi
, safi
, PEER_FLAG_MED_UNCHANGED
) ?
7070 " med" : "", VTY_NEWLINE
);
7075 /* Display "address-family" configuration header. */
7077 bgp_config_write_family_header (struct vty
*vty
, afi_t afi
, safi_t safi
,
7083 vty_out (vty
, " !%s address-family ", VTY_NEWLINE
);
7087 if (safi
== SAFI_UNICAST
)
7088 vty_out (vty
, "ipv4 unicast");
7089 else if (safi
== SAFI_MULTICAST
)
7090 vty_out (vty
, "ipv4 multicast");
7091 else if (safi
== SAFI_MPLS_VPN
)
7092 vty_out (vty
, "vpnv4");
7093 else if (safi
== SAFI_ENCAP
)
7094 vty_out (vty
, "encap");
7096 else if (afi
== AFI_IP6
)
7098 if (safi
== SAFI_UNICAST
)
7099 vty_out (vty
, "ipv6 unicast");
7100 else if (safi
== SAFI_MULTICAST
)
7101 vty_out (vty
, "ipv6 multicast");
7102 else if (safi
== SAFI_MPLS_VPN
)
7103 vty_out (vty
, "vpnv6");
7104 else if (safi
== SAFI_ENCAP
)
7105 vty_out (vty
, "encapv6");
7108 vty_out (vty
, "%s", VTY_NEWLINE
);
7113 /* Address family based peer configuration display. */
7115 bgp_config_write_family (struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7120 struct peer_group
*group
;
7121 struct listnode
*node
, *nnode
;
7123 bgp_config_write_network (vty
, bgp
, afi
, safi
, &write
);
7125 bgp_config_write_redistribute (vty
, bgp
, afi
, safi
, &write
);
7127 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7128 bgp_config_write_peer_af (vty
, bgp
, group
->conf
, afi
, safi
, &write
);
7130 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7132 /* Skip dynamic neighbors. */
7133 if (peer_dynamic_neighbor (peer
))
7136 /* Do not display doppelganger peers */
7137 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7138 bgp_config_write_peer_af (vty
, bgp
, peer
, afi
, safi
, &write
);
7141 bgp_config_write_maxpaths (vty
, bgp
, afi
, safi
, &write
);
7142 bgp_config_write_table_map (vty
, bgp
, afi
, safi
, &write
);
7145 vty_out (vty
, " exit-address-family%s", VTY_NEWLINE
);
7151 bgp_config_write (struct vty
*vty
)
7155 struct peer_group
*group
;
7157 struct listnode
*node
, *nnode
;
7158 struct listnode
*mnode
, *mnnode
;
7160 /* BGP Multiple instance. */
7161 if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7163 vty_out (vty
, "no bgp multiple-instance%s", VTY_NEWLINE
);
7167 /* BGP Config type. */
7168 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7170 vty_out (vty
, "bgp config-type cisco%s", VTY_NEWLINE
);
7174 if (bm
->rmap_update_timer
!= RMAP_DEFAULT_UPDATE_TIMER
)
7175 vty_out (vty
, "bgp route-map delay-timer %d%s", bm
->rmap_update_timer
,
7178 /* BGP configuration. */
7179 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7182 vty_out (vty
, "!%s", VTY_NEWLINE
);
7184 /* Router bgp ASN */
7185 vty_out (vty
, "router bgp %u", bgp
->as
);
7187 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE
))
7190 vty_out (vty
, " %s %s",
7191 (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
) ?
7192 "view" : "vrf", bgp
->name
);
7194 vty_out (vty
, "%s", VTY_NEWLINE
);
7196 /* No Synchronization */
7197 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7198 vty_out (vty
, " no synchronization%s", VTY_NEWLINE
);
7200 /* BGP fast-external-failover. */
7201 if (CHECK_FLAG (bgp
->flags
, BGP_FLAG_NO_FAST_EXT_FAILOVER
))
7202 vty_out (vty
, " no bgp fast-external-failover%s", VTY_NEWLINE
);
7204 /* BGP router ID. */
7205 if (bgp
->router_id_static
.s_addr
!= 0)
7206 vty_out (vty
, " bgp router-id %s%s",
7207 inet_ntoa (bgp
->router_id_static
), VTY_NEWLINE
);
7209 /* BGP log-neighbor-changes. */
7210 if (!bgp_flag_check (bgp
, BGP_FLAG_LOG_NEIGHBOR_CHANGES
))
7211 vty_out (vty
, " no bgp log-neighbor-changes%s", VTY_NEWLINE
);
7213 /* BGP configuration. */
7214 if (bgp_flag_check (bgp
, BGP_FLAG_ALWAYS_COMPARE_MED
))
7215 vty_out (vty
, " bgp always-compare-med%s", VTY_NEWLINE
);
7217 /* BGP default ipv4-unicast. */
7218 if (bgp_flag_check (bgp
, BGP_FLAG_NO_DEFAULT_IPV4
))
7219 vty_out (vty
, " no bgp default ipv4-unicast%s", VTY_NEWLINE
);
7221 /* BGP default local-preference. */
7222 if (bgp
->default_local_pref
!= BGP_DEFAULT_LOCAL_PREF
)
7223 vty_out (vty
, " bgp default local-preference %d%s",
7224 bgp
->default_local_pref
, VTY_NEWLINE
);
7226 /* BGP default show-hostname */
7227 if (!bgp_flag_check(bgp
, BGP_FLAG_SHOW_HOSTNAME
))
7228 vty_out (vty
, " no bgp default show-hostname%s", VTY_NEWLINE
);
7230 /* BGP default subgroup-pkt-queue-max. */
7231 if (bgp
->default_subgroup_pkt_queue_max
!= BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX
)
7232 vty_out (vty
, " bgp default subgroup-pkt-queue-max %d%s",
7233 bgp
->default_subgroup_pkt_queue_max
, VTY_NEWLINE
);
7235 /* BGP client-to-client reflection. */
7236 if (bgp_flag_check (bgp
, BGP_FLAG_NO_CLIENT_TO_CLIENT
))
7237 vty_out (vty
, " no bgp client-to-client reflection%s", VTY_NEWLINE
);
7239 /* BGP cluster ID. */
7240 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CLUSTER_ID
))
7241 vty_out (vty
, " bgp cluster-id %s%s", inet_ntoa (bgp
->cluster_id
),
7244 /* Disable ebgp connected nexthop check */
7245 if (bgp_flag_check (bgp
, BGP_FLAG_DISABLE_NH_CONNECTED_CHK
))
7246 vty_out (vty
, " bgp disable-ebgp-connected-route-check%s", VTY_NEWLINE
);
7248 /* Confederation identifier*/
7249 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
7250 vty_out (vty
, " bgp confederation identifier %i%s", bgp
->confed_id
,
7253 /* Confederation peer */
7254 if (bgp
->confed_peers_cnt
> 0)
7258 vty_out (vty
, " bgp confederation peers");
7260 for (i
= 0; i
< bgp
->confed_peers_cnt
; i
++)
7261 vty_out(vty
, " %u", bgp
->confed_peers
[i
]);
7263 vty_out (vty
, "%s", VTY_NEWLINE
);
7266 /* BGP enforce-first-as. */
7267 if (bgp_flag_check (bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
7268 vty_out (vty
, " bgp enforce-first-as%s", VTY_NEWLINE
);
7270 /* BGP deterministic-med. */
7271 if (!bgp_flag_check (bgp
, BGP_FLAG_DETERMINISTIC_MED
))
7272 vty_out (vty
, " no bgp deterministic-med%s", VTY_NEWLINE
);
7274 /* BGP update-delay. */
7275 bgp_config_write_update_delay (vty
, bgp
);
7277 if (bgp
->v_maxmed_onstartup
!= BGP_MAXMED_ONSTARTUP_UNCONFIGURED
)
7279 vty_out (vty
, " bgp max-med on-startup %d", bgp
->v_maxmed_onstartup
);
7280 if (bgp
->maxmed_onstartup_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7281 vty_out (vty
, " %d", bgp
->maxmed_onstartup_value
);
7282 vty_out (vty
, "%s", VTY_NEWLINE
);
7284 if (bgp
->v_maxmed_admin
!= BGP_MAXMED_ADMIN_UNCONFIGURED
)
7286 vty_out (vty
, " bgp max-med administrative");
7287 if (bgp
->maxmed_admin_value
!= BGP_MAXMED_VALUE_DEFAULT
)
7288 vty_out (vty
, " %d", bgp
->maxmed_admin_value
);
7289 vty_out (vty
, "%s", VTY_NEWLINE
);
7293 bgp_config_write_wpkt_quanta (vty
, bgp
);
7296 bgp_config_write_coalesce_time(vty
, bgp
);
7298 /* BGP graceful-restart. */
7299 if (bgp
->stalepath_time
!= BGP_DEFAULT_STALEPATH_TIME
)
7300 vty_out (vty
, " bgp graceful-restart stalepath-time %d%s",
7301 bgp
->stalepath_time
, VTY_NEWLINE
);
7302 if (bgp
->restart_time
!= BGP_DEFAULT_RESTART_TIME
)
7303 vty_out (vty
, " bgp graceful-restart restart-time %d%s",
7304 bgp
->restart_time
, VTY_NEWLINE
);
7305 if (bgp_flag_check (bgp
, BGP_FLAG_GRACEFUL_RESTART
))
7306 vty_out (vty
, " bgp graceful-restart%s", VTY_NEWLINE
);
7308 /* BGP bestpath method. */
7309 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_IGNORE
))
7310 vty_out (vty
, " bgp bestpath as-path ignore%s", VTY_NEWLINE
);
7311 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_CONFED
))
7312 vty_out (vty
, " bgp bestpath as-path confed%s", VTY_NEWLINE
);
7314 if (bgp_flag_check (bgp
, BGP_FLAG_ASPATH_MULTIPATH_RELAX
))
7316 if (bgp_flag_check (bgp
, BGP_FLAG_MULTIPATH_RELAX_AS_SET
))
7318 vty_out (vty
, " bgp bestpath as-path multipath-relax as-set%s", VTY_NEWLINE
);
7322 vty_out (vty
, " bgp bestpath as-path multipath-relax%s", VTY_NEWLINE
);
7326 if (bgp_flag_check (bgp
, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY
)) {
7327 vty_out (vty
, " bgp route-reflector allow-outbound-policy%s",
7330 if (bgp_flag_check (bgp
, BGP_FLAG_COMPARE_ROUTER_ID
))
7331 vty_out (vty
, " bgp bestpath compare-routerid%s", VTY_NEWLINE
);
7332 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
)
7333 || bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7335 vty_out (vty
, " bgp bestpath med");
7336 if (bgp_flag_check (bgp
, BGP_FLAG_MED_CONFED
))
7337 vty_out (vty
, " confed");
7338 if (bgp_flag_check (bgp
, BGP_FLAG_MED_MISSING_AS_WORST
))
7339 vty_out (vty
, " missing-as-worst");
7340 vty_out (vty
, "%s", VTY_NEWLINE
);
7343 /* BGP network import check. */
7344 if (!bgp_flag_check (bgp
, BGP_FLAG_IMPORT_CHECK
))
7345 vty_out (vty
, " no bgp network import-check%s", VTY_NEWLINE
);
7347 /* BGP flag dampening. */
7348 if (CHECK_FLAG (bgp
->af_flags
[AFI_IP
][SAFI_UNICAST
],
7349 BGP_CONFIG_DAMPENING
))
7350 bgp_config_write_damp (vty
);
7352 /* BGP timers configuration. */
7353 if (bgp
->default_keepalive
!= BGP_DEFAULT_KEEPALIVE
7354 && bgp
->default_holdtime
!= BGP_DEFAULT_HOLDTIME
)
7355 vty_out (vty
, " timers bgp %d %d%s", bgp
->default_keepalive
,
7356 bgp
->default_holdtime
, VTY_NEWLINE
);
7359 for (ALL_LIST_ELEMENTS (bgp
->group
, node
, nnode
, group
))
7361 bgp_config_write_peer_global (vty
, bgp
, group
->conf
);
7364 /* Normal neighbor configuration. */
7365 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7367 if (CHECK_FLAG (peer
->flags
, PEER_FLAG_CONFIG_NODE
))
7368 bgp_config_write_peer_global (vty
, bgp
, peer
);
7371 /* Distance configuration. */
7372 bgp_config_write_distance (vty
, bgp
);
7374 /* listen range and limit for dynamic BGP neighbors */
7375 bgp_config_write_listen (vty
, bgp
);
7377 /* No auto-summary */
7378 if (bgp_option_check (BGP_OPT_CONFIG_CISCO
))
7379 vty_out (vty
, " no auto-summary%s", VTY_NEWLINE
);
7381 /* IPv4 unicast configuration. */
7382 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_UNICAST
);
7384 /* IPv4 multicast configuration. */
7385 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MULTICAST
);
7387 /* IPv4 VPN configuration. */
7388 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_MPLS_VPN
);
7390 /* ENCAPv4 configuration. */
7391 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP
, SAFI_ENCAP
);
7393 /* IPv6 unicast configuration. */
7394 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_UNICAST
);
7396 /* IPv6 multicast configuration. */
7397 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MULTICAST
);
7399 /* IPv6 VPN configuration. */
7400 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_MPLS_VPN
);
7402 /* ENCAPv6 configuration. */
7403 write
+= bgp_config_write_family (vty
, bgp
, AFI_IP6
, SAFI_ENCAP
);
7406 write
+= bgp_rfapi_cfg_write(vty
, bgp
);
7415 bgp_master_init (void)
7417 memset (&bgp_master
, 0, sizeof (struct bgp_master
));
7420 bm
->bgp
= list_new ();
7421 bm
->listen_sockets
= list_new ();
7422 bm
->port
= BGP_PORT_DEFAULT
;
7423 bm
->master
= thread_master_create ();
7424 bm
->start_time
= bgp_clock ();
7425 bm
->t_rmap_update
= NULL
;
7426 bm
->rmap_update_timer
= RMAP_DEFAULT_UPDATE_TIMER
;
7428 bgp_process_queue_init();
7430 /* Enable multiple instances by default. */
7431 bgp_option_set (BGP_OPT_MULTIPLE_INSTANCE
);
7435 * Initialize interface list for instance, if needed. Invoked upon
7439 bgp_if_init (struct bgp
*bgp
)
7441 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7444 vrf_iflist_create (bgp
->vrf_id
);
7448 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7449 * instance delete (non-default only) or BGP exit.
7452 bgp_if_finish (struct bgp
*bgp
)
7454 struct listnode
*ifnode
, *ifnnode
;
7455 struct interface
*ifp
;
7457 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VIEW
)
7460 for (ALL_LIST_ELEMENTS (vrf_iflist(bgp
->vrf_id
), ifnode
, ifnnode
, ifp
))
7462 struct listnode
*c_node
, *c_nnode
;
7463 struct connected
*c
;
7465 for (ALL_LIST_ELEMENTS (ifp
->connected
, c_node
, c_nnode
, c
))
7466 bgp_connected_delete (bgp
, c
);
7474 /* allocates some vital data structures used by peer commands in vty_init */
7477 bgp_zebra_init(bm
->master
);
7480 vnc_zebra_init (bm
->master
);
7483 /* BGP VTY commands installation. */
7491 bgp_route_map_init ();
7492 bgp_scan_vty_init();
7493 bgp_mplsvpn_init ();
7499 /* Access list initialize. */
7500 access_list_init ();
7501 access_list_add_hook (peer_distribute_update
);
7502 access_list_delete_hook (peer_distribute_update
);
7504 /* Filter list initialize. */
7506 as_list_add_hook (peer_aslist_add
);
7507 as_list_delete_hook (peer_aslist_del
);
7509 /* Prefix list initialize.*/
7510 prefix_list_init ();
7511 prefix_list_add_hook (peer_prefix_list_update
);
7512 prefix_list_delete_hook (peer_prefix_list_update
);
7514 /* Community list initialize. */
7515 bgp_clist
= community_list_init ();
7519 #endif /* HAVE_SNMP */
7526 bgp_terminate (void)
7530 struct listnode
*node
, *nnode
;
7531 struct listnode
*mnode
, *mnnode
;
7533 /* Close the listener sockets first as this prevents peers from attempting
7534 * to reconnect on receiving the peer unconfig message. In the presence
7535 * of a large number of peers this will ensure that no peer is left with
7536 * a dangling connection
7538 /* reverse bgp_master_init */
7540 if (bm
->listen_sockets
)
7541 list_free(bm
->listen_sockets
);
7542 bm
->listen_sockets
= NULL
;
7544 for (ALL_LIST_ELEMENTS (bm
->bgp
, mnode
, mnnode
, bgp
))
7545 for (ALL_LIST_ELEMENTS (bgp
->peer
, node
, nnode
, peer
))
7546 if (peer
->status
== Established
||
7547 peer
->status
== OpenSent
||
7548 peer
->status
== OpenConfirm
)
7549 bgp_notify_send (peer
, BGP_NOTIFY_CEASE
,
7550 BGP_NOTIFY_CEASE_PEER_UNCONFIG
);
7552 bgp_cleanup_routes ();
7554 if (bm
->process_main_queue
)
7556 work_queue_free (bm
->process_main_queue
);
7557 bm
->process_main_queue
= NULL
;
7560 if (bm
->t_rmap_update
)
7561 BGP_TIMER_OFF(bm
->t_rmap_update
);