// SPDX-License-Identifier: GPL-2.0-or-later

/* BGP message definition header.

 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro

 */

#ifndef _QUAGGA_BGPD_H

#define _QUAGGA_BGPD_H

#include "qobj.h"

#include <pthread.h>

#include "hook.h"

#include "frr_pthread.h"

#include "lib/json.h"

#include "vrf.h"

#include "vty.h"

#include "srv6.h"

#include "iana_afi.h"

#include "asn.h"

/* For union sockunion.  */

#include "queue.h"

#include "sockunion.h"

#include "routemap.h"

#include "linklist.h"

#include "defaults.h"

#include "bgp_memory.h"

#include "bitfield.h"

#include "vxlan.h"

#include "bgp_labelpool.h"

#include "bgp_addpath_types.h"

#include "bgp_nexthop.h"

#include "bgp_io.h"

#include "lib/bfd.h"

#define BGP_MAX_HOSTNAME 64  /* Linux max, is larger than most other sys */

#define BGP_PEER_MAX_HASH_SIZE 16384

/* Default interval for IPv6 RAs when triggered by BGP unnumbered neighbor. */

#define BGP_UNNUM_DEFAULT_RA_INTERVAL 10

struct update_subgroup;

struct bpacket;

struct bgp_pbr_config;

/*

 * Allow the neighbor XXXX remote-as to take internal or external

 * AS_SPECIFIED is zero to auto-inherit original non-feature/enhancement

 * behavior

 * in the system.

 */

enum { AS_UNSPECIFIED = 0,

       AS_SPECIFIED,

       AS_INTERNAL,

       AS_EXTERNAL,

};

/* Zebra Gracaful Restart states */

enum zebra_gr_mode {

  ZEBRA_GR_DISABLE = 0,

  ZEBRA_GR_ENABLE

};

/* Typedef BGP specific types.  */

typedef uint16_t as16_t; /* we may still encounter 16 Bit asnums */

typedef uint16_t bgp_size_t;

enum bgp_af_index {

  BGP_AF_START,

  BGP_AF_IPV4_UNICAST = BGP_AF_START,

  BGP_AF_IPV4_MULTICAST,

  BGP_AF_IPV4_VPN,

  BGP_AF_IPV6_UNICAST,

  BGP_AF_IPV6_MULTICAST,

  BGP_AF_IPV6_VPN,

  BGP_AF_IPV4_ENCAP,

  BGP_AF_IPV6_ENCAP,

  BGP_AF_L2VPN_EVPN,

  BGP_AF_IPV4_LBL_UNICAST,

  BGP_AF_IPV6_LBL_UNICAST,

  BGP_AF_IPV4_FLOWSPEC,

  BGP_AF_IPV6_FLOWSPEC,

  BGP_AF_MAX

};

#define AF_FOREACH(af) for ((af) = BGP_AF_START; (af) < BGP_AF_MAX; (af)++)

#define FOREACH_SAFI(safi)                                            \

  for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)

extern struct frr_pthread *bgp_pth_io;

extern struct frr_pthread *bgp_pth_ka;

/* BGP master for system wide configurations and variables.  */

struct bgp_master {

  /* BGP instance list.  */

  struct list *bgp;

  /* BGP thread master.  */

  struct event_loop *master;

  /* Listening sockets */

  struct list *listen_sockets;

  /* BGP port number.  */

  uint16_t port;

  /* Listener addresses */

  struct list *addresses;

  /* The Mac table */

  struct hash *self_mac_hash;

  /* BGP start time.  */

  time_t start_time;

  /* Various BGP global configuration.  */

  uint8_t options;

#define BGP_OPT_NO_FIB                   (1 << 0)

#define BGP_OPT_NO_LISTEN                (1 << 1)

#define BGP_OPT_NO_ZEBRA                 (1 << 2)

  uint64_t updgrp_idspace;

  uint64_t subgrp_idspace;

  /* timer to dampen route map changes */

  struct event *t_rmap_update; /* Handle route map updates */

  uint32_t rmap_update_timer;   /* Route map update timer */

#define RMAP_DEFAULT_UPDATE_TIMER 5 /* disabled by default */

  /* Id space for automatic RD derivation for an EVI/VRF */

  bitfield_t rd_idspace;

  /* dynamic mpls label allocation pool */

  struct labelpool labelpool;

  /* BGP-EVPN VRF ID. Defaults to default VRF (if any) */

  struct bgp* bgp_evpn;

  /* How big should we set the socket buffer size */

  uint32_t socket_buffer;

  /* Should we do wait for fib install globally? */

  bool wait_for_fib;

  /* EVPN multihoming */

  struct bgp_evpn_mh_info *mh_info;

  /* global update-delay timer values */

  uint16_t v_update_delay;

  uint16_t v_establish_wait;

  uint32_t flags;

#define BM_FLAG_GRACEFUL_SHUTDOWN        (1 << 0)

#define BM_FLAG_SEND_EXTRA_DATA_TO_ZEBRA (1 << 1)

  bool terminating; /* global flag that sigint terminate seen */

  /* DSCP value for TCP sessions */

  uint8_t tcp_dscp;

#define BM_DEFAULT_Q_LIMIT 10000

  uint32_t inq_limit;

  uint32_t outq_limit;

  QOBJ_FIELDS;

};

DECLARE_QOBJ_TYPE(bgp_master);

/* BGP route-map structure.  */

struct bgp_rmap {

  char *name;

  struct route_map *map;

};

struct bgp_redist {

  unsigned short instance;

  /* BGP redistribute metric configuration. */

  uint8_t redist_metric_flag;

  uint32_t redist_metric;

  /* BGP redistribute route-map.  */

  struct bgp_rmap rmap;

};

enum vpn_policy_direction {

  BGP_VPN_POLICY_DIR_FROMVPN = 0,

  BGP_VPN_POLICY_DIR_TOVPN = 1,

  BGP_VPN_POLICY_DIR_MAX = 2

};

struct vpn_policy {

  struct bgp *bgp; /* parent */

  afi_t afi;

  struct ecommunity *rtlist[BGP_VPN_POLICY_DIR_MAX];

  struct ecommunity *import_redirect_rtlist;

  char *rmap_name[BGP_VPN_POLICY_DIR_MAX];

  struct route_map *rmap[BGP_VPN_POLICY_DIR_MAX];

  /* should be mpls_label_t? */

  uint32_t tovpn_label; /* may be MPLS_LABEL_NONE */

  uint32_t tovpn_zebra_vrf_label_last_sent;

  char *tovpn_rd_pretty;

  struct prefix_rd tovpn_rd;

  struct prefix tovpn_nexthop; /* unset => set to 0 */

  uint32_t flags;

#define BGP_VPN_POLICY_TOVPN_LABEL_AUTO        (1 << 0)

#define BGP_VPN_POLICY_TOVPN_RD_SET            (1 << 1)

#define BGP_VPN_POLICY_TOVPN_NEXTHOP_SET       (1 << 2)

#define BGP_VPN_POLICY_TOVPN_SID_AUTO          (1 << 3)

#define BGP_VPN_POLICY_TOVPN_LABEL_PER_NEXTHOP (1 << 4)

  /*

   * If we are importing another vrf into us keep a list of

   * vrf names that are being imported into us.

   */

  struct list *import_vrf;

  /*

   * if we are being exported to another vrf keep a list of

   * vrf names that we are being exported to.

   */

  struct list *export_vrf;

  /*

   * Segment-Routing SRv6 Mode

   */

  uint32_t tovpn_sid_index; /* unset => set to 0 */

  struct in6_addr *tovpn_sid;

  struct srv6_locator_chunk *tovpn_sid_locator;

  uint32_t tovpn_sid_transpose_label;

  struct in6_addr *tovpn_zebra_vrf_sid_last_sent;

};

/*

 * Type of 'struct bgp'.

 * - Default: The default instance

 * - VRF: A specific (non-default) VRF

 * - View: An instance used for route exchange

 * The "default" instance is treated separately to simplify the code. Note

 * that if deployed in a Multi-VRF environment, it may not exist.

 */

enum bgp_instance_type {

  BGP_INSTANCE_TYPE_DEFAULT,

  BGP_INSTANCE_TYPE_VRF,

  BGP_INSTANCE_TYPE_VIEW

};

#define BGP_SEND_EOR(bgp, afi, safi)                                           \

  (!CHECK_FLAG(bgp->flags, BGP_FLAG_GR_DISABLE_EOR)                      \

   && ((bgp->gr_info[afi][safi].t_select_deferral == NULL)               \

       || (bgp->gr_info[afi][safi].eor_required                          \

     == bgp->gr_info[afi][safi].eor_received)))

/* BGP GR Global ds */

#define BGP_GLOBAL_GR_MODE 4

#define BGP_GLOBAL_GR_EVENT_CMD 4

/* Graceful restart selection deferral timer info */

struct graceful_restart_info {

  /* Count of EOR message expected */

  uint32_t eor_required;

  /* Count of EOR received */

  uint32_t eor_received;

  /* Deferral Timer */

  struct event *t_select_deferral;

  /* Routes Deferred */

  uint32_t gr_deferred;

  /* Best route select */

  struct event *t_route_select;

  /* AFI, SAFI enabled */

  bool af_enabled[AFI_MAX][SAFI_MAX];

  /* Route update completed */

  bool route_sync[AFI_MAX][SAFI_MAX];

};

enum global_mode {

  GLOBAL_HELPER = 0, /* This is the default mode */

  GLOBAL_GR,

  GLOBAL_DISABLE,

  GLOBAL_INVALID

};

enum global_gr_command {

  GLOBAL_GR_CMD = 0,

  NO_GLOBAL_GR_CMD,

  GLOBAL_DISABLE_CMD,

  NO_GLOBAL_DISABLE_CMD

};

#define BGP_GR_SUCCESS 0

#define BGP_GR_FAILURE 1

/* Handling of BGP link bandwidth (LB) on receiver - whether and how to

 * do weighted ECMP. Note: This applies after multipath computation.

 */

enum bgp_link_bw_handling {

  /* Do ECMP if some paths don't have LB - default */

  BGP_LINK_BW_ECMP,

  /* Completely ignore LB, just do regular ECMP */

  BGP_LINK_BW_IGNORE_BW,

  /* Skip paths without LB, do wECMP on others */

  BGP_LINK_BW_SKIP_MISSING,

  /* Do wECMP with default weight for paths not having LB */

  BGP_LINK_BW_DEFWT_4_MISSING

};

RB_HEAD(bgp_es_vrf_rb_head, bgp_evpn_es_vrf);

RB_PROTOTYPE(bgp_es_vrf_rb_head, bgp_evpn_es_vrf, rb_node, bgp_es_vrf_rb_cmp);

struct bgp_snmp_stats {

  /* SNMP variables for mplsL3Vpn*/

  time_t creation_time;

  time_t modify_time;

  bool active;

  uint32_t routes_added;

  uint32_t routes_deleted;

};

struct bgp_srv6_function {

  struct in6_addr sid;

  char locator_name[SRV6_LOCNAME_SIZE];

};

struct as_confed {

  as_t as;

  char *as_pretty;

};

/* BGP instance structure.  */

struct bgp {

  /* AS number of this BGP instance.  */

  as_t as;

  char *as_pretty;

  /* Name of this BGP instance.  */

  char *name;

  char *name_pretty;  /* printable "VRF|VIEW name|default" */

  /* Type of instance and VRF id. */

  enum bgp_instance_type inst_type;

  vrf_id_t vrf_id;

  /* Reference count to allow peer_delete to finish after bgp_delete */

  int lock;

  /* Self peer.  */

  struct peer *peer_self;

  /* BGP peer. */

  struct list *peer;

  struct hash *peerhash;

  /* BGP peer group.  */

  struct list *group;

  /* The maximum number of BGP dynamic neighbors that can be created */

  int dynamic_neighbors_limit;

  /* The current number of BGP dynamic neighbors */

  int dynamic_neighbors_count;

  struct hash *update_groups[BGP_AF_MAX];

  /*

   * Global statistics for update groups.

   */

  struct {

    uint32_t join_events;

    uint32_t prune_events;

    uint32_t merge_events;

    uint32_t split_events;

    uint32_t updgrp_switch_events;

    uint32_t peer_refreshes_combined;

    uint32_t adj_count;

    uint32_t merge_checks_triggered;

    uint32_t updgrps_created;

    uint32_t updgrps_deleted;

    uint32_t subgrps_created;

    uint32_t subgrps_deleted;

  } update_group_stats;

  struct bgp_snmp_stats *snmp_stats;

  /* BGP configuration.  */

  uint16_t config;

#define BGP_CONFIG_CLUSTER_ID             (1 << 0)

#define BGP_CONFIG_CONFEDERATION          (1 << 1)

#define BGP_CONFIG_ASNOTATION             (1 << 2)

  /* BGP router identifier.  */

  struct in_addr router_id;

  struct in_addr router_id_static;

  struct in_addr router_id_zebra;

  /* BGP route reflector cluster ID.  */

  struct in_addr cluster_id;

  /* BGP confederation information.  */

  as_t confed_id;

  char *confed_id_pretty;

  struct as_confed *confed_peers;

  int confed_peers_cnt;

  /* start-up timer on only once at the beginning */

  struct event *t_startup;

  uint32_t v_maxmed_onstartup; /* Duration of max-med on start-up */

#define BGP_MAXMED_ONSTARTUP_UNCONFIGURED  0 /* 0 means off, its the default */

  uint32_t maxmed_onstartup_value;     /* Max-med value when active on

             start-up */

  /* non-null when max-med onstartup is on */

  struct event *t_maxmed_onstartup;

  uint8_t maxmed_onstartup_over; /* Flag to make it effective only once */

  bool v_maxmed_admin; /* true/false if max-med administrative is on/off

            */

#define BGP_MAXMED_ADMIN_UNCONFIGURED false /* Off by default */

  uint32_t maxmed_admin_value; /* Max-med value when administrative in on

              */

#define BGP_MAXMED_VALUE_DEFAULT  4294967294 /* Maximum by default */

  uint8_t maxmed_active; /* 1/0 if max-med is active or not */

  uint32_t maxmed_value; /* Max-med value when its active */

  /* BGP update delay on startup */

  struct event *t_update_delay;

  struct event *t_establish_wait;

  struct event *t_revalidate[AFI_MAX][SAFI_MAX];

  uint8_t update_delay_over;

  uint8_t main_zebra_update_hold;

  uint8_t main_peers_update_hold;

  uint16_t v_update_delay;

  uint16_t v_establish_wait;

  char update_delay_begin_time[64];

  char update_delay_end_time[64];

  char update_delay_zebra_resume_time[64];

  char update_delay_peers_resume_time[64];

  uint32_t established;

  uint32_t restarted_peers;

  uint32_t implicit_eors;

  uint32_t explicit_eors;

#define BGP_UPDATE_DELAY_DEF              0

#define BGP_UPDATE_DELAY_MIN              0

#define BGP_UPDATE_DELAY_MAX              3600

  /* Reference bandwidth for BGP link-bandwidth. Used when

   * the LB value has to be computed based on some other

   * factor (e.g., number of multipaths for the prefix)

   * Value is in Mbps

   */

  uint32_t lb_ref_bw;

#define BGP_LINK_BW_REF_BW                1

  /* BGP flags. */

  uint64_t flags;

#define BGP_FLAG_ALWAYS_COMPARE_MED (1ULL << 0)

#define BGP_FLAG_DETERMINISTIC_MED (1ULL << 1)

#define BGP_FLAG_MED_MISSING_AS_WORST (1ULL << 2)

#define BGP_FLAG_MED_CONFED (1ULL << 3)

#define BGP_FLAG_NO_CLIENT_TO_CLIENT (1ULL << 4)

#define BGP_FLAG_COMPARE_ROUTER_ID (1ULL << 5)

#define BGP_FLAG_ASPATH_IGNORE (1ULL << 6)

#define BGP_FLAG_IMPORT_CHECK (1ULL << 7)

#define BGP_FLAG_NO_FAST_EXT_FAILOVER (1ULL << 8)

#define BGP_FLAG_LOG_NEIGHBOR_CHANGES (1ULL << 9)

/* This flag is set when we have full BGP Graceful-Restart mode enable */

#define BGP_FLAG_GRACEFUL_RESTART (1ULL << 10)

#define BGP_FLAG_ASPATH_CONFED (1ULL << 11)

#define BGP_FLAG_ASPATH_MULTIPATH_RELAX (1ULL << 12)

#define BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY (1ULL << 13)

#define BGP_FLAG_DISABLE_NH_CONNECTED_CHK (1ULL << 14)

#define BGP_FLAG_MULTIPATH_RELAX_AS_SET (1ULL << 15)

#define BGP_FLAG_FORCE_STATIC_PROCESS (1ULL << 16)

#define BGP_FLAG_SHOW_HOSTNAME (1ULL << 17)

#define BGP_FLAG_GR_PRESERVE_FWD (1ULL << 18)

#define BGP_FLAG_GRACEFUL_SHUTDOWN (1ULL << 19)

#define BGP_FLAG_DELETE_IN_PROGRESS (1ULL << 20)

#define BGP_FLAG_SELECT_DEFER_DISABLE (1ULL << 21)

#define BGP_FLAG_GR_DISABLE_EOR (1ULL << 22)

#define BGP_FLAG_EBGP_REQUIRES_POLICY (1ULL << 23)

#define BGP_FLAG_SHOW_NEXTHOP_HOSTNAME (1ULL << 24)

/* This flag is set if the instance is in administrative shutdown */

#define BGP_FLAG_SHUTDOWN (1ULL << 25)

#define BGP_FLAG_SUPPRESS_FIB_PENDING (1ULL << 26)

#define BGP_FLAG_SUPPRESS_DUPLICATES (1ULL << 27)

#define BGP_FLAG_PEERTYPE_MULTIPATH_RELAX (1ULL << 29)

/* Indicate Graceful Restart support for BGP NOTIFICATION messages */

#define BGP_FLAG_GRACEFUL_NOTIFICATION (1ULL << 30)

/* Send Hard Reset CEASE Notification for 'Administrative Reset' */

#define BGP_FLAG_HARD_ADMIN_RESET (1ULL << 31)

/* Evaluate the AIGP attribute during the best path selection process */

#define BGP_FLAG_COMPARE_AIGP (1ULL << 32)

/* For BGP-LU, force IPv4 local prefixes to use ipv4-explicit-null label */

#define BGP_FLAG_LU_IPV4_EXPLICIT_NULL (1ULL << 33)

/* For BGP-LU, force IPv6 local prefixes to use ipv6-explicit-null label */

#define BGP_FLAG_LU_IPV6_EXPLICIT_NULL (1ULL << 34)

  /* BGP default address-families.

   * New peers inherit enabled afi/safis from bgp instance.

   */

  uint16_t default_af[AFI_MAX][SAFI_MAX];

  enum global_mode GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE]

              [BGP_GLOBAL_GR_EVENT_CMD];

  enum global_mode global_gr_present_state;

  /* This variable stores the current Graceful Restart state of Zebra

   * - ZEBRA_GR_ENABLE / ZEBRA_GR_DISABLE

   */

  enum zebra_gr_mode present_zebra_gr_state;

  /* BGP Per AF flags */

  uint16_t af_flags[AFI_MAX][SAFI_MAX];

#define BGP_CONFIG_DAMPENING        (1 << 0)

/* l2vpn evpn flags - 1 << 0 is used for DAMPENNG */

#define BGP_L2VPN_EVPN_ADV_IPV4_UNICAST (1 << 1)

#define BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP (1 << 2)

#define BGP_L2VPN_EVPN_ADV_IPV6_UNICAST (1 << 3)

#define BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP (1 << 4)

#define BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4 (1 << 5)

#define BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6 (1 << 6)

/* import/export between address families */

#define BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT (1 << 7)

#define BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT (1 << 8)

/* vrf-route leaking flags */

#define BGP_CONFIG_VRF_TO_VRF_IMPORT (1 << 9)

#define BGP_CONFIG_VRF_TO_VRF_EXPORT (1 << 10)

/* vpnvx retain flag */

#define BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL (1 << 11)

  /* BGP per AF peer count */

  uint32_t af_peer_count[AFI_MAX][SAFI_MAX];

  /* Tree for next-hop lookup cache. */

  struct bgp_nexthop_cache_head nexthop_cache_table[AFI_MAX];

  /* Tree for import-check */

  struct bgp_nexthop_cache_head import_check_table[AFI_MAX];

  struct bgp_table *connected_table[AFI_MAX];

  struct hash *address_hash;

  /* DB for all local tunnel-ips - used mainly for martian checks

     Currently it only has all VxLan tunnel IPs*/

  struct hash *tip_hash;

  /* Static route configuration.  */

  struct bgp_table *route[AFI_MAX][SAFI_MAX];

  /* Aggregate address configuration.  */

  struct bgp_table *aggregate[AFI_MAX][SAFI_MAX];

  /* BGP routing information base.  */

  struct bgp_table *rib[AFI_MAX][SAFI_MAX];

  /* BGP table route-map.  */

  struct bgp_rmap table_map[AFI_MAX][SAFI_MAX];

  /* BGP redistribute configuration. */

  struct list *redist[AFI_MAX][ZEBRA_ROUTE_MAX];

  /* Allocate MPLS labels */

  uint8_t allocate_mpls_labels[AFI_MAX][SAFI_MAX];

  /* Tree for next-hop lookup cache. */

  struct bgp_label_per_nexthop_cache_head

    mpls_labels_per_nexthop[AFI_MAX];

  /* Allocate hash entries to store policy routing information

   * The hash are used to host pbr rules somewhere.

   * Actually, pbr will only be used by flowspec

   * those hash elements will have relationship together as

   * illustrated in below diagram:

   *

   *  pbr_action a <----- pbr_match i <--- pbr_match_entry 1..n

   *              <----- pbr_match j <--- pbr_match_entry 1..m

   *              <----- pbr_rule k

   *

   * - here in BGP structure, the list of match and actions will

   * stand for the list of ipset sets, and table_ids in the kernel

   * - the arrow above between pbr_match and pbr_action indicate

   * that a backpointer permits match to find the action

   * - the arrow betwen match_entry and match is a hash list

   * contained in match, that lists the whole set of entries

   */

  struct hash *pbr_match_hash;

  struct hash *pbr_rule_hash;

  struct hash *pbr_action_hash;

  /* timer to re-evaluate neighbor default-originate route-maps */

  struct event *t_rmap_def_originate_eval;

#define RMAP_DEFAULT_ORIGINATE_EVAL_TIMER 5

  /* BGP distance configuration.  */

  uint8_t distance_ebgp[AFI_MAX][SAFI_MAX];

  uint8_t distance_ibgp[AFI_MAX][SAFI_MAX];

  uint8_t distance_local[AFI_MAX][SAFI_MAX];

  /* BGP default local-preference.  */

  uint32_t default_local_pref;

  /* BGP default subgroup pkt queue max  */

  uint32_t default_subgroup_pkt_queue_max;

  /* BGP default timer.  */

  uint32_t default_holdtime;

  uint32_t default_keepalive;

  uint32_t default_connect_retry;

  uint32_t default_delayopen;

  /* BGP minimum holdtime.  */

  uint16_t default_min_holdtime;

  /* BGP graceful restart */

  uint32_t restart_time;

  uint32_t stalepath_time;

  uint32_t select_defer_time;

  struct graceful_restart_info gr_info[AFI_MAX][SAFI_MAX];

  uint32_t rib_stale_time;

  /* BGP Long-lived Graceful Restart */

  uint32_t llgr_stale_time;

#define BGP_ROUTE_SELECT_DELAY 1

#define BGP_MAX_BEST_ROUTE_SELECT 10000

  /* Maximum-paths configuration */

  struct bgp_maxpaths_cfg {

    uint16_t maxpaths_ebgp;

    uint16_t maxpaths_ibgp;

    bool same_clusterlen;

  } maxpaths[AFI_MAX][SAFI_MAX];

  _Atomic uint32_t wpkt_quanta; // max # packets to write per i/o cycle

  _Atomic uint32_t rpkt_quanta; // max # packets to read per i/o cycle

  /* Automatic coalesce adjust on/off */

  bool heuristic_coalesce;

  /* Actual coalesce time */

  uint32_t coalesce_time;

  /* Auto-shutdown new peers */

  bool autoshutdown;

  struct bgp_addpath_bgp_data tx_addpath;

#ifdef ENABLE_BGP_VNC

  struct rfapi_cfg *rfapi_cfg;

  struct rfapi *rfapi;

#endif

  /* EVPN related information */

  /* EVI hash table */

  struct hash *vnihash;

  /*

   * VNI hash table based on SVI ifindex as its key.

   * We use SVI ifindex as key to lookup a VNI table for gateway IP

   * overlay index recursive lookup.

   * For this purpose, a hashtable is added which optimizes this lookup.

   */

  struct hash *vni_svi_hash;

  /* EVPN enable - advertise gateway macip routes */

  int advertise_gw_macip;

  /* EVPN enable - advertise local VNIs and their MACs etc. */

  int advertise_all_vni;

  /* draft-ietf-idr-deprecate-as-set-confed-set

   * Reject aspaths with AS_SET and/or AS_CONFED_SET.

   */

  bool reject_as_sets;

  struct bgp_evpn_info *evpn_info;

  /* EVPN - use RFC 8365 to auto-derive RT */

  int advertise_autort_rfc8365;

  /*

   * Flooding mechanism for BUM packets for VxLAN-EVPN.

   */

  enum vxlan_flood_control vxlan_flood_ctrl;

  /* Hash table of Import RTs to EVIs */

  struct hash *import_rt_hash;

  /* Hash table of VRF import RTs to VRFs */

  struct hash *vrf_import_rt_hash;

  /* L3-VNI corresponding to this vrf */

  vni_t l3vni;

  /* router-mac to be used in mac-ip routes for this vrf */

  struct ethaddr rmac;

  /* originator ip - to be used as NH for type-5 routes */

  struct in_addr originator_ip;

  /* SVI associated with the L3-VNI corresponding to this vrf */

  ifindex_t l3vni_svi_ifindex;

  /* RB tree of ES-VRFs */

  struct bgp_es_vrf_rb_head es_vrf_rb_tree;

  /* Hash table of EVPN nexthops maintained per-tenant-VRF */

  struct hash *evpn_nh_table;

  /*

   * Flag resolve_overlay_index is used for recursive resolution

   * procedures for EVPN type-5 route's gateway IP overlay index.

   * When this flag is set, we build remote-ip-hash for

   * all L2VNIs and resolve overlay index nexthops using this hash.

   * Overlay index nexthops remain unresolved if this flag is not set.

   */

  bool resolve_overlay_index;

  /* vrf flags */

  uint32_t vrf_flags;

#define BGP_VRF_AUTO                        (1 << 0)

#define BGP_VRF_IMPORT_RT_CFGD              (1 << 1)

#define BGP_VRF_EXPORT_RT_CFGD              (1 << 2)

#define BGP_VRF_IMPORT_AUTO_RT_CFGD         (1 << 3) /* retain auto when cfgd */

#define BGP_VRF_EXPORT_AUTO_RT_CFGD         (1 << 4) /* retain auto when cfgd */

#define BGP_VRF_RD_CFGD                     (1 << 5)

#define BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY    (1 << 6)

/* per-VRF toVPN SID */

#define BGP_VRF_TOVPN_SID_AUTO              (1 << 7)

  /* unique ID for auto derivation of RD for this vrf */

  uint16_t vrf_rd_id;

  /* Automatically derived RD for this VRF */

  struct prefix_rd vrf_prd_auto;

  /* RD for this VRF */

  struct prefix_rd vrf_prd;

  char *vrf_prd_pretty;

  /* import rt list for the vrf instance */

  struct list *vrf_import_rtl;

  /* export rt list for the vrf instance */

  struct list *vrf_export_rtl;

  /* list of corresponding l2vnis (struct bgpevpn) */

  struct list *l2vnis;

  /* route map for advertise ipv4/ipv6 unicast (type-5 routes) */

  struct bgp_rmap adv_cmd_rmap[AFI_MAX][SAFI_MAX];

  struct vpn_policy vpn_policy[AFI_MAX];

  struct bgp_pbr_config *bgp_pbr_cfg;

  /* Count of peers in established state */

  uint32_t established_peers;

  /* Weighted ECMP related config. */

  enum bgp_link_bw_handling lb_handling;

  /* Process Queue for handling routes */

  struct work_queue *process_queue;

  bool fast_convergence;

  /* BGP Conditional advertisement */

  uint32_t condition_check_period;

  uint32_t condition_filter_count;

  struct event *t_condition_check;

  /* BGP VPN SRv6 backend */

  bool srv6_enabled;

  char srv6_locator_name[SRV6_LOCNAME_SIZE];

  struct list *srv6_locator_chunks;

  struct list *srv6_functions;

  uint32_t tovpn_sid_index; /* unset => set to 0 */

  struct in6_addr *tovpn_sid;

  struct srv6_locator_chunk *tovpn_sid_locator;

  uint32_t tovpn_sid_transpose_label;

  struct in6_addr *tovpn_zebra_vrf_sid_last_sent;

  /* TCP keepalive parameters for BGP connection */

  uint16_t tcp_keepalive_idle;

  uint16_t tcp_keepalive_intvl;

  uint16_t tcp_keepalive_probes;

  struct timeval ebgprequirespolicywarning;

#define FIFTEENMINUTE2USEC (int64_t)15 * 60 * 1000000

  bool allow_martian;

  enum asnotation_mode asnotation;

  QOBJ_FIELDS;

};

DECLARE_QOBJ_TYPE(bgp);

struct bgp_interface {

#define BGP_INTERFACE_MPLS_BGP_FORWARDING (1 << 0)

  uint32_t flags;

};

DECLARE_HOOK(bgp_inst_delete, (struct bgp *bgp), (bgp));

DECLARE_HOOK(bgp_inst_config_write,

    (struct bgp *bgp, struct vty *vty),

    (bgp, vty));

DECLARE_HOOK(bgp_config_end, (struct bgp *bgp), (bgp));

/* Thread callback information */

struct afi_safi_info {

  afi_t afi;

  safi_t safi;

  struct bgp *bgp;

};

#define BGP_ROUTE_ADV_HOLD(bgp) (bgp->main_peers_update_hold)

#define IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)                                        \

  (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT                           \

   || (bgp->inst_type == BGP_INSTANCE_TYPE_VRF                           \

       && bgp->vrf_id != VRF_UNKNOWN))

#define BGP_SELECT_DEFER_DISABLE(bgp)                                          \

  (CHECK_FLAG(bgp->flags, BGP_FLAG_SELECT_DEFER_DISABLE))

#define BGP_SUPPRESS_FIB_ENABLED(bgp)                                          \

  (CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_FIB_PENDING)                 \

   || bm->wait_for_fib)

/* BGP peer-group support. */

struct peer_group {

  /* Name of the peer-group. */

  char *name;

  /* Pointer to BGP.  */

  struct bgp *bgp;

  /* Peer-group client list. */

  struct list *peer;

  /** Dynamic neighbor listening ranges */

  struct list *listen_range[AFI_MAX];

  /* Peer-group config */

  struct peer *conf;

};

/* BGP Notify message format. */

struct bgp_notify {

  uint8_t code;

  uint8_t subcode;

  char *data;

  bgp_size_t length;

  uint8_t *raw_data;

  bool hard_reset;

};

/* Next hop self address. */

struct bgp_nexthop {

  struct interface *ifp;

  struct in_addr v4;

  struct in6_addr v6_global;

  struct in6_addr v6_local;

};

/* BGP addpath values */

#define BGP_ADDPATH_RX     1

#define BGP_ADDPATH_TX     2

#define BGP_ADDPATH_ID_LEN 4

#define BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE 1

/* Route map direction */

#define RMAP_IN  0

#define RMAP_OUT 1

#define RMAP_MAX 2

#define BGP_DEFAULT_TTL         1

#define BGP_GTSM_HOPS_DISABLED  0

#define BGP_GTSM_HOPS_CONNECTED 1

/* Advertise map */

#define CONDITION_NON_EXIST false

#define CONDITION_EXIST   true

enum update_type { UPDATE_TYPE_WITHDRAW, UPDATE_TYPE_ADVERTISE };

#include "filter.h"

/* BGP filter structure. */

struct bgp_filter {

  /* Distribute-list.  */

  struct {

    char *name;

    struct access_list *alist;

  } dlist[FILTER_MAX];

  /* Prefix-list.  */

  struct {

    char *name;

    struct prefix_list *plist;

  } plist[FILTER_MAX];

  /* Filter-list.  */

  struct {

    char *name;

    struct as_list *aslist;

  } aslist[FILTER_MAX];

  /* Route-map.  */

  struct {

    char *name;

    struct route_map *map;

  } map[RMAP_MAX];

  /* Unsuppress-map.  */

  struct {

    char *name;

    struct route_map *map;

  } usmap;

  /* Advertise-map */

  struct {

    char *aname;

    struct route_map *amap;

    bool condition;

    char *cname;

    struct route_map *cmap;

    enum update_type update_type;

  } advmap;

};

/* IBGP/EBGP identifier.  We also have a CONFED peer, which is to say,

   a peer who's AS is part of our Confederation.  */

enum bgp_peer_sort {

  BGP_PEER_UNSPECIFIED,

  BGP_PEER_IBGP,

  BGP_PEER_EBGP,

  BGP_PEER_INTERNAL,

  BGP_PEER_CONFED,

};

/* BGP message header and packet size.  */

#define BGP_MARKER_SIZE                   16

#define BGP_HEADER_SIZE                   19

#define BGP_STANDARD_MESSAGE_MAX_PACKET_SIZE 4096

#define BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE 65535

#define BGP_MAX_PACKET_SIZE BGP_EXTENDED_MESSAGE_MAX_PACKET_SIZE

#define BGP_MAX_PACKET_SIZE_OVERFLOW          1024

/*

 * Trigger delay for bgp_announce_route().

 */

#define BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS  100

#define BGP_ANNOUNCE_ROUTE_DELAY_MS        500

struct peer_af {

  /* back pointer to the peer */

  struct peer *peer;

  /* which subgroup the peer_af belongs to */

  struct update_subgroup *subgroup;

  /* for being part of an update subgroup's peer list */

  LIST_ENTRY(peer_af) subgrp_train;

  /* for being part of a packet's peer list */

  LIST_ENTRY(peer_af) pkt_train;

  struct bpacket *next_pkt_to_send;

  /*

   * Trigger timer for bgp_announce_route().

   */

  struct event *t_announce_route;

  afi_t afi;

  safi_t safi;

  int afid;

};

/* BGP GR per peer ds */

#define BGP_PEER_GR_MODE 5

#define BGP_PEER_GR_EVENT_CMD 6

enum peer_mode {

  PEER_HELPER = 0,

  PEER_GR,

  PEER_DISABLE,

  PEER_INVALID,

  PEER_GLOBAL_INHERIT /* This is the default mode */

};

enum peer_gr_command {

  PEER_GR_CMD = 0,

  NO_PEER_GR_CMD,

  PEER_DISABLE_CMD,

  NO_PEER_DISABLE_CMD,

  PEER_HELPER_CMD,

  NO_PEER_HELPER_CMD

};

typedef unsigned int  (*bgp_peer_gr_action_ptr)(struct peer *, int, int);

struct bgp_peer_gr {

  enum peer_mode next_state;

  bgp_peer_gr_action_ptr action_fun;

};

/*

 * BGP FSM event codes, per RFC 4271 ss. 8.1

 */

enum bgp_fsm_rfc_codes {

  BGP_FSM_ManualStart = 1,

  BGP_FSM_ManualStop = 2,

  BGP_FSM_AutomaticStart = 3,

  BGP_FSM_ManualStart_with_PassiveTcpEstablishment = 4,

  BGP_FSM_AutomaticStart_with_PassiveTcpEstablishment = 5,

  BGP_FSM_AutomaticStart_with_DampPeerOscillations = 6,

  BGP_FSM_AutomaticStart_with_DampPeerOscillations_and_PassiveTcpEstablishment =

    7,

  BGP_FSM_AutomaticStop = 8,

  BGP_FSM_ConnectRetryTimer_Expires = 9,

  BGP_FSM_HoldTimer_Expires = 10,

  BGP_FSM_KeepaliveTimer_Expires = 11,

  BGP_FSM_DelayOpenTimer_Expires = 12,

  BGP_FSM_IdleHoldTimer_Expires = 13,

  BGP_FSM_TcpConnection_Valid = 14,

  BGP_FSM_Tcp_CR_Invalid = 15,

  BGP_FSM_Tcp_CR_Acked = 16,

  BGP_FSM_TcpConnectionConfirmed = 17,

  BGP_FSM_TcpConnectionFails = 18,

  BGP_FSM_BGPOpen = 19,

  BGP_FSM_BGPOpen_with_DelayOpenTimer_running = 20,

  BGP_FSM_BGPHeaderErr = 21,

  BGP_FSM_BGPOpenMsgErr = 22,

  BGP_FSM_OpenCollisionDump = 23,

  BGP_FSM_NotifMsgVerErr = 24,

  BGP_FSM_NotifMsg = 25,

  BGP_FSM_KeepAliveMsg = 26,

  BGP_FSM_UpdateMsg = 27,

  BGP_FSM_UpdateMsgErr = 28

};

/*

 * BGP finite state machine events

 *

 * Note: these do not correspond to RFC-defined event codes. Those are

 * defined elsewhere.

 */

enum bgp_fsm_events {

  BGP_Start = 1,

  BGP_Stop,

  TCP_connection_open,

  TCP_connection_open_w_delay,

  TCP_connection_closed,

  TCP_connection_open_failed,

  TCP_fatal_error,

  ConnectRetry_timer_expired,

  Hold_Timer_expired,

  KeepAlive_timer_expired,

  DelayOpen_timer_expired,

  Receive_OPEN_message,

  Receive_KEEPALIVE_message,

  Receive_UPDATE_message,

  Receive_NOTIFICATION_message,

  Clearing_Completed,

  BGP_EVENTS_MAX,

};

/* BGP finite state machine status.  */

enum bgp_fsm_status {

  Idle = 1,

  Connect,

  Active,

  OpenSent,

  OpenConfirm,

  Established,

  Clearing,

  Deleted,

  BGP_STATUS_MAX,

};

#define PEER_HOSTNAME(peer) ((peer)->host ? (peer)->host : "(unknown peer)")

struct llgr_info {

  uint32_t stale_time;

  uint8_t flags;

};

/* BGP neighbor structure. */

struct peer {

  /* BGP structure.  */

  struct bgp *bgp;

  /* reference count, primarily to allow bgp_process'ing of route_node's

   * to be done after a struct peer is deleted.

   *

   * named 'lock' for hysterical reasons within Quagga.

   */

  int lock;

  /* BGP peer group.  */

  struct peer_group *group;

  /* BGP peer_af structures, per configured AF on this peer */

  struct peer_af *peer_af_array[BGP_AF_MAX];