2023-02-08 13:17:09 +01:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2002-12-13 21:15:29 +01:00
|
|
|
/* zebra connection and redistribute fucntions.
|
2017-05-13 10:25:29 +02:00
|
|
|
* Copyright (C) 1999 Kunihiro Ishiguro
|
|
|
|
*/
|
2002-12-13 21:15:29 +01:00
|
|
|
|
2005-05-23 16:19:54 +02:00
|
|
|
#ifndef _QUAGGA_BGP_ZEBRA_H
|
|
|
|
#define _QUAGGA_BGP_ZEBRA_H
|
|
|
|
|
2017-06-28 10:51:10 +02:00
|
|
|
#include "vxlan.h"
|
|
|
|
|
2021-09-17 17:50:03 +02:00
|
|
|
/* Macro to update bgp_original based on bpg_path_info */
|
|
|
|
#define BGP_ORIGINAL_UPDATE(_bgp_orig, _mpinfo, _bgp) \
|
|
|
|
((_mpinfo->extra && _mpinfo->extra->bgp_orig \
|
|
|
|
&& _mpinfo->sub_type == BGP_ROUTE_IMPORTED) \
|
|
|
|
? (_bgp_orig = _mpinfo->extra->bgp_orig) \
|
|
|
|
: (_bgp_orig = _bgp))
|
|
|
|
|
2020-03-24 22:38:37 +01:00
|
|
|
/* Default weight for next hop, if doing weighted ECMP. */
|
|
|
|
#define BGP_ZEBRA_DEFAULT_NHOP_WEIGHT 1
|
|
|
|
|
2022-12-11 17:20:40 +01:00
|
|
|
extern void bgp_zebra_init(struct event_master *master,
|
2018-06-07 15:28:12 +02:00
|
|
|
unsigned short instance);
|
2022-08-17 11:52:51 +02:00
|
|
|
extern void bgp_if_init(void);
|
2018-05-23 14:14:53 +02:00
|
|
|
extern void bgp_zebra_init_tm_connect(struct bgp *bgp);
|
2018-04-03 15:06:50 +02:00
|
|
|
extern uint32_t bgp_zebra_tm_get_id(void);
|
2018-05-23 14:14:53 +02:00
|
|
|
extern bool bgp_zebra_tm_chunk_obtained(void);
|
2016-01-12 19:41:57 +01:00
|
|
|
extern void bgp_zebra_destroy(void);
|
2018-03-05 18:09:57 +01:00
|
|
|
extern int bgp_zebra_get_table_range(uint32_t chunk_size,
|
|
|
|
uint32_t *start, uint32_t *end);
|
2005-06-28 14:44:16 +02:00
|
|
|
extern int bgp_if_update_all(void);
|
2020-03-27 00:11:58 +01:00
|
|
|
extern void bgp_zebra_announce(struct bgp_dest *dest, const struct prefix *p,
|
2018-10-02 22:41:30 +02:00
|
|
|
struct bgp_path_info *path, struct bgp *bgp,
|
|
|
|
afi_t afi, safi_t safi);
|
2022-05-12 14:28:11 +02:00
|
|
|
extern void bgp_zebra_announce_table(struct bgp *bgp, afi_t afi, safi_t safi);
|
2020-03-22 02:56:36 +01:00
|
|
|
extern void bgp_zebra_withdraw(const struct prefix *p,
|
|
|
|
struct bgp_path_info *path, struct bgp *bgp,
|
|
|
|
safi_t safi);
|
2017-07-17 14:03:14 +02:00
|
|
|
|
2020-09-02 18:20:08 +02:00
|
|
|
/* Announce routes of any bgp subtype of a table to zebra */
|
|
|
|
extern void bgp_zebra_announce_table_all_subtypes(struct bgp *bgp, afi_t afi,
|
|
|
|
safi_t safi);
|
|
|
|
|
|
|
|
/* Withdraw all entries of any subtype in a BGP instances RIB table from Zebra */
|
|
|
|
extern void bgp_zebra_withdraw_table_all_subtypes(struct bgp *bgp, afi_t afi,
|
|
|
|
safi_t safi);
|
|
|
|
|
BGP: Trigger IPv6 router advertisements upon config of unnumbered neighbor
Instead of turning on IPv6 RA on every interface as soon as it has an IPv6
address, only enable it upon configuration of BGP neighbor. When the BGP
neighbor is deleted, signal that RAs can be turned off.
To support this, introduce new message interaction between BGP and Zebra.
Also, take appropriate actions in BGP upon interface add/del since the
unnumbered neighbor could exist prior to interface creation etc.
Only unnumbered IPv6 neighbors require RA, the /30 or /31 based neighbors
don't. However, to keep the interaction simple and not have to deal with
too many dynamic conditions (e.g., address deletes or neighbor change to/from
'v6only'), RAs on the interface are triggered upon any unnumbered neighbor
configuration.
BGP-triggered RAs will cause RAs to be initiated on the interface; however,
if BGP asks that RAs be stopped (upon delete of unnumbered neighbor), RAs
will continue to be exchanged if the operator has explicitly enabled.
Signed-off-by: Vivek Venkatraman <vivek@cumulusnetworks.com>
Reviewed-by: Donald Sharp <sharpd@cumulusnetworks.com>
Ticket: CM-10640
Reviewed By: CCR-4589
Testing Done: Various manual and automated (refer to defect)
2016-05-02 22:53:38 +02:00
|
|
|
extern void bgp_zebra_initiate_radv(struct bgp *bgp, struct peer *peer);
|
|
|
|
extern void bgp_zebra_terminate_radv(struct bgp *bgp, struct peer *peer);
|
2017-07-17 14:03:14 +02:00
|
|
|
|
2022-05-12 14:28:11 +02:00
|
|
|
extern void bgp_zebra_instance_register(struct bgp *bgp);
|
|
|
|
extern void bgp_zebra_instance_deregister(struct bgp *bgp);
|
2017-07-17 14:03:14 +02:00
|
|
|
|
2019-03-13 19:41:29 +01:00
|
|
|
extern void bgp_redistribute_redo(struct bgp *bgp);
|
2022-05-12 14:28:11 +02:00
|
|
|
extern struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi,
|
|
|
|
uint8_t type,
|
|
|
|
unsigned short instance);
|
|
|
|
extern struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi,
|
|
|
|
uint8_t type, unsigned short instance);
|
|
|
|
extern int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type,
|
|
|
|
unsigned short instance, bool changed);
|
|
|
|
extern int bgp_redistribute_resend(struct bgp *bgp, afi_t afi, int type,
|
|
|
|
unsigned short instance);
|
2020-03-20 10:57:54 +01:00
|
|
|
extern bool bgp_redistribute_rmap_set(struct bgp_redist *red, const char *name,
|
|
|
|
struct route_map *route_map);
|
2022-05-12 14:28:11 +02:00
|
|
|
extern bool bgp_redistribute_metric_set(struct bgp *bgp, struct bgp_redist *red,
|
|
|
|
afi_t afi, int type, uint32_t metric);
|
|
|
|
extern int bgp_redistribute_unset(struct bgp *bgp, afi_t afi, int type,
|
|
|
|
unsigned short instance);
|
|
|
|
extern int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
|
|
|
|
unsigned short instance);
|
2017-07-17 14:03:14 +02:00
|
|
|
|
2022-05-12 14:28:11 +02:00
|
|
|
extern struct interface *if_lookup_by_ipv4(struct in_addr *addr,
|
|
|
|
vrf_id_t vrf_id);
|
|
|
|
extern struct interface *if_lookup_by_ipv4_exact(struct in_addr *addr,
|
|
|
|
vrf_id_t vrf_id);
|
|
|
|
extern struct interface *if_lookup_by_ipv6(struct in6_addr *addr,
|
|
|
|
ifindex_t ifindex, vrf_id_t vrf_id);
|
|
|
|
extern struct interface *if_lookup_by_ipv6_exact(struct in6_addr *addr,
|
|
|
|
ifindex_t ifindex,
|
|
|
|
vrf_id_t vrf_id);
|
2017-11-20 06:47:04 +01:00
|
|
|
extern int bgp_zebra_advertise_subnet(struct bgp *bgp, int advertise,
|
|
|
|
vni_t vni);
|
2022-05-12 14:28:11 +02:00
|
|
|
extern int bgp_zebra_advertise_gw_macip(struct bgp *bgp, int advertise,
|
|
|
|
vni_t vni);
|
2019-02-04 02:29:59 +01:00
|
|
|
extern int bgp_zebra_advertise_svi_macip(struct bgp *bgp, int advertise,
|
|
|
|
vni_t vni);
|
2022-05-12 14:28:11 +02:00
|
|
|
extern int bgp_zebra_advertise_all_vni(struct bgp *bgp, int advertise);
|
2018-11-01 16:28:08 +01:00
|
|
|
extern int bgp_zebra_dup_addr_detection(struct bgp *bgp);
|
2018-10-05 01:20:12 +02:00
|
|
|
extern int bgp_zebra_vxlan_flood_control(struct bgp *bgp,
|
|
|
|
enum vxlan_flood_control flood_ctrl);
|
2017-05-15 23:30:19 +02:00
|
|
|
|
2016-10-07 15:44:42 +02:00
|
|
|
extern int bgp_zebra_num_connects(void);
|
|
|
|
|
2022-05-12 14:28:11 +02:00
|
|
|
extern bool bgp_zebra_nexthop_set(union sockunion *local,
|
|
|
|
union sockunion *remote,
|
|
|
|
struct bgp_nexthop *nexthop,
|
|
|
|
struct peer *peer);
|
2018-03-08 15:39:19 +01:00
|
|
|
struct bgp_pbr_action;
|
|
|
|
struct bgp_pbr_match;
|
2018-11-29 15:14:41 +01:00
|
|
|
struct bgp_pbr_rule;
|
2018-03-08 15:39:19 +01:00
|
|
|
struct bgp_pbr_match_entry;
|
2019-10-25 17:42:39 +02:00
|
|
|
|
2018-03-08 15:39:19 +01:00
|
|
|
extern void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra,
|
2018-11-29 15:14:41 +01:00
|
|
|
struct bgp_pbr_rule *pbr,
|
|
|
|
bool install);
|
2018-03-08 15:39:19 +01:00
|
|
|
extern void bgp_send_pbr_ipset_match(struct bgp_pbr_match *pbrim,
|
|
|
|
bool install);
|
|
|
|
extern void bgp_send_pbr_ipset_entry_match(struct bgp_pbr_match_entry *pbrime,
|
|
|
|
bool install);
|
2018-03-12 09:38:53 +01:00
|
|
|
extern void bgp_send_pbr_iptable(struct bgp_pbr_action *pba,
|
|
|
|
struct bgp_pbr_match *pbm,
|
|
|
|
bool install);
|
2018-03-08 15:39:19 +01:00
|
|
|
|
2018-03-28 14:51:57 +02:00
|
|
|
extern void bgp_zebra_announce_default(struct bgp *bgp, struct nexthop *nh,
|
|
|
|
afi_t afi, uint32_t table_id, bool announce);
|
2019-10-25 17:42:39 +02:00
|
|
|
extern int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable);
|
2023-03-09 14:36:51 +01:00
|
|
|
extern int bgp_zebra_update(struct bgp *bgp, afi_t afi, safi_t safi,
|
|
|
|
enum zserv_client_capabilities);
|
2019-10-25 17:42:39 +02:00
|
|
|
extern int bgp_zebra_stale_timer_update(struct bgp *bgp);
|
2020-12-19 02:50:18 +01:00
|
|
|
extern int bgp_zebra_srv6_manager_get_locator_chunk(const char *name);
|
2021-09-14 00:11:11 +02:00
|
|
|
extern int bgp_zebra_srv6_manager_release_locator_chunk(const char *name);
|
2005-05-23 16:19:54 +02:00
|
|
|
#endif /* _QUAGGA_BGP_ZEBRA_H */
|