diff options
Diffstat (limited to 'bgpd/bgp_evpn.c')
| -rw-r--r-- | bgpd/bgp_evpn.c | 2477 |
1 files changed, 2293 insertions, 184 deletions
diff --git a/bgpd/bgp_evpn.c b/bgpd/bgp_evpn.c index 0e191ffff1..d021def1b8 100644 --- a/bgpd/bgp_evpn.c +++ b/bgpd/bgp_evpn.c @@ -1,7 +1,8 @@ /* Ethernet-VPN Packet and vty Processing File * Copyright (C) 2016 6WIND + * Copyright (C) 2017 Cumulus Networks, Inc. * - * This file is part of FRRouting. + * This file is part of FRR. * * FRRouting is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -29,6 +30,7 @@ #include "hash.h" #include "jhash.h" #include "bitfield.h" +#include "zclient.h" #include "bgpd/bgp_attr_evpn.h" #include "bgpd/bgpd.h" @@ -40,6 +42,27 @@ #include "bgpd/bgp_evpn.h" #include "bgpd/bgp_evpn_private.h" #include "bgpd/bgp_ecommunity.h" +#include "bgpd/bgp_encap_types.h" +#include "bgpd/bgp_debug.h" +#include "bgpd/bgp_aspath.h" + +/* + * Definitions and external declarations. + */ +extern struct zclient *zclient; + +DEFINE_QOBJ_TYPE(bgpevpn) + + +/* + * Static function declarations + */ +static void +delete_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, + afi_t afi, safi_t safi, struct bgp_node *rn, + struct bgp_info **ri); +static int +delete_all_vni_routes (struct bgp *bgp, struct bgpevpn *vpn); /* * Private functions. @@ -113,11 +136,1757 @@ import_rt_hash_cmp (const void *p1, const void *p2) } /* + * Create a new import_rt + */ +static struct irt_node * +import_rt_new (struct bgp *bgp, struct ecommunity_val *rt) +{ + struct irt_node *irt; + + if (!bgp) + return NULL; + + irt = XCALLOC (MTYPE_BGP_EVPN_IMPORT_RT, sizeof (struct irt_node)); + if (!irt) + return NULL; + + irt->rt = *rt; + irt->vnis = list_new (); + + /* Add to hash */ + if (!hash_get(bgp->import_rt_hash, irt, hash_alloc_intern)) + { + XFREE(MTYPE_BGP_EVPN_IMPORT_RT, irt); + return NULL; + } + + return irt; +} + +/* + * Free the import rt node + */ +static void +import_rt_free (struct bgp *bgp, struct irt_node *irt) +{ + hash_release(bgp->import_rt_hash, irt); + XFREE(MTYPE_BGP_EVPN_IMPORT_RT, irt); +} + +/* + * Function to lookup Import RT node - used to map a RT to set of + * VNIs importing routes with that RT. + */ +static struct irt_node * +lookup_import_rt (struct bgp *bgp, struct ecommunity_val *rt) +{ + struct irt_node *irt; + struct irt_node tmp; + + memset(&tmp, 0, sizeof(struct irt_node)); + memcpy(&tmp.rt, rt, ECOMMUNITY_SIZE); + irt = hash_lookup(bgp->import_rt_hash, &tmp); + return irt; +} + +/* + * Is specified VNI present on the RT's list of "importing" VNIs? + */ +static int +is_vni_present_in_irt_vnis (struct list *vnis, struct bgpevpn *vpn) +{ + struct listnode *node, *nnode; + struct bgpevpn *tmp_vpn; + + for (ALL_LIST_ELEMENTS (vnis, node, nnode, tmp_vpn)) + { + if (tmp_vpn == vpn) + return 1; + } + + return 0; +} + +/* + * Compare Route Targets. + */ +static int +evpn_route_target_cmp (struct ecommunity *ecom1, struct ecommunity *ecom2) +{ + if (ecom1 && !ecom2) + return -1; + + if (!ecom1 && ecom2) + return 1; + + if (!ecom1 && !ecom2) + return 0; + + if (ecom1->str && !ecom2->str) + return -1; + + if (!ecom1->str && ecom2->str) + return 1; + + if (!ecom1->str && !ecom2->str) + return 0; + + return strcmp(ecom1->str, ecom2->str); +} + +/* + * Mask off global-admin field of specified extended community (RT), + * just retain the local-admin field. + */ +static inline void +mask_ecom_global_admin (struct ecommunity_val *dst, + struct ecommunity_val *src) +{ + u_char type; + + type = src->val[0]; + dst->val[0] = 0; + if (type == ECOMMUNITY_ENCODE_AS) + { + dst->val[2] = dst->val[3] = 0; + } + else if (type == ECOMMUNITY_ENCODE_AS4 || + type == ECOMMUNITY_ENCODE_IP) + { + dst->val[2] = dst->val[3] = 0; + dst->val[4] = dst->val[5] = 0; + } +} + +/* + * Map one RT to specified VNI. + */ +static void +map_vni_to_rt (struct bgp *bgp, struct bgpevpn *vpn, + struct ecommunity_val *eval) +{ + struct irt_node *irt; + struct ecommunity_val eval_tmp; + + /* If using "automatic" RT, we only care about the local-admin sub-field. + * This is to facilitate using VNI as the RT for EBGP peering too. + */ + memcpy (&eval_tmp, eval, ECOMMUNITY_SIZE); + if (!is_import_rt_configured (vpn)) + mask_ecom_global_admin (&eval_tmp, eval); + + irt = lookup_import_rt (bgp, &eval_tmp); + if (irt && irt->vnis) + if (is_vni_present_in_irt_vnis (irt->vnis, vpn)) + /* Already mapped. */ + return; + + if (!irt) + { + irt = import_rt_new (bgp, &eval_tmp); + assert (irt); + } + + /* Add VNI to the hash list for this RT. */ + listnode_add (irt->vnis, vpn); +} + +/* + * Unmap specified VNI from specified RT. If there are no other + * VNIs for this RT, then the RT hash is deleted. + */ +static void +unmap_vni_from_rt (struct bgp *bgp, struct bgpevpn *vpn, + struct irt_node *irt) +{ + /* Delete VNI from hash list for this RT. */ + listnode_delete (irt->vnis, vpn); + if (!listnode_head (irt->vnis)) + { + list_free (irt->vnis); + import_rt_free (bgp, irt); + } +} + +/* + * Create RT extended community automatically from passed information: + * of the form AS:VNI. + * NOTE: We use only the lower 16 bits of the AS. This is sufficient as + * the need is to get a RT value that will be unique across different + * VNIs but the same across routers (in the same AS) for a particular + * VNI. + */ +static void +form_auto_rt (struct bgp *bgp, struct bgpevpn *vpn, + struct list *rtl) +{ + struct ecommunity_val eval; + struct ecommunity *ecomadd; + + encode_route_target_as ((bgp->as & 0xFFFF), vpn->vni, &eval); + + ecomadd = ecommunity_new (); + ecommunity_add_val (ecomadd, &eval); + listnode_add_sort (rtl, ecomadd); +} + +/* + * Derive RD and RT for a VNI automatically. Invoked at the time of + * creation of a VNI. + */ +static void +derive_rd_rt_for_vni (struct bgp *bgp, struct bgpevpn *vpn) +{ + bgp_evpn_derive_auto_rd (bgp, vpn); + bgp_evpn_derive_auto_rt_import (bgp, vpn); + bgp_evpn_derive_auto_rt_export (bgp, vpn); +} + +/* + * Add (update) or delete MACIP from zebra. + */ +static int +bgp_zebra_send_remote_macip (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, + struct in_addr remote_vtep_ip, + int add) +{ + struct stream *s; + int ipa_len; + char buf1[ETHER_ADDR_STRLEN]; + char buf2[INET6_ADDRSTRLEN]; + char buf3[INET6_ADDRSTRLEN]; + + /* Check socket. */ + if (!zclient || zclient->sock < 0) + return 0; + + /* Don't try to register if Zebra doesn't know of this instance. */ + if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) + return 0; + + s = zclient->obuf; + stream_reset (s); + + zclient_create_header (s, add ? ZEBRA_REMOTE_MACIP_ADD : ZEBRA_REMOTE_MACIP_DEL, + bgp->vrf_id); + stream_putl(s, vpn->vni); + stream_put (s, &p->prefix.mac.octet, ETHER_ADDR_LEN); /* Mac Addr */ + /* IP address length and IP address, if any. */ + if (IS_EVPN_PREFIX_IPADDR_NONE(p)) + stream_putl(s, 0); + else + { + ipa_len = IS_EVPN_PREFIX_IPADDR_V4(p) ? + IPV4_MAX_BYTELEN : IPV6_MAX_BYTELEN; + stream_putl(s, ipa_len); + stream_put (s, &p->prefix.ip.ip.addr, ipa_len); + } + stream_put_in_addr(s, &remote_vtep_ip); + + stream_putw_at (s, 0, stream_get_endp (s)); + + if (bgp_debug_zebra (NULL)) + zlog_debug("Tx %s MACIP, VNI %u MAC %s IP %s remote VTEP %s", + add ? "ADD" : "DEL", vpn->vni, + prefix_mac2str (&p->prefix.mac, buf1, sizeof(buf1)), + ipaddr2str (&p->prefix.ip, buf3, sizeof(buf3)), + inet_ntop(AF_INET, &remote_vtep_ip, buf2, sizeof(buf2))); + + return zclient_send_message(zclient); +} + +/* + * Add (update) or delete remote VTEP from zebra. + */ +static int +bgp_zebra_send_remote_vtep (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, int add) +{ + struct stream *s; + + /* Check socket. */ + if (!zclient || zclient->sock < 0) + return 0; + + /* Don't try to register if Zebra doesn't know of this instance. */ + if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) + return 0; + + s = zclient->obuf; + stream_reset (s); + + zclient_create_header (s, add ? ZEBRA_REMOTE_VTEP_ADD : ZEBRA_REMOTE_VTEP_DEL, + bgp->vrf_id); + stream_putl(s, vpn->vni); + if (IS_EVPN_PREFIX_IPADDR_V4(p)) + stream_put_in_addr(s, &p->prefix.ip.ipaddr_v4); + else if (IS_EVPN_PREFIX_IPADDR_V6(p)) + { + zlog_err ("Bad remote IP when trying to %s remote VTEP for VNI %u", + add ? "ADD" : "DEL", vpn->vni); + return -1; + } + + stream_putw_at (s, 0, stream_get_endp (s)); + + if (bgp_debug_zebra (NULL)) + zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s", + add ? "ADD" : "DEL", vpn->vni, + inet_ntoa (p->prefix.ip.ipaddr_v4)); + + return zclient_send_message(zclient); +} + +/* + * Build extended communities for EVPN route. RT and ENCAP are + * applicable to all routes. + */ +static void +build_evpn_route_extcomm (struct bgpevpn *vpn, struct attr *attr) +{ + struct attr_extra *attre; + struct ecommunity ecom_encap; + struct ecommunity_val eval; + bgp_encap_types tnl_type; + struct listnode *node, *nnode; + struct ecommunity *ecom; + + attre = bgp_attr_extra_get (attr); + + /* Encap */ + tnl_type = BGP_ENCAP_TYPE_VXLAN; + memset (&ecom_encap, 0, sizeof (ecom_encap)); + encode_encap_extcomm (tnl_type, &eval); + ecom_encap.size = 1; + ecom_encap.val = (u_int8_t *)eval.val; + + /* Add Encap */ + attre->ecommunity = ecommunity_dup (&ecom_encap); + + /* Add the export RTs */ + for (ALL_LIST_ELEMENTS (vpn->export_rtl, node, nnode, ecom)) + attre->ecommunity = ecommunity_merge (attre->ecommunity, ecom); + + attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); +} + +/* + * Add MAC mobility extended community to attribute. + */ +static void +add_mac_mobility_to_attr (u_int32_t seq_num, struct attr *attr) +{ + struct attr_extra *attre; + struct ecommunity ecom_tmp; + struct ecommunity_val eval; + struct ecommunity *ecom_mm; + int i; + u_int8_t *pnt; + int type = 0; + int sub_type = 0; + + attre = bgp_attr_extra_get (attr); + + /* Build MM */ + encode_mac_mobility_extcomm (0, seq_num, &eval); + + /* Find current MM ecommunity */ + ecom_mm = NULL; + + if (attre->ecommunity) + { + for (i = 0; i < attre->ecommunity->size; i++) + { + pnt = attre->ecommunity->val + (i * 8); + type = *pnt++; + sub_type = *pnt++; + + if (type == ECOMMUNITY_ENCODE_EVPN && sub_type == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY) + { + ecom_mm = (struct ecommunity*) attre->ecommunity->val + (i * 8); + break; + } + } + } + + /* Update the existing MM ecommunity */ + if (ecom_mm) + { + memcpy(ecom_mm->val, eval.val, sizeof(char) * ECOMMUNITY_SIZE); + } + + /* Add MM to existing */ + else + { + memset (&ecom_tmp, 0, sizeof (ecom_tmp)); + ecom_tmp.size = 1; + ecom_tmp.val = (u_int8_t *)eval.val; + + attre->ecommunity = ecommunity_merge (attre->ecommunity, &ecom_tmp); + } +} + +/* Install EVPN route into zebra. */ +static int +evpn_zebra_install (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, struct in_addr remote_vtep_ip) +{ + int ret; + + if (p->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE) + ret = bgp_zebra_send_remote_macip (bgp, vpn, p, remote_vtep_ip, 1); + else + ret = bgp_zebra_send_remote_vtep (bgp, vpn, p, 1); + + return ret; +} + +/* Uninstall EVPN route from zebra. */ +static int +evpn_zebra_uninstall (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, struct in_addr remote_vtep_ip) +{ + int ret; + + if (p->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE) + ret = bgp_zebra_send_remote_macip (bgp, vpn, p, remote_vtep_ip, 0); + else + ret = bgp_zebra_send_remote_vtep (bgp, vpn, p, 0); + + return ret; +} + +/* + * Due to MAC mobility, the prior "local" best route has been supplanted + * by a "remote" best route. The prior route has to be deleted and withdrawn + * from peers. + */ +static void +evpn_delete_old_local_route (struct bgp *bgp, struct bgpevpn *vpn, + struct bgp_node *rn, struct bgp_info *old_local) +{ + struct bgp_node *global_rn; + struct bgp_info *ri; + afi_t afi = AFI_L2VPN; + safi_t safi = SAFI_EVPN; + + /* Locate route node in the global EVPN routing table. Note that + * this table is a 2-level tree (RD-level + Prefix-level) similar to + * L3VPN routes. + */ + global_rn = bgp_afi_node_lookup (bgp->rib[afi][safi], afi, safi, + (struct prefix *)&rn->p, &vpn->prd); + if (global_rn) + { + /* Delete route entry in the global EVPN table. */ + delete_evpn_route_entry (bgp, vpn, afi, safi, global_rn, &ri); + + /* Schedule for processing - withdraws to peers happen from + * this table. + */ + if (ri) + bgp_process (bgp, global_rn, afi, safi); + bgp_unlock_node (global_rn); + } + + /* Delete route entry in the VNI route table, caller to remove. */ + bgp_info_delete (rn, old_local); +} + +/* + * Calculate the best path for an EVPN route. Install/update best path in zebra, + * if appropriate. + */ +static int +evpn_route_select_install (struct bgp *bgp, struct bgpevpn *vpn, + struct bgp_node *rn) +{ + struct bgp_info *old_select, *new_select; + struct bgp_info_pair old_and_new; + afi_t afi = AFI_L2VPN; + safi_t safi = SAFI_EVPN; + int ret = 0; + + /* Compute the best path. */ + bgp_best_selection (bgp, rn, &bgp->maxpaths[afi][safi], + &old_and_new, afi, safi); + old_select = old_and_new.old; + new_select = old_and_new.new; + + /* If the best path hasn't changed - see if there is still something to update + * to zebra RIB. + */ + if (old_select && old_select == new_select && + old_select->type == ZEBRA_ROUTE_BGP && + old_select->sub_type == BGP_ROUTE_NORMAL && + !CHECK_FLAG(rn->flags, BGP_NODE_USER_CLEAR) && + !CHECK_FLAG(old_select->flags, BGP_INFO_ATTR_CHANGED) && + !bgp->addpath_tx_used[afi][safi]) + { + if (bgp_zebra_has_route_changed (rn, old_select)) + ret = evpn_zebra_install (bgp, vpn, (struct prefix_evpn *)&rn->p, + old_select->attr->nexthop); + UNSET_FLAG (old_select->flags, BGP_INFO_MULTIPATH_CHG); + bgp_zebra_clear_route_change_flags (rn); + return ret; + } + + /* If the user did a "clear" this flag will be set */ + UNSET_FLAG(rn->flags, BGP_NODE_USER_CLEAR); + + /* bestpath has changed; update relevant fields and install or uninstall + * into the zebra RIB. + */ + if (old_select || new_select) + bgp_bump_version(rn); + + if (old_select) + bgp_info_unset_flag (rn, old_select, BGP_INFO_SELECTED); + if (new_select) + { + bgp_info_set_flag (rn, new_select, BGP_INFO_SELECTED); + bgp_info_unset_flag (rn, new_select, BGP_INFO_ATTR_CHANGED); + UNSET_FLAG (new_select->flags, BGP_INFO_MULTIPATH_CHG); + } + + if (new_select + && new_select->type == ZEBRA_ROUTE_BGP + && new_select->sub_type == BGP_ROUTE_NORMAL) + { + ret = evpn_zebra_install (bgp, vpn, (struct prefix_evpn *) &rn->p, + new_select->attr->nexthop); + /* If an old best existed and it was a "local" route, the only reason + * it would be supplanted is due to MAC mobility procedures. So, we + * need to do an implicit delete and withdraw that route from peers. + */ + if (old_select + && old_select->peer == bgp->peer_self + && old_select->type == ZEBRA_ROUTE_BGP + && old_select->sub_type == BGP_ROUTE_STATIC) + evpn_delete_old_local_route (bgp, vpn, rn, old_select); + } + else + { + if (old_select + && old_select->type == ZEBRA_ROUTE_BGP + && old_select->sub_type == BGP_ROUTE_NORMAL) + ret = evpn_zebra_uninstall (bgp, vpn, (struct prefix_evpn *) &rn->p, + old_select->attr->nexthop); + } + + /* Clear any route change flags. */ + bgp_zebra_clear_route_change_flags (rn); + + /* Reap old select bgp_info, if it has been removed */ + if (old_select && CHECK_FLAG (old_select->flags, BGP_INFO_REMOVED)) + bgp_info_reap (rn, old_select); + + return ret; +} + +/* + * Create or update EVPN route entry. This could be in the VNI route table + * or the global route table. + */ +static int +update_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, afi_t afi, + safi_t safi, struct bgp_node *rn, struct attr *attr, + int add, int vni_table, struct bgp_info **ri) +{ + struct bgp_info *tmp_ri; + struct bgp_info *local_ri, *remote_ri; + struct attr *attr_new; + mpls_label_t label = MPLS_INVALID_LABEL; + int route_change = 1; + + *ri = NULL; + + /* See if this is an update of an existing route, or a new add. Also, + * identify if already known from remote, and if so, the one with the + * highest sequence number; this is only when adding to the VNI routing + * table. + */ + local_ri = remote_ri = NULL; + for (tmp_ri = rn->info; tmp_ri; tmp_ri = tmp_ri->next) + { + if (tmp_ri->peer == bgp->peer_self + && tmp_ri->type == ZEBRA_ROUTE_BGP + && tmp_ri->sub_type == BGP_ROUTE_STATIC) + local_ri = tmp_ri; + if (vni_table) + { + if (tmp_ri->type == ZEBRA_ROUTE_BGP + && tmp_ri->sub_type == BGP_ROUTE_NORMAL + && CHECK_FLAG (tmp_ri->flags, BGP_INFO_VALID)) + { + if (!remote_ri) + remote_ri = tmp_ri; + else if (mac_mobility_seqnum (tmp_ri->attr) > + mac_mobility_seqnum (remote_ri->attr)) + remote_ri = tmp_ri; + } + } + } + + /* If route doesn't exist already, create a new one, if told to. + * Otherwise act based on whether the attributes of the route have + * changed or not. + */ + if (!local_ri && !add) + return 0; + + if (!local_ri) + { + /* When learnt locally for the first time but already known from + * remote, we have to initiate appropriate MAC mobility steps. This + * is applicable when updating the VNI routing table. + */ + if (remote_ri) + { + u_int32_t cur_seqnum; + + /* Add MM extended community to route. */ + cur_seqnum = mac_mobility_seqnum (remote_ri->attr); + add_mac_mobility_to_attr (cur_seqnum + 1, attr); + } + + /* Add (or update) attribute to hash. */ + attr_new = bgp_attr_intern (attr); + + /* Extract MAC mobility sequence number, if any. */ + attr_new->extra->mm_seqnum = bgp_attr_mac_mobility_seqnum (attr_new); + + /* Create new route with its attribute. */ + tmp_ri = info_make (ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0, + bgp->peer_self, attr_new, rn); + SET_FLAG (tmp_ri->flags, BGP_INFO_VALID); + bgp_info_extra_get(tmp_ri); + + /* The VNI goes into the 'label' field of the route */ + vni2label (vpn->vni, &label); + + memcpy (&tmp_ri->extra->label, &label, BGP_LABEL_BYTES); + bgp_info_add (rn, tmp_ri); + } + else + { + tmp_ri = local_ri; + if (attrhash_cmp (tmp_ri->attr, attr) && + !CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED)) + route_change = 0; + else + { + /* The attribute has changed. */ + /* Add (or update) attribute to hash. */ + attr_new = bgp_attr_intern (attr); + bgp_info_set_flag (rn, tmp_ri, BGP_INFO_ATTR_CHANGED); + + /* Restore route, if needed. */ + if (CHECK_FLAG(tmp_ri->flags, BGP_INFO_REMOVED)) + bgp_info_restore(rn, tmp_ri); + + /* Unintern existing, set to new. */ + bgp_attr_unintern (&tmp_ri->attr); + tmp_ri->attr = attr_new; + tmp_ri->uptime = bgp_clock (); + } + } + + /* Return back the route entry. */ + *ri = tmp_ri; + return route_change; +} + +/* + * Create or update EVPN route (of type based on prefix) for specified VNI + * and schedule for processing. + */ +static int +update_evpn_route (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p) +{ + struct bgp_node *rn; + struct attr attr; + struct attr *attr_new; + struct bgp_info *ri; + afi_t afi = AFI_L2VPN; + safi_t safi = SAFI_EVPN; + int route_change; + + memset (&attr, 0, sizeof (struct attr)); + + /* Build path-attribute for this route. */ + bgp_attr_default_set (&attr, BGP_ORIGIN_IGP); + attr.nexthop = vpn->originator_ip; + attr.extra->mp_nexthop_global_in = vpn->originator_ip; + attr.extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; + + /* Set up RT and ENCAP extended community. */ + build_evpn_route_extcomm (vpn, &attr); + + /* First, create (or fetch) route node within the VNI. */ + /* NOTE: There is no RD here. */ + rn = bgp_node_get (vpn->route_table, (struct prefix *)p); + + /* Create or update route entry. */ + route_change = update_evpn_route_entry (bgp, vpn, afi, safi, + rn, &attr, 1, 1, &ri); + assert (ri); + attr_new = ri->attr; + + /* Perform route selection; this is just to set the flags correctly + * as local route in the VNI always wins. + */ + evpn_route_select_install (bgp, vpn, rn); + bgp_unlock_node (rn); + + /* If this is a new route or some attribute has changed, export the + * route to the global table. The route will be advertised to peers + * from there. Note that this table is a 2-level tree (RD-level + + * Prefix-level) similar to L3VPN routes. + */ + if (route_change) + { + struct bgp_info *global_ri; + + rn = bgp_afi_node_get (bgp->rib[afi][safi], afi, safi, + (struct prefix *)p, &vpn->prd); + update_evpn_route_entry (bgp, vpn, afi, safi, rn, + attr_new, 1, 0, &global_ri); + + /* Schedule for processing and unlock node. */ + bgp_process (bgp, rn, afi, safi); + bgp_unlock_node (rn); + } + + /* Unintern temporary. */ + aspath_unintern (&attr.aspath); + bgp_attr_extra_free (&attr); + + return 0; +} + +/* + * Delete EVPN route entry. This could be in the VNI route table + * or the global route table. + */ +static void +delete_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, + afi_t afi, safi_t safi, struct bgp_node *rn, + struct bgp_info **ri) +{ + struct bgp_info *tmp_ri; + + *ri = NULL; + + /* Now, find matching route. */ + for (tmp_ri = rn->info; tmp_ri; tmp_ri = tmp_ri->next) + if (tmp_ri->peer == bgp->peer_self + && tmp_ri->type == ZEBRA_ROUTE_BGP + && tmp_ri->sub_type == BGP_ROUTE_STATIC) + break; + + *ri = tmp_ri; + + /* Mark route for delete. */ + if (tmp_ri) + bgp_info_delete (rn, tmp_ri); +} + +/* + * Delete EVPN route (of type based on prefix) for specified VNI and + * schedule for processing. + */ +static int +delete_evpn_route (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p) +{ + struct bgp_node *rn, *global_rn; + struct bgp_info *ri; + afi_t afi = AFI_L2VPN; + safi_t safi = SAFI_EVPN; + + /* First, locate the route node within the VNI. If it doesn't exist, there + * is nothing further to do. + */ + /* NOTE: There is no RD here. */ + rn = bgp_node_lookup (vpn->route_table, (struct prefix *)p); + if (!rn) + return 0; + + /* Next, locate route node in the global EVPN routing table. Note that + * this table is a 2-level tree (RD-level + Prefix-level) similar to + * L3VPN routes. + */ + global_rn = bgp_afi_node_lookup (bgp->rib[afi][safi], afi, safi, + (struct prefix *)p, &vpn->prd); + if (global_rn) + { + /* Delete route entry in the global EVPN table. */ + delete_evpn_route_entry (bgp, vpn, afi, safi, global_rn, &ri); + + /* Schedule for processing - withdraws to peers happen from + * this table. + */ + if (ri) + bgp_process (bgp, global_rn, afi, safi); + bgp_unlock_node (global_rn); + } + + /* Delete route entry in the VNI route table. This can just be removed. */ + delete_evpn_route_entry (bgp, vpn, afi, safi, rn, &ri); + if (ri) + bgp_info_reap (rn, ri); + bgp_unlock_node (rn); + + return 0; +} + +/* + * Update all type-2 (MACIP) local routes for this VNI - these should also + * be scheduled for advertise to peers. + */ +static int +update_all_type2_routes (struct bgp *bgp, struct bgpevpn *vpn) +{ + afi_t afi; + safi_t safi; + struct bgp_node *rn; + struct bgp_info *ri; + struct attr attr; + struct attr *attr_new; + + afi = AFI_L2VPN; + safi = SAFI_EVPN; + memset (&attr, 0, sizeof (struct attr)); + + /* Build path-attribute - all type-2 routes for this VNI will share the + * same path attribute. + */ + bgp_attr_default_set (&attr, BGP_ORIGIN_IGP); + attr.nexthop = vpn->originator_ip; + attr.extra->mp_nexthop_global_in = vpn->originator_ip; + attr.extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; + + /* Set up RT, ENCAP extended community. */ + build_evpn_route_extcomm (vpn, &attr); + + /* Walk this VNI's route table and update local type-2 routes. For any + * routes updated, update corresponding entry in the global table too. + */ + for (rn = bgp_table_top (vpn->route_table); rn; rn = bgp_route_next (rn)) + { + struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p; + struct bgp_node *rd_rn; + struct bgp_info *global_ri; + + if (evp->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE) + continue; + + update_evpn_route_entry (bgp, vpn, afi, safi, rn, &attr, 0, 1, &ri); + + /* If a local route exists for this prefix, we need to update + * the global routing table too. + */ + if (!ri) + continue; + + /* Perform route selection; this is just to set the flags correctly + * as local route in the VNI always wins. + */ + evpn_route_select_install (bgp, vpn, rn); + + attr_new = ri->attr; + + /* Update route in global routing table. */ + rd_rn = bgp_afi_node_get (bgp->rib[afi][safi], afi, safi, + (struct prefix *)evp, &vpn->prd); + assert (rd_rn); + update_evpn_route_entry (bgp, vpn, afi, safi, rd_rn, + attr_new, 0, 0, &global_ri); + + /* Schedule for processing and unlock node. */ + bgp_process (bgp, rd_rn, afi, safi); + bgp_unlock_node (rd_rn); + } + + /* Unintern temporary. */ + aspath_unintern (&attr.aspath); + bgp_attr_extra_free (&attr); + + return 0; +} + +/* + * Delete all type-2 (MACIP) local routes for this VNI - only from the + * global routing table. These are also scheduled for withdraw from peers. + */ +static int +delete_global_type2_routes (struct bgp *bgp, struct bgpevpn *vpn) +{ + afi_t afi; + safi_t safi; + struct bgp_node *rdrn, *rn; + struct bgp_table *table; + struct bgp_info *ri; + + afi = AFI_L2VPN; + safi = SAFI_EVPN; + + rdrn = bgp_node_lookup (bgp->rib[afi][safi], (struct prefix *) &vpn->prd); + if (rdrn && rdrn->info) + { + table = (struct bgp_table *)rdrn->info; + for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn)) + { + struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p; + + if (evp->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE) + continue; + + delete_evpn_route_entry (bgp, vpn, afi, safi, rn, &ri); + if (ri) + bgp_process (bgp, rn, afi, safi); + } + } + + /* Unlock RD node. */ + if (rdrn) + bgp_unlock_node (rdrn); + + return 0; +} + +/* + * Delete all type-2 (MACIP) local routes for this VNI - from the global + * table as well as the per-VNI route table. + */ +static int +delete_all_type2_routes (struct bgp *bgp, struct bgpevpn *vpn) +{ + afi_t afi; + safi_t safi; + struct bgp_node *rn; + struct bgp_info *ri; + + afi = AFI_L2VPN; + safi = SAFI_EVPN; + + /* First, walk the global route table for this VNI's type-2 local routes. + * EVPN routes are a 2-level table, first get the RD table. + */ + delete_global_type2_routes (bgp, vpn); + + /* Next, walk this VNI's route table and delete local type-2 routes. */ + for (rn = bgp_table_top (vpn->route_table); rn; rn = bgp_route_next (rn)) + { + struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p; + + if (evp->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE) + continue; + + delete_evpn_route_entry (bgp, vpn, afi, safi, rn, &ri); + + /* Route entry in local table gets deleted immediately. */ + if (ri) + bgp_info_reap (rn, ri); + } + + return 0; +} + +/* + * Delete all routes in the per-VNI route table. + */ +static int +delete_all_vni_routes (struct bgp *bgp, struct bgpevpn *vpn) +{ + struct bgp_node *rn; + struct bgp_info *ri, *nextri; + + /* Walk this VNI's route table and delete all routes. */ + for (rn = bgp_table_top (vpn->route_table); rn; rn = bgp_route_next (rn)) + { + for (ri = rn->info; (ri != NULL) && (nextri = ri->next, 1); ri = nextri) + { + bgp_info_delete (rn, ri); + bgp_info_reap (rn, ri); + } + } + + return 0; +} + +/* + * Update (and advertise) local routes for a VNI. Invoked upon the VNI + * export RT getting modified or change to tunnel IP. Note that these + * situations need the route in the per-VNI table as well as the global + * table to be updated (as attributes change). + */ +static int +update_routes_for_vni (struct bgp *bgp, struct bgpevpn *vpn) +{ + int ret; + struct prefix_evpn p; + + /* Update and advertise the type-3 route (only one) followed by the + * locally learnt type-2 routes (MACIP) - for this VNI. + */ + build_evpn_type3_prefix (&p, vpn->originator_ip); + ret = update_evpn_route (bgp, vpn, &p); + if (ret) + return ret; + + return update_all_type2_routes (bgp, vpn); +} + +/* + * Delete (and withdraw) local routes for specified VNI from the global + * table and per-VNI table. After this, remove all other routes from + * the per-VNI table. Invoked upon the VNI being deleted or EVPN + * (advertise-all-vni) being disabled. + */ +static int +delete_routes_for_vni (struct bgp *bgp, struct bgpevpn *vpn) +{ + int ret; + struct prefix_evpn p; + + /* Delete and withdraw locally learnt type-2 routes (MACIP) + * followed by type-3 routes (only one) - for this VNI. + */ + ret = delete_all_type2_routes (bgp, vpn); + if (ret) + return ret; + + build_evpn_type3_prefix (&p, vpn->originator_ip); + ret = delete_evpn_route (bgp, vpn, &p); + if (ret) + return ret; + + /* Delete all routes from the per-VNI table. */ + return delete_all_vni_routes (bgp, vpn); +} + +/* + * There is a tunnel endpoint IP address change for this VNI, + * need to re-advertise routes with the new nexthop. + */ +static int +handle_tunnel_ip_change (struct bgp *bgp, struct bgpevpn *vpn, + struct in_addr originator_ip) +{ + struct prefix_evpn p; + + /* Need to withdraw type-3 route as the originator IP is part + * of the key. + */ + build_evpn_type3_prefix (&p, vpn->originator_ip); + delete_evpn_route (bgp, vpn, &p); + + /* Update the tunnel IP and re-advertise all routes for this VNI. */ + vpn->originator_ip = originator_ip; + return update_routes_for_vni (bgp, vpn); +} + +/* + * Install route entry into the VNI routing table and invoke route selection. + */ +static int +install_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, struct bgp_info *parent_ri) +{ + struct bgp_node *rn; + struct bgp_info *ri; + struct attr *attr_new; + int ret; + + /* Create (or fetch) route within the VNI. */ + /* NOTE: There is no RD here. */ + rn = bgp_node_get (vpn->route_table, (struct prefix *)p); + + /* Check if route entry is already present. */ + for (ri = rn->info; ri; ri = ri->next) + if (ri->extra && + (struct bgp_info *)ri->extra->parent == parent_ri) + break; + + if (!ri) + { + /* Add (or update) attribute to hash. */ + attr_new = bgp_attr_intern (parent_ri->attr); + + /* Create new route with its attribute. */ + ri = info_make (parent_ri->type, parent_ri->sub_type, 0, + parent_ri->peer, attr_new, rn); + SET_FLAG (ri->flags, BGP_INFO_VALID); + bgp_info_extra_get(ri); + ri->extra->parent = parent_ri; + if (parent_ri->extra) + memcpy (&ri->extra->label, &parent_ri->extra->label, BGP_LABEL_BYTES); + bgp_info_add (rn, ri); + } + else + { + if (attrhash_cmp (ri->attr, parent_ri->attr) && + !CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) + { + bgp_unlock_node (rn); + return 0; + } + /* The attribute has changed. */ + /* Add (or update) attribute to hash. */ + attr_new = bgp_attr_intern (parent_ri->attr); + + /* Restore route, if needed. */ + if (CHECK_FLAG(ri->flags, BGP_INFO_REMOVED)) + bgp_info_restore(rn, ri); + + /* Mark if nexthop has changed. */ + if (!IPV4_ADDR_SAME (&ri->attr->nexthop, &attr_new->nexthop)) + SET_FLAG(ri->flags, BGP_INFO_IGP_CHANGED); + + /* Unintern existing, set to new. */ + bgp_attr_unintern (&ri->attr); + ri->attr = attr_new; + ri->uptime = bgp_clock (); + } + + /* Perform route selection and update zebra, if required. */ + ret = evpn_route_select_install (bgp, vpn, rn); + + return ret; +} + +/* + * Uninstall route entry from the VNI routing table and send message + * to zebra, if appropriate. + */ +static int +uninstall_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, + struct prefix_evpn *p, struct bgp_info *parent_ri) +{ + struct bgp_node *rn; + struct bgp_info *ri; + int ret; + + /* Locate route within the VNI. */ + /* NOTE: There is no RD here. */ + rn = bgp_node_lookup (vpn->route_table, (struct prefix *)p); + if (!rn) + return 0; + + /* Find matching route entry. */ + for (ri = rn->info; ri; ri = ri->next) + if (ri->extra && + (struct bgp_info *)ri->extra->parent == parent_ri) + break; + + if (!ri) + return 0; + + /* Mark entry for deletion */ + bgp_info_delete (rn, ri); + + /* Perform route selection and update zebra, if required. */ + ret = evpn_route_select_install (bgp, vpn, rn); + + /* Unlock route node. */ + bgp_unlock_node (rn); + + return ret; +} + +/* + * Given a route entry and a VNI, see if this route entry should be + * imported into the VNI i.e., RTs match. + */ +static int +is_route_matching_for_vni (struct bgp *bgp, struct bgpevpn *vpn, + struct bgp_info *ri) +{ + struct attr *attr = ri->attr; + struct ecommunity *ecom; + int i; + + assert (attr); + /* Route should have valid RT to be even considered. */ + if (!(attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) + return 0; + + ecom = attr->extra->ecommunity; + if (!ecom || !ecom->size) + return 0; + + /* For each extended community RT, see if it matches this VNI. If any RT + * matches, we're done. + */ + for (i = 0; i < ecom->size; i++) + { + u_char *pnt; + u_char type, sub_type; + struct ecommunity_val *eval; + struct ecommunity_val eval_tmp; + struct irt_node *irt; + + /* Only deal with RTs */ + pnt = (ecom->val + (i * ECOMMUNITY_SIZE)); + eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE)); + type = *pnt++; + sub_type = *pnt++; + if (sub_type != ECOMMUNITY_ROUTE_TARGET) + continue; + + /* See if this RT matches specified VNIs import RTs */ + irt = lookup_import_rt (bgp, eval); + if (irt && irt->vnis) + if (is_vni_present_in_irt_vnis (irt->vnis, vpn)) + return 1; + + /* Also check for non-exact match. In this, we mask out the AS and + * only check on the local-admin sub-field. This is to facilitate using + * VNI as the RT for EBGP peering too. + */ + irt = NULL; + if (type == ECOMMUNITY_ENCODE_AS || + type == ECOMMUNITY_ENCODE_AS4 || + type == ECOMMUNITY_ENCODE_IP) + { + memcpy (&eval_tmp, eval, ECOMMUNITY_SIZE); + mask_ecom_global_admin (&eval_tmp, eval); + irt = lookup_import_rt (bgp, &eval_tmp); + } + if (irt && irt->vnis) + if (is_vni_present_in_irt_vnis (irt->vnis, vpn)) + return 1; + } + + return 0; +} + +/* + * Install or uninstall routes of specified type that are appropriate for this + * particular VNI. + */ +static int +install_uninstall_routes_for_vni (struct bgp *bgp, struct bgpevpn *vpn, + bgp_evpn_route_type rtype, int install) +{ + afi_t afi; + safi_t safi; + struct bgp_node *rd_rn, *rn; + struct bgp_table *table; + struct bgp_info *ri; + int ret; + + afi = AFI_L2VPN; + safi = SAFI_EVPN; + + /* Walk entire global routing table and evaluate routes which could be + * imported into this VPN. Note that we cannot just look at the routes for + * the VNI's RD - remote routes applicable for this VNI could have any RD. + */ + /* EVPN routes are a 2-level table. */ + for (rd_rn = bgp_table_top(bgp->rib[afi][safi]); rd_rn; rd_rn = bgp_route_next (rd_rn)) + { + table = (struct bgp_table *)(rd_rn->info); + if (!table) + continue; + + for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn)) + { + struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p; + + if (evp->prefix.route_type != rtype) + continue; + + for (ri = rn->info; ri; ri = ri->next) + { + /* Consider "valid" remote routes applicable for this VNI. */ + if (!(CHECK_FLAG (ri->flags, BGP_INFO_VALID) + && ri->type == ZEBRA_ROUTE_BGP + && ri->sub_type == BGP_ROUTE_NORMAL)) + continue; + + if (is_route_matching_for_vni (bgp, vpn, ri)) + { + if (install) + ret = install_evpn_route_entry (bgp, vpn, evp, ri); + else + ret = uninstall_evpn_route_entry (bgp, vpn, evp, ri); + + if (ret) + { + zlog_err ("%u: Failed to %s EVPN %s route in VNI %u", + bgp->vrf_id, install ? "install" : "uninstall", + rtype == BGP_EVPN_MAC_IP_ROUTE ? \ + "MACIP" : "IMET", vpn->vni); + return ret; + } + } + } + } + } + + return 0; +} + +/* + * Install any existing remote routes applicable for this VNI into its + * routing table. This is invoked when a VNI becomes "live" or its Import + * RT is changed. + */ +static int +install_routes_for_vni (struct bgp *bgp, struct bgpevpn *vpn) +{ + int ret; + + /* Install type-3 routes followed by type-2 routes - the ones applicable + * for this VNI. + */ + ret = install_uninstall_routes_for_vni (bgp, vpn, BGP_EVPN_IMET_ROUTE, 1); + if (ret) + return ret; + + return install_uninstall_routes_for_vni (bgp, vpn, BGP_EVPN_MAC_IP_ROUTE, 1); +} + +/* + * Install or uninstall route in matching VNIs (list). + */ +static int +install_uninstall_route_in_vnis (struct bgp *bgp, afi_t afi, safi_t safi, + struct prefix_evpn *evp, struct bgp_info *ri, + struct list *vnis, int install) +{ + struct bgpevpn *vpn; + struct listnode *node, *nnode; + + for (ALL_LIST_ELEMENTS (vnis, node, nnode, vpn)) + { + int ret; + + if (!is_vni_live (vpn)) + continue; + + if (install) + ret = install_evpn_route_entry (bgp, vpn, evp, ri); + else + ret = uninstall_evpn_route_entry (bgp, vpn, evp, ri); + + if (ret) + { + zlog_err ("%u: Failed to %s EVPN %s route in VNI %u", + bgp->vrf_id, install ? "install" : "uninstall", + evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE ? \ + "MACIP" : "IMET", vpn->vni); + return ret; + } + } + + return 0; +} + +/* + * Install or uninstall route for appropriate VNIs. + */ +static int +install_uninstall_evpn_route (struct bgp *bgp, afi_t afi, safi_t safi, + struct prefix *p, struct bgp_info *ri, + int import) +{ + struct prefix_evpn *evp = (struct prefix_evpn *)p; + struct attr *attr = ri->attr; + struct ecommunity *ecom; + int i; + + assert (attr); + + /* Only type-2 and type-3 routes go into a L2 VNI. */ + if (!(evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE || + evp->prefix.route_type == BGP_EVPN_IMET_ROUTE)) + return 0; + + /* If we don't have Route Target, nothing much to do. */ + if (!(attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) + return 0; + + ecom = attr->extra->ecommunity; + if (!ecom || !ecom->size) + return -1; + + /* For each extended community RT, see which VNIs match and import + * the route into matching VNIs. + */ + for (i = 0; i < ecom->size; i++) + { + u_char *pnt; + u_char type, sub_type; + struct ecommunity_val *eval; + struct ecommunity_val eval_tmp; + struct irt_node *irt; + + /* Only deal with RTs */ + pnt = (ecom->val + (i * ECOMMUNITY_SIZE)); + eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE)); + type = *pnt++; + sub_type = *pnt++; + if (sub_type != ECOMMUNITY_ROUTE_TARGET) + continue; + + /* Are we interested in this RT? */ + irt = lookup_import_rt (bgp, eval); + if (irt && irt->vnis) + install_uninstall_route_in_vnis (bgp, afi, safi, evp, + ri, irt->vnis, import); + + /* Also check for non-exact match. In this, we mask out the AS and + * only check on the local-admin sub-field. This is to facilitate using + * VNI as the RT for EBGP peering too. + */ + irt = NULL; + if (type == ECOMMUNITY_ENCODE_AS || + type == ECOMMUNITY_ENCODE_AS4 || + type == ECOMMUNITY_ENCODE_IP) + { + memcpy (&eval_tmp, eval, ECOMMUNITY_SIZE); + mask_ecom_global_admin (&eval_tmp, eval); + irt = lookup_import_rt (bgp, &eval_tmp); + } + if (irt && irt->vnis) + install_uninstall_route_in_vnis (bgp, afi, safi, evp, + ri, irt->vnis, import); + } + + return 0; +} + +/* + * Process received EVPN type-2 route (advertise or withdraw). + */ +static int +process_type2_route (struct peer *peer, afi_t afi, safi_t safi, + struct attr *attr, u_char *pfx, int psize, + u_int32_t addpath_id) +{ + struct prefix_rd prd; + struct prefix_evpn p; + u_char ipaddr_len; + u_char macaddr_len; + mpls_label_t *label_pnt; + int ret; + + /* Type-2 route should be either 33, 37 or 49 bytes or an + * additional 3 bytes if there is a second label (VNI): + * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1), + * MAC Addr (6), IP len (1), IP (0, 4 or 16), + * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3) + */ + if (psize != 33 && psize != 37 && psize != 49 && + psize != 36 && psize != 40 && psize != 52) + { + zlog_err ("%u:%s - Rx EVPN Type-2 NLRI with invalid length %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + + /* Make prefix_rd */ + prd.family = AF_UNSPEC; + prd.prefixlen = 64; + memcpy (&prd.val, pfx, 8); + pfx += 8; + + /* Make EVPN prefix. */ + memset (&p, 0, sizeof (struct prefix_evpn)); + p.family = AF_ETHERNET; + p.prefixlen = EVPN_TYPE_2_ROUTE_PREFIXLEN; + p.prefix.route_type = BGP_EVPN_MAC_IP_ROUTE; + + /* Skip over Ethernet Seg Identifier for now. */ + pfx += 10; + + /* Skip over Ethernet Tag for now. */ + pfx += 4; + + /* Get the MAC Addr len */ + macaddr_len = *pfx++; + + /* Get the MAC Addr */ + if (macaddr_len == (ETHER_ADDR_LEN * 8)) + { + memcpy (&p.prefix.mac.octet, pfx, ETHER_ADDR_LEN); + pfx += ETHER_ADDR_LEN; + } + else + { + zlog_err ("%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d", + peer->bgp->vrf_id, peer->host, macaddr_len); + return -1; + } + + + /* Get the IP. */ + ipaddr_len = *pfx++; + if (ipaddr_len != 0 && + ipaddr_len != IPV4_MAX_BITLEN && + ipaddr_len != IPV6_MAX_BITLEN) + { + zlog_err ("%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d", + peer->bgp->vrf_id, peer->host, ipaddr_len); + return -1; + } + + if (ipaddr_len) + { + ipaddr_len /= 8; /* Convert to bytes. */ + p.prefix.ip.ipa_type = (ipaddr_len == IPV4_MAX_BYTELEN) ? + IPADDR_V4 : IPADDR_V6; + memcpy (&p.prefix.ip.ip.addr, pfx, ipaddr_len); + } + pfx += ipaddr_len; + + /* Get the VNI (in MPLS label field). */ + /* Note: We ignore the second VNI, if any. */ + label_pnt = (mpls_label_t *) pfx; + + /* Process the route. */ + if (attr) + ret = bgp_update (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, label_pnt, 0, NULL); + else + ret = bgp_withdraw (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, label_pnt, NULL); + return ret; +} + +/* + * Process received EVPN type-3 route (advertise or withdraw). + */ +static int +process_type3_route (struct peer *peer, afi_t afi, safi_t safi, + struct attr *attr, u_char *pfx, int psize, + u_int32_t addpath_id) +{ + struct prefix_rd prd; + struct prefix_evpn p; + u_char ipaddr_len; + int ret; + + /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4), + * IP len (1) and IP (4 or 16). + */ + if (psize != 17 && psize != 29) + { + zlog_err ("%u:%s - Rx EVPN Type-3 NLRI with invalid length %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + + /* Make prefix_rd */ + prd.family = AF_UNSPEC; + prd.prefixlen = 64; + memcpy (&prd.val, pfx, 8); + pfx += 8; + + /* Make EVPN prefix. */ + memset (&p, 0, sizeof (struct prefix_evpn)); + p.family = AF_ETHERNET; + p.prefixlen = EVPN_TYPE_3_ROUTE_PREFIXLEN; + p.prefix.route_type = BGP_EVPN_IMET_ROUTE; + + /* Skip over Ethernet Tag for now. */ + pfx += 4; + + /* Get the IP. */ + ipaddr_len = *pfx++; + if (ipaddr_len == IPV4_MAX_BITLEN) + { + p.prefix.ip.ipa_type = IPADDR_V4; + memcpy (&p.prefix.ip.ip.addr, pfx, IPV4_MAX_BYTELEN); + } + else + { + zlog_err ("%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d", + peer->bgp->vrf_id, peer->host, ipaddr_len); + return -1; + } + + /* Process the route. */ + if (attr) + ret = bgp_update (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, NULL, 0, NULL); + else + ret = bgp_withdraw (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, NULL, NULL); + return ret; +} + +/* + * Process received EVPN type-5 route (advertise or withdraw). + */ +static int +process_type5_route (struct peer *peer, afi_t afi, safi_t safi, + struct attr *attr, u_char *pfx, int psize, + u_int32_t addpath_id, int withdraw) +{ + struct prefix_rd prd; + struct prefix_evpn p; + struct bgp_route_evpn evpn; + u_char ippfx_len; + u_int32_t eth_tag; + mpls_label_t *label_pnt; + int ret; + + /* Type-5 route should be 34 or 58 bytes: + * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16), + * GW (4 or 16) and VNI (3). + * Note that the IP and GW should both be IPv4 or both IPv6. + */ + if (psize != 34 && psize != 58) + { + zlog_err ("%u:%s - Rx EVPN Type-5 NLRI with invalid length %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + + /* Make prefix_rd */ + prd.family = AF_UNSPEC; + prd.prefixlen = 64; + memcpy (&prd.val, pfx, 8); + pfx += 8; + + /* Make EVPN prefix. */ + memset (&p, 0, sizeof (struct prefix_evpn)); + p.family = AF_ETHERNET; + p.prefix.route_type = BGP_EVPN_IP_PREFIX_ROUTE; + + /* Additional information outside of prefix - ESI and GW IP */ + memset(&evpn, 0, sizeof(evpn)); + + /* Fetch ESI */ + memcpy (&evpn.eth_s_id.val, pfx, 10); + pfx += 10; + + /* Fetch Ethernet Tag. */ + memcpy (ð_tag, pfx, 4); + p.prefix.eth_tag = ntohl (eth_tag); + pfx += 4; + + /* Fetch IP prefix length. */ + ippfx_len = *pfx++; + if (ippfx_len > IPV6_MAX_BITLEN) + { + zlog_err ("%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d", + peer->bgp->vrf_id, peer->host, ippfx_len); + return -1; + } + p.prefix.ip_prefix_length = ippfx_len; + + /* Determine IPv4 or IPv6 prefix */ + /* Since the address and GW are from the same family, this just becomes + * a simple check on the total size. + */ + if (psize == 34) + { + SET_IPADDR_V4 (&p.prefix.ip); + memcpy (&p.prefix.ip.ipaddr_v4, pfx, 4); + pfx += 4; + memcpy (&evpn.gw_ip.ipv4, pfx, 4); + pfx += 4; + p.prefixlen = PREFIX_LEN_ROUTE_TYPE_5_IPV4; + } + else + { + SET_IPADDR_V6 (&p.prefix.ip); + memcpy (&p.prefix.ip.ipaddr_v6, pfx, 16); + pfx += 16; + memcpy (&evpn.gw_ip.ipv6, pfx, 16); + pfx += 16; + p.prefixlen = PREFIX_LEN_ROUTE_TYPE_5_IPV6; + } + + label_pnt = (mpls_label_t *) pfx; + + /* Process the route. */ + if (!withdraw) + ret = bgp_update (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, label_pnt, 0, &evpn); + else + ret = bgp_withdraw (peer, (struct prefix *)&p, addpath_id, attr, afi, safi, + ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, label_pnt, &evpn); + + return ret; +} + +static void +evpn_mpattr_encode_type5 (struct stream *s, struct prefix *p, + struct prefix_rd *prd, mpls_label_t * label, + struct attr *attr) +{ + int len; + char temp[16]; + struct evpn_addr *p_evpn_p; + + memset(&temp, 0, 16); + if (p->family != AF_ETHERNET) + return; + p_evpn_p = &(p->u.prefix_evpn); + + if (IS_IPADDR_V4(&p_evpn_p->ip)) + len = 8; /* ipv4 */ + else + len = 32; /* ipv6 */ + stream_putc(s, BGP_EVPN_IP_PREFIX_ROUTE); + /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */ + stream_putc(s, 8 + 10 + 4 + 1 + len + 3); + stream_put(s, prd->val, 8); + if (attr && attr->extra) + stream_put(s, &(attr->extra->evpn_overlay.eth_s_id), 10); + else + stream_put(s, &temp, 10); + stream_putl(s, p_evpn_p->eth_tag); + stream_putc(s, p_evpn_p->ip_prefix_length); + if (IS_IPADDR_V4(&p_evpn_p->ip)) + stream_put_ipv4(s, p_evpn_p->ip.ipaddr_v4.s_addr); + else + stream_put(s, &p_evpn_p->ip.ipaddr_v6, 16); + if (attr && attr->extra) + { + if (IS_IPADDR_V4(&p_evpn_p->ip)) + stream_put_ipv4(s, attr->extra->evpn_overlay.gw_ip.ipv4. s_addr); + else + stream_put(s, &(attr->extra->evpn_overlay.gw_ip.ipv6), 16); + } + else + { + if (IS_IPADDR_V4(&p_evpn_p->ip)) + stream_put_ipv4(s, 0); + else + stream_put(s, &temp, 16); + } + + if (label) + stream_put(s, label, 3); + else + stream_put3(s, 0); +} + +/* * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled. */ static void cleanup_vni_on_disable (struct hash_backet *backet, struct bgp *bgp) { + struct bgpevpn *vpn = (struct bgpevpn *) backet->data; + + /* Remove EVPN routes and schedule for processing. */ + delete_routes_for_vni (bgp, vpn); + + /* Clear "live" flag and see if hash needs to be freed. */ + UNSET_FLAG (vpn->flags, VNI_FLAG_LIVE); + if (!is_vni_configured (vpn)) + bgp_evpn_free (bgp, vpn); } /* @@ -126,6 +1895,11 @@ cleanup_vni_on_disable (struct hash_backet *backet, struct bgp *bgp) static void free_vni_entry (struct hash_backet *backet, struct bgp *bgp) { + struct bgpevpn *vpn; + + vpn = (struct bgpevpn *) backet->data; + delete_all_vni_routes (bgp, vpn); + bgp_evpn_free(bgp, vpn); } @@ -133,194 +1907,529 @@ free_vni_entry (struct hash_backet *backet, struct bgp *bgp) * Public functions. */ +/* + * Encode EVPN prefix in Update (MP_REACH) + */ +void +bgp_evpn_encode_prefix (struct stream *s, struct prefix *p, + struct prefix_rd *prd, mpls_label_t *label, + struct attr *attr, int addpath_encode, + u_int32_t addpath_tx_id) +{ + struct prefix_evpn *evp = (struct prefix_evpn *)p; + int ipa_len = 0; + + if (addpath_encode) + stream_putl (s, addpath_tx_id); + + /* Route type */ + stream_putc (s, evp->prefix.route_type); + + switch (evp->prefix.route_type) + { + case BGP_EVPN_MAC_IP_ROUTE: + if (IS_EVPN_PREFIX_IPADDR_V4(evp)) + ipa_len = IPV4_MAX_BYTELEN; + else if (IS_EVPN_PREFIX_IPADDR_V6(evp)) + ipa_len = IPV6_MAX_BYTELEN; + stream_putc (s, 33 + ipa_len); // 1 VNI + stream_put (s, prd->val, 8); /* RD */ + stream_put (s, 0, 10); /* ESI */ + stream_putl (s, 0); /* Ethernet Tag ID */ + stream_putc (s, 8*ETHER_ADDR_LEN); /* Mac Addr Len - bits */ + stream_put (s, evp->prefix.mac.octet, 6); /* Mac Addr */ + stream_putc (s, 8*ipa_len); /* IP address Length */ + if (ipa_len) + stream_put (s, &evp->prefix.ip.ip.addr, ipa_len); /* IP */ + stream_put (s, label, BGP_LABEL_BYTES); /* VNI is contained in 'tag' */ + break; + + case BGP_EVPN_IMET_ROUTE: + stream_putc (s, 17); // TODO: length - assumes IPv4 address + stream_put (s, prd->val, 8); /* RD */ + stream_putl (s, 0); /* Ethernet Tag ID */ + stream_putc (s, IPV4_MAX_BITLEN); /* IP address Length - bits */ + /* Originating Router's IP Addr */ + stream_put_in_addr (s, &evp->prefix.ip.ipaddr_v4); + break; + + case BGP_EVPN_IP_PREFIX_ROUTE: + /* TODO: AddPath support. */ + evpn_mpattr_encode_type5 (s, p, prd, label, attr); + break; + + default: + break; + } +} + int bgp_nlri_parse_evpn(struct peer *peer, struct attr *attr, - struct bgp_nlri *packet, int withdraw) -{ - u_char *pnt; - u_char *lim; - struct prefix p; - struct prefix_rd prd; - struct evpn_addr *p_evpn_p; - struct bgp_route_evpn evpn; - uint8_t route_type, route_length; - mpls_label_t label; - u_int32_t addpath_id = 0; - - /* Check peer status. */ - if (peer->status != Established) - return 0; - - /* Make prefix_rd */ - prd.family = AF_UNSPEC; - prd.prefixlen = 64; - - p_evpn_p = &p.u.prefix_evpn; - pnt = packet->nlri; - lim = pnt + packet->length; - while (pnt < lim) { - /* clear evpn structure */ - memset(&evpn, 0, sizeof(evpn)); - - /* Clear prefix structure. */ - memset(&p, 0, sizeof(struct prefix)); - memset(&evpn.gw_ip, 0, sizeof(union gw_addr)); - memset(&evpn.eth_s_id, 0, sizeof(struct eth_segment_id)); - - /* Fetch Route Type */ - route_type = *pnt++; - route_length = *pnt++; - /* simply ignore. goto next route type if any */ - if (route_type != EVPN_IP_PREFIX) { - if (pnt + route_length > lim) { - zlog_err - ("not enough bytes for New Route Type left in NLRI?"); - return -1; - } - pnt += route_length; - continue; - } - - /* Fetch RD */ - if (pnt + 8 > lim) { - zlog_err("not enough bytes for RD left in NLRI?"); - return -1; - } - - /* Copy routing distinguisher to rd. */ - memcpy(&prd.val, pnt, 8); - pnt += 8; - - /* Fetch ESI */ - if (pnt + 10 > lim) { - zlog_err("not enough bytes for ESI left in NLRI?"); - return -1; - } - memcpy(&evpn.eth_s_id.val, pnt, 10); - pnt += 10; - - /* Fetch Ethernet Tag */ - if (pnt + 4 > lim) { - zlog_err("not enough bytes for Eth Tag left in NLRI?"); - return -1; - } - - if (route_type == EVPN_IP_PREFIX) { - p_evpn_p->route_type = route_type; - memcpy(&(p_evpn_p->eth_tag), pnt, 4); - p_evpn_p->eth_tag = ntohl(p_evpn_p->eth_tag); - pnt += 4; - - /* Fetch IP prefix length. */ - p_evpn_p->ip_prefix_length = *pnt++; - - if (p_evpn_p->ip_prefix_length > 128) { - zlog_err("invalid prefixlen %d in EVPN NLRI?", - p.prefixlen); - return -1; - } - /* determine IPv4 or IPv6 prefix */ - if (route_length - 4 - 10 - 8 - - 3 /* label to be read */ >= 32) { - SET_IPADDR_V6 (&p_evpn_p->ip); - memcpy(&(p_evpn_p->ip.ipaddr_v6), pnt, 16); - pnt += 16; - memcpy(&evpn.gw_ip.ipv6, pnt, 16); - pnt += 16; - } else { - SET_IPADDR_V4 (&p_evpn_p->ip); - memcpy(&(p_evpn_p->ip.ipaddr_v4), pnt, 4); - pnt += 4; - memcpy(&evpn.gw_ip.ipv4, pnt, 4); - pnt += 4; - } - p.family = AFI_L2VPN; - if (IS_IPADDR_V4(&p_evpn_p->ip)) - p.prefixlen = - (u_char) PREFIX_LEN_ROUTE_TYPE_5_IPV4; - else - p.prefixlen = PREFIX_LEN_ROUTE_TYPE_5_IPV6; - p.family = AF_ETHERNET; - } - - /* Fetch Label */ - if (pnt + BGP_LABEL_BYTES > lim) { - zlog_err("not enough bytes for Label left in NLRI?"); - return -1; - } - - memcpy(&label, pnt, BGP_LABEL_BYTES); - bgp_set_valid_label(&label); - pnt += BGP_LABEL_BYTES; - - if (!withdraw) { - bgp_update(peer, &p, addpath_id, attr, AFI_L2VPN, - SAFI_EVPN, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, - &prd, &label, 0, &evpn); - } else { - bgp_withdraw(peer, &p, addpath_id, attr, AFI_L2VPN, - SAFI_EVPN, ZEBRA_ROUTE_BGP, - BGP_ROUTE_NORMAL, &prd, &label, &evpn); - } - } - - /* Packet length consistency check. */ - if (pnt != lim) - return -1; - return 0; + struct bgp_nlri *packet, int withdraw) +{ + u_char *pnt; + u_char *lim; + afi_t afi; + safi_t safi; + u_int32_t addpath_id; + int addpath_encoded; + int psize = 0; + u_char rtype; + u_char rlen; + struct prefix p; + + /* Check peer status. */ + if (peer->status != Established) + { + zlog_err ("%u:%s - EVPN update received in state %d", + peer->bgp->vrf_id, peer->host, peer->status); + return -1; + } + + /* Start processing the NLRI - there may be multiple in the MP_REACH */ + pnt = packet->nlri; + lim = pnt + packet->length; + afi = packet->afi; + safi = packet->safi; + addpath_id = 0; + + addpath_encoded = (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) && + CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV)); + + for (; pnt < lim; pnt += psize) + { + /* Clear prefix structure. */ + memset (&p, 0, sizeof (struct prefix)); + + /* Deal with path-id if AddPath is supported. */ + if (addpath_encoded) + { + /* When packet overflow occurs return immediately. */ + if (pnt + BGP_ADDPATH_ID_LEN > lim) + return -1; + + addpath_id = ntohl(*((uint32_t*) pnt)); + pnt += BGP_ADDPATH_ID_LEN; + } + + /* All EVPN NLRI types start with type and length. */ + if (pnt + 2 > lim) + return -1; + + rtype = *pnt++; + psize = rlen = *pnt++; + + /* When packet overflow occur return immediately. */ + if (pnt + psize > lim) + return -1; + + switch (rtype) + { + case BGP_EVPN_MAC_IP_ROUTE: + if (process_type2_route (peer, afi, safi, + withdraw ? NULL : attr, + pnt, psize, addpath_id)) + { + zlog_err ("%u:%s - Error in processing EVPN type-2 NLRI size %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + break; + + case BGP_EVPN_IMET_ROUTE: + if (process_type3_route (peer, afi, safi, + withdraw ? NULL : attr, + pnt, psize, addpath_id)) + { + zlog_err ("%u:%s - Error in processing EVPN type-3 NLRI size %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + break; + + case BGP_EVPN_IP_PREFIX_ROUTE: + if (process_type5_route (peer, afi, safi, attr, + pnt, psize, addpath_id, withdraw)) + { + zlog_err ("%u:%s - Error in processing EVPN type-5 NLRI size %d", + peer->bgp->vrf_id, peer->host, psize); + return -1; + } + break; + + default: + break; + } + + } + + /* Packet length consistency check. */ + if (pnt != lim) + return -1; + + return 0; } + +/* + * Map the RTs (configured or automatically derived) of a VNI to the VNI. + * The mapping will be used during route processing. + */ +void +bgp_evpn_map_vni_to_its_rts (struct bgp *bgp, struct bgpevpn *vpn) +{ + int i; + struct ecommunity_val *eval; + struct listnode *node, *nnode; + struct ecommunity *ecom; + + for (ALL_LIST_ELEMENTS (vpn->import_rtl, node, nnode, ecom)) + { + for (i = 0; i < ecom->size; i++) + { + eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE)); + map_vni_to_rt (bgp, vpn, eval); + } + } +} + +/* + * Unmap the RTs (configured or automatically derived) of a VNI from the VNI. + */ +void +bgp_evpn_unmap_vni_from_its_rts (struct bgp *bgp, struct bgpevpn *vpn) +{ + int i; + struct ecommunity_val *eval; + struct listnode *node, *nnode; + struct ecommunity *ecom; + + for (ALL_LIST_ELEMENTS (vpn->import_rtl, node, nnode, ecom)) + { + for (i = 0; i < ecom->size; i++) + { + struct irt_node *irt; + struct ecommunity_val eval_tmp; + + eval = (struct ecommunity_val *) (ecom->val + (i * ECOMMUNITY_SIZE)); + /* If using "automatic" RT, we only care about the local-admin sub-field. + * This is to facilitate using VNI as the RT for EBGP peering too. + */ + memcpy (&eval_tmp, eval, ECOMMUNITY_SIZE); + if (!is_import_rt_configured (vpn)) + mask_ecom_global_admin (&eval_tmp, eval); + + irt = lookup_import_rt (bgp, &eval_tmp); + if (irt) + unmap_vni_from_rt (bgp, vpn, irt); + } + } +} + +/* + * Derive Import RT automatically for VNI and map VNI to RT. + * The mapping will be used during route processing. + */ +void +bgp_evpn_derive_auto_rt_import (struct bgp *bgp, struct bgpevpn *vpn) +{ + form_auto_rt (bgp, vpn, vpn->import_rtl); + UNSET_FLAG (vpn->flags, VNI_FLAG_IMPRT_CFGD); + + /* Map RT to VNI */ + bgp_evpn_map_vni_to_its_rts (bgp, vpn); +} + +/* + * Derive Export RT automatically for VNI. + */ void -bgp_packet_mpattr_route_type_5(struct stream *s, - struct prefix *p, struct prefix_rd *prd, - mpls_label_t *label, struct attr *attr) -{ - int len; - char temp[16]; - struct evpn_addr *p_evpn_p; - - memset(&temp, 0, 16); - if (p->family != AF_ETHERNET) - return; - p_evpn_p = &(p->u.prefix_evpn); - if (IS_IPADDR_V4(&p_evpn_p->ip)) - len = 8; /* ipv4 */ - else - len = 32; /* ipv6 */ - stream_putc(s, EVPN_IP_PREFIX); - stream_putc(s, - 8 /* RD */ + 10 /* ESI */ + 4 /* EthTag */ + 1 + len + - 3 /* label */ ); - stream_put(s, prd->val, 8); - if (attr && attr->extra) - stream_put(s, &(attr->extra->evpn_overlay.eth_s_id), 10); - else - stream_put(s, &temp, 10); - stream_putl(s, p_evpn_p->eth_tag); - stream_putc(s, p_evpn_p->ip_prefix_length); - if (IS_IPADDR_V4(&p_evpn_p->ip)) - stream_put_ipv4(s, p_evpn_p->ip.ipaddr_v4.s_addr); - else - stream_put(s, &p_evpn_p->ip.ipaddr_v6, 16); - if (attr && attr->extra) { - if (IS_IPADDR_V4(&p_evpn_p->ip)) - stream_put_ipv4(s, - attr->extra->evpn_overlay.gw_ip.ipv4. - s_addr); - else - stream_put(s, &(attr->extra->evpn_overlay.gw_ip.ipv6), - 16); - } else { - if (IS_IPADDR_V4(&p_evpn_p->ip)) - stream_put_ipv4(s, 0); - else - stream_put(s, &temp, 16); - } - if (label) - stream_put(s, label, 3); - else - stream_put3(s, 0); - return; +bgp_evpn_derive_auto_rt_export (struct bgp *bgp, struct bgpevpn *vpn) +{ + form_auto_rt (bgp, vpn, vpn->export_rtl); + UNSET_FLAG (vpn->flags, VNI_FLAG_EXPRT_CFGD); +} + +/* + * Derive RD automatically for VNI using passed information - it + * is of the form RouterId:unique-id-for-vni. + */ +void +bgp_evpn_derive_auto_rd (struct bgp *bgp, struct bgpevpn *vpn) +{ + char buf[100]; + + vpn->prd.family = AF_UNSPEC; + vpn->prd.prefixlen = 64; + sprintf (buf, "%s:%hu", inet_ntoa (bgp->router_id), vpn->rd_id); + str2prefix_rd (buf, &vpn->prd); + UNSET_FLAG (vpn->flags, VNI_FLAG_RD_CFGD); +} + +/* + * Lookup VNI. + */ +struct bgpevpn * +bgp_evpn_lookup_vni (struct bgp *bgp, vni_t vni) +{ + struct bgpevpn *vpn; + struct bgpevpn tmp; + + memset(&tmp, 0, sizeof(struct bgpevpn)); + tmp.vni = vni; + vpn = hash_lookup (bgp->vnihash, &tmp); + return vpn; +} + +/* + * Create a new vpn - invoked upon configuration or zebra notification. + */ +struct bgpevpn * +bgp_evpn_new (struct bgp *bgp, vni_t vni, struct in_addr originator_ip) +{ + struct bgpevpn *vpn; + + if (!bgp) + return NULL; + + vpn = XCALLOC (MTYPE_BGP_EVPN, sizeof (struct bgpevpn)); + if (!vpn) + return NULL; + + /* Set values - RD and RT set to defaults. */ + vpn->vni = vni; + vpn->originator_ip = originator_ip; + + /* Initialize route-target import and export lists */ + vpn->import_rtl = list_new (); + vpn->import_rtl->cmp = (int (*)(void *, void *)) evpn_route_target_cmp; + vpn->export_rtl = list_new (); + vpn->export_rtl->cmp = (int (*)(void *, void *)) evpn_route_target_cmp; + bf_assign_index(bgp->rd_idspace, vpn->rd_id); + derive_rd_rt_for_vni (bgp, vpn); + + /* Initialize EVPN route table. */ + vpn->route_table = bgp_table_init (AFI_L2VPN, SAFI_EVPN); + + /* Add to hash */ + if (!hash_get(bgp->vnihash, vpn, hash_alloc_intern)) + { + XFREE(MTYPE_BGP_EVPN, vpn); + return NULL; + } + QOBJ_REG (vpn, bgpevpn); + return vpn; +} + +/* + * Free a given VPN - called in multiple scenarios such as zebra + * notification, configuration being deleted, advertise-all-vni disabled etc. + * This just frees appropriate memory, caller should have taken other + * needed actions. + */ +void +bgp_evpn_free (struct bgp *bgp, struct bgpevpn *vpn) +{ + bgp_table_unlock (vpn->route_table); + bgp_evpn_unmap_vni_from_its_rts (bgp, vpn); + list_delete (vpn->import_rtl); + list_delete (vpn->export_rtl); + vpn->import_rtl = NULL; + vpn->export_rtl = NULL; + bf_release_index(bgp->rd_idspace, vpn->rd_id); + hash_release (bgp->vnihash, vpn); + QOBJ_UNREG (vpn); + XFREE(MTYPE_BGP_EVPN, vpn); +} + +/* + * Import route into matching VNI(s). + */ +int +bgp_evpn_import_route (struct bgp *bgp, afi_t afi, safi_t safi, + struct prefix *p, struct bgp_info *ri) +{ + return install_uninstall_evpn_route (bgp, afi, safi, p, ri, 1); +} + +/* + * Unimport route from matching VNI(s). + */ +int +bgp_evpn_unimport_route (struct bgp *bgp, afi_t afi, safi_t safi, + struct prefix *p, struct bgp_info *ri) +{ + return install_uninstall_evpn_route (bgp, afi, safi, p, ri, 0); +} + +/* + * Handle del of a local MACIP. + */ +int +bgp_evpn_local_macip_del (struct bgp *bgp, vni_t vni, + struct ethaddr *mac, struct ipaddr *ip) +{ + struct bgpevpn *vpn; + struct prefix_evpn p; + + if (!bgp->vnihash) + { + zlog_err ("%u: VNI hash not created", bgp->vrf_id); + return -1; + } + + /* Lookup VNI hash - should exist. */ + vpn = bgp_evpn_lookup_vni (bgp, vni); + if (!vpn || !is_vni_live (vpn)) + { + zlog_warn ("%u: VNI hash entry for VNI %u %s at MACIP DEL", + bgp->vrf_id, vni, vpn ? "not live" : "not found"); + return -1; + } + + /* Remove EVPN type-2 route and schedule for processing. */ + build_evpn_type2_prefix (&p, mac, ip); + delete_evpn_route (bgp, vpn, &p); + + return 0; +} + +/* + * Handle add of a local MACIP. + */ +int +bgp_evpn_local_macip_add (struct bgp *bgp, vni_t vni, + struct ethaddr *mac, struct ipaddr *ip) +{ + struct bgpevpn *vpn; + struct prefix_evpn p; + + if (!bgp->vnihash) + { + zlog_err ("%u: VNI hash not created", bgp->vrf_id); + return -1; + } + + /* Lookup VNI hash - should exist. */ + vpn = bgp_evpn_lookup_vni (bgp, vni); + if (!vpn || !is_vni_live (vpn)) + { + zlog_warn ("%u: VNI hash entry for VNI %u %s at MACIP ADD", + bgp->vrf_id, vni, vpn ? "not live" : "not found"); + return -1; + } + + /* Create EVPN type-2 route and schedule for processing. */ + build_evpn_type2_prefix (&p, mac, ip); + if (update_evpn_route (bgp, vpn, &p)) + { + char buf[ETHER_ADDR_STRLEN]; + char buf2[INET6_ADDRSTRLEN]; + + zlog_err ("%u:Failed to create Type-2 route, VNI %u MAC %s IP %s", + bgp->vrf_id, vpn->vni, + prefix_mac2str (mac, buf, sizeof (buf)), + ipaddr2str (ip, buf2, sizeof(buf2))); + return -1; + } + + return 0; +} + +/* + * Handle del of a local VNI. + */ +int +bgp_evpn_local_vni_del (struct bgp *bgp, vni_t vni) +{ + struct bgpevpn *vpn; + + if (!bgp->vnihash) + { + zlog_err ("%u: VNI hash not created", bgp->vrf_id); + return -1; + } + + /* Locate VNI hash */ + vpn = bgp_evpn_lookup_vni (bgp, vni); + if (!vpn) + { + zlog_warn ("%u: VNI hash entry for VNI %u not found at DEL", + bgp->vrf_id, vni); + return 0; + } + + /* Remove all local EVPN routes and schedule for processing (to + * withdraw from peers). + */ + delete_routes_for_vni (bgp, vpn); + + /* Clear "live" flag and see if hash needs to be freed. */ + UNSET_FLAG (vpn->flags, VNI_FLAG_LIVE); + if (!is_vni_configured (vpn)) + bgp_evpn_free (bgp, vpn); + + return 0; +} + +/* + * Handle add (or update) of a local VNI. The only VNI change we care + * about is change to local-tunnel-ip. + */ +int +bgp_evpn_local_vni_add (struct bgp *bgp, vni_t vni, struct in_addr originator_ip) +{ + struct bgpevpn *vpn; + struct prefix_evpn p; + + if (!bgp->vnihash) + { + zlog_err ("%u: VNI hash not created", bgp->vrf_id); + return -1; + } + + /* Lookup VNI. If present and no change, exit. */ + vpn = bgp_evpn_lookup_vni (bgp, vni); + if (vpn && is_vni_live (vpn)) + { + if (IPV4_ADDR_SAME (&vpn->originator_ip, &originator_ip)) + /* Probably some other param has changed that we don't care about. */ + return 0; + + /* Local tunnel endpoint IP address has changed */ + return handle_tunnel_ip_change (bgp, vpn, originator_ip); + } + + /* Create or update as appropriate. */ + if (!vpn) + { + vpn = bgp_evpn_new (bgp, vni, originator_ip); + if (!vpn) + { + zlog_err ("%u: Failed to allocate VNI entry for VNI %u - at Add", + bgp->vrf_id, vni); + return -1; + } + } + + /* Mark as "live" */ + SET_FLAG (vpn->flags, VNI_FLAG_LIVE); + + /* Create EVPN type-3 route and schedule for processing. */ + build_evpn_type3_prefix (&p, vpn->originator_ip); + if (update_evpn_route (bgp, vpn, &p)) + { + zlog_err ("%u: Type3 route creation failure for VNI %u", + bgp->vrf_id, vni); + return -1; + } + + /* If we have learnt and retained remote routes (VTEPs, MACs) for this VNI, + * install them. + */ + install_routes_for_vni (bgp, vpn); + + return 0; } /* |