bgpd/bgp_evpn_private.h

   1 /* BGP EVPN internal definitions
   2  * Copyright (C) 2017 Cumulus Networks, Inc.
   3  *
   4  * This file is part of FRR.
   5  *
   6  * FRR 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
   9  * later version.
  10  *
  11  * FRR 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.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with FRR; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #ifndef _BGP_EVPN_PRIVATE_H
  23 #define _BGP_EVPN_PRIVATE_H
  24
  25 #include "vxlan.h"
  26 #include "zebra.h"
  27
  28 #include "bgpd/bgpd.h"
  29 #include "bgpd/bgp_ecommunity.h"
  30
  31 #define RT_ADDRSTRLEN                    28
  32
  33 /* EVPN prefix lengths. */
  34 #define EVPN_TYPE_2_ROUTE_PREFIXLEN      224
  35 #define EVPN_TYPE_3_ROUTE_PREFIXLEN      224
  36
  37 /* EVPN route types. */
  38 typedef enum {
  39         BGP_EVPN_AD_ROUTE = 1,    /* Ethernet Auto-Discovery (A-D) route */
  40         BGP_EVPN_MAC_IP_ROUTE,    /* MAC/IP Advertisement route */
  41         BGP_EVPN_IMET_ROUTE,      /* Inclusive Multicast Ethernet Tag route */
  42         BGP_EVPN_ES_ROUTE,      /* Ethernet Segment route */
  43         BGP_EVPN_IP_PREFIX_ROUTE, /* IP Prefix route */
  44 } bgp_evpn_route_type;
  45
  46 /*
  47  * Hash table of EVIs. Right now, the only type of EVI supported is with
  48  * VxLAN encapsulation, hence each EVI corresponds to a L2 VNI.
  49  * The VNIs are not "created" through BGP but through some other interface
  50  * on the system. This table stores VNIs that BGP comes to know as present
  51  * on the system (through interaction with zebra) as well as pre-configured
  52  * VNIs (which need to be defined in the system to become "live").
  53  */
  54 struct bgpevpn {
  55         vni_t vni;
  56         u_int32_t flags;
  57 #define VNI_FLAG_CFGD              0x1  /* VNI is user configured */
  58 #define VNI_FLAG_LIVE              0x2  /* VNI is "live" */
  59 #define VNI_FLAG_RD_CFGD           0x4  /* RD is user configured. */
  60 #define VNI_FLAG_IMPRT_CFGD        0x8  /* Import RT is user configured */
  61 #define VNI_FLAG_EXPRT_CFGD        0x10 /* Export RT is user configured */
  62
  63         /* Flag to indicate if we are advertising the g/w mac ip for this VNI*/
  64         u_int8_t advertise_gw_macip;
  65
  66         /* Id for deriving the RD automatically for this VNI */
  67         u_int16_t rd_id;
  68
  69         /* RD for this VNI. */
  70         struct prefix_rd prd;
  71
  72         /* Route type 3 field */
  73         struct in_addr originator_ip;
  74
  75         /* Import and Export RTs. */
  76         struct list *import_rtl;
  77         struct list *export_rtl;
  78
  79         /* Route table for EVPN routes for this VNI. */
  80         struct bgp_table *route_table;
  81
  82         QOBJ_FIELDS
  83 };
  84
  85 DECLARE_QOBJ_TYPE(bgpevpn)
  86
  87 /* Mapping of Import RT to VNIs.
  88  * The Import RTs of all VNIs are maintained in a hash table with each
  89  * RT linking to all VNIs that will import routes matching this RT.
  90  */
  91 struct irt_node {
  92         /* RT */
  93         struct ecommunity_val rt;
  94
  95         /* List of VNIs importing routes matching this RT. */
  96         struct list *vnis;
  97 };
  98
  99 #define RT_TYPE_IMPORT 1
 100 #define RT_TYPE_EXPORT 2
 101 #define RT_TYPE_BOTH   3
 102
 103 static inline int is_vni_configured(struct bgpevpn *vpn)
 104 {
 105         return (CHECK_FLAG(vpn->flags, VNI_FLAG_CFGD));
 106 }
 107
 108 static inline int is_vni_live(struct bgpevpn *vpn)
 109 {
 110         return (CHECK_FLAG(vpn->flags, VNI_FLAG_LIVE));
 111 }
 112
 113 static inline int is_rd_configured(struct bgpevpn *vpn)
 114 {
 115         return (CHECK_FLAG(vpn->flags, VNI_FLAG_RD_CFGD));
 116 }
 117
 118 static inline int bgp_evpn_rd_matches_existing(struct bgpevpn *vpn,
 119                                                struct prefix_rd *prd)
 120 {
 121         return (memcmp(&vpn->prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
 122 }
 123
 124 static inline int is_import_rt_configured(struct bgpevpn *vpn)
 125 {
 126         return (CHECK_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD));
 127 }
 128
 129 static inline int is_export_rt_configured(struct bgpevpn *vpn)
 130 {
 131         return (CHECK_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD));
 132 }
 133
 134 static inline int is_vni_param_configured(struct bgpevpn *vpn)
 135 {
 136         return (is_rd_configured(vpn) || is_import_rt_configured(vpn)
 137                 || is_export_rt_configured(vpn));
 138 }
 139
 140 static inline void vni2label(vni_t vni, mpls_label_t *label)
 141 {
 142         u_char *tag = (u_char *)label;
 143         tag[0] = (vni >> 16) & 0xFF;
 144         tag[1] = (vni >> 8) & 0xFF;
 145         tag[2] = vni & 0xFF;
 146 }
 147
 148 static inline vni_t label2vni(mpls_label_t *label)
 149 {
 150         u_char *tag = (u_char *)label;
 151         vni_t vni;
 152
 153         vni = ((u_int32_t)*tag++ << 16);
 154         vni |= (u_int32_t)*tag++ << 8;
 155         vni |= (u_int32_t)(*tag & 0xFF);
 156
 157         return vni;
 158 }
 159
 160 static inline void encode_mac_mobility_extcomm(int static_mac, u_int32_t seq,
 161                                                struct ecommunity_val *eval)
 162 {
 163         memset(eval, 0, sizeof(*eval));
 164         eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
 165         eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY;
 166         if (static_mac)
 167                 eval->val[2] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY_FLAG_STICKY;
 168         eval->val[4] = (seq >> 24) & 0xff;
 169         eval->val[5] = (seq >> 16) & 0xff;
 170         eval->val[6] = (seq >> 8) & 0xff;
 171         eval->val[7] = seq & 0xff;
 172 }
 173
 174 static inline void build_evpn_type2_prefix(struct prefix_evpn *p,
 175                                            struct ethaddr *mac,
 176                                            struct ipaddr *ip)
 177 {
 178         memset(p, 0, sizeof(struct prefix_evpn));
 179         p->family = AF_EVPN;
 180         p->prefixlen = EVPN_TYPE_2_ROUTE_PREFIXLEN;
 181         p->prefix.route_type = BGP_EVPN_MAC_IP_ROUTE;
 182         memcpy(&p->prefix.mac.octet, mac->octet, ETH_ALEN);
 183         p->prefix.ip.ipa_type = IPADDR_NONE;
 184         if (ip)
 185                 memcpy(&p->prefix.ip, ip, sizeof(*ip));
 186 }
 187
 188 static inline void build_evpn_type3_prefix(struct prefix_evpn *p,
 189                                            struct in_addr originator_ip)
 190 {
 191         memset(p, 0, sizeof(struct prefix_evpn));
 192         p->family = AF_EVPN;
 193         p->prefixlen = EVPN_TYPE_3_ROUTE_PREFIXLEN;
 194         p->prefix.route_type = BGP_EVPN_IMET_ROUTE;
 195         p->prefix.ip.ipa_type = IPADDR_V4;
 196         p->prefix.ip.ipaddr_v4 = originator_ip;
 197 }
 198
 199
 200 extern int bgp_evpn_handle_export_rt_change(struct bgp *bgp,
 201                                             struct bgpevpn *vpn);
 202 extern void bgp_evpn_handle_rd_change(struct bgp *bgp, struct bgpevpn *vpn,
 203                                       int withdraw);
 204 extern int bgp_evpn_install_routes(struct bgp *bgp, struct bgpevpn *vpn);
 205 extern int bgp_evpn_uninstall_routes(struct bgp *bgp, struct bgpevpn *vpn);
 206 extern void bgp_evpn_map_vni_to_its_rts(struct bgp *bgp, struct bgpevpn *vpn);
 207 extern void bgp_evpn_unmap_vni_from_its_rts(struct bgp *bgp,
 208                                             struct bgpevpn *vpn);
 209 extern void bgp_evpn_derive_auto_rt_import(struct bgp *bgp,
 210                                            struct bgpevpn *vpn);
 211 extern void bgp_evpn_derive_auto_rt_export(struct bgp *bgp,
 212                                            struct bgpevpn *vpn);
 213 extern void bgp_evpn_derive_auto_rd(struct bgp *bgp, struct bgpevpn *vpn);
 214 extern struct bgpevpn *bgp_evpn_lookup_vni(struct bgp *bgp, vni_t vni);
 215 extern struct bgpevpn *bgp_evpn_new(struct bgp *bgp, vni_t vni,
 216                                     struct in_addr originator_ip);
 217 extern void bgp_evpn_free(struct bgp *bgp, struct bgpevpn *vpn);
 218 #endif /* _BGP_EVPN_PRIVATE_H */