bgpd/bgp_nexthop.c

   1 /* BGP nexthop scan
   2  * Copyright (C) 2000 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "thread.h"
  25 #include "prefix.h"
  26 #include "zclient.h"
  27 #include "stream.h"
  28 #include "network.h"
  29 #include "log.h"
  30 #include "memory.h"
  31 #include "hash.h"
  32 #include "jhash.h"
  33 #include "nexthop.h"
  34 #include "queue.h"
  35 #include "filter.h"
  36 #include "printfrr.h"
  37
  38 #include "bgpd/bgpd.h"
  39 #include "bgpd/bgp_route.h"
  40 #include "bgpd/bgp_attr.h"
  41 #include "bgpd/bgp_nexthop.h"
  42 #include "bgpd/bgp_nht.h"
  43 #include "bgpd/bgp_debug.h"
  44 #include "bgpd/bgp_damp.h"
  45 #include "bgpd/bgp_fsm.h"
  46 #include "bgpd/bgp_vty.h"
  47 #include "bgpd/bgp_rd.h"
  48
  49 DEFINE_MTYPE_STATIC(BGPD, MARTIAN_STRING, "BGP Martian Addr Intf String");
  50
  51 int bgp_nexthop_cache_compare(const struct bgp_nexthop_cache *a,
  52                               const struct bgp_nexthop_cache *b)
  53 {
  54         if (a->srte_color < b->srte_color)
  55                 return -1;
  56         if (a->srte_color > b->srte_color)
  57                 return 1;
  58
  59         if (a->ifindex < b->ifindex)
  60                 return -1;
  61         if (a->ifindex > b->ifindex)
  62                 return 1;
  63
  64         return prefix_cmp(&a->prefix, &b->prefix);
  65 }
  66
  67 void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
  68 {
  69         nexthops_free(bnc->nexthop);
  70 }
  71
  72 struct bgp_nexthop_cache *bnc_new(struct bgp_nexthop_cache_head *tree,
  73                                   struct prefix *prefix, uint32_t srte_color,
  74                                   ifindex_t ifindex)
  75 {
  76         struct bgp_nexthop_cache *bnc;
  77
  78         bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
  79                       sizeof(struct bgp_nexthop_cache));
  80         bnc->prefix = *prefix;
  81         bnc->ifindex = ifindex;
  82         bnc->srte_color = srte_color;
  83         bnc->tree = tree;
  84         LIST_INIT(&(bnc->paths));
  85         bgp_nexthop_cache_add(tree, bnc);
  86
  87         return bnc;
  88 }
  89
  90 bool bnc_existing_for_prefix(struct bgp_nexthop_cache *bnc)
  91 {
  92         struct bgp_nexthop_cache *bnc_tmp;
  93
  94         frr_each (bgp_nexthop_cache, bnc->tree, bnc_tmp) {
  95                 if (bnc_tmp == bnc)
  96                         continue;
  97                 if (prefix_cmp(&bnc->prefix, &bnc_tmp->prefix) == 0)
  98                         return true;
  99         }
 100         return false;
 101 }
 102
 103 void bnc_free(struct bgp_nexthop_cache *bnc)
 104 {
 105         bnc_nexthop_free(bnc);
 106         bgp_nexthop_cache_del(bnc->tree, bnc);
 107         XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
 108 }
 109
 110 struct bgp_nexthop_cache *bnc_find(struct bgp_nexthop_cache_head *tree,
 111                                    struct prefix *prefix, uint32_t srte_color,
 112                                    ifindex_t ifindex)
 113 {
 114         struct bgp_nexthop_cache bnc = {};
 115
 116         if (!tree)
 117                 return NULL;
 118
 119         bnc.prefix = *prefix;
 120         bnc.srte_color = srte_color;
 121         bnc.ifindex = ifindex;
 122         return bgp_nexthop_cache_find(tree, &bnc);
 123 }
 124
 125 /* Reset and free all BGP nexthop cache. */
 126 static void bgp_nexthop_cache_reset(struct bgp_nexthop_cache_head *tree)
 127 {
 128         struct bgp_nexthop_cache *bnc;
 129
 130         while (bgp_nexthop_cache_count(tree) > 0) {
 131                 bnc = bgp_nexthop_cache_first(tree);
 132
 133                 while (!LIST_EMPTY(&(bnc->paths))) {
 134                         struct bgp_path_info *path = LIST_FIRST(&(bnc->paths));
 135
 136                         path_nh_map(path, bnc, false);
 137                 }
 138
 139                 bnc_free(bnc);
 140         }
 141 }
 142
 143 static void *bgp_tip_hash_alloc(void *p)
 144 {
 145         const struct in_addr *val = (const struct in_addr *)p;
 146         struct tip_addr *addr;
 147
 148         addr = XMALLOC(MTYPE_TIP_ADDR, sizeof(struct tip_addr));
 149         addr->refcnt = 0;
 150         addr->addr.s_addr = val->s_addr;
 151
 152         return addr;
 153 }
 154
 155 static void bgp_tip_hash_free(void *addr)
 156 {
 157         XFREE(MTYPE_TIP_ADDR, addr);
 158 }
 159
 160 static unsigned int bgp_tip_hash_key_make(const void *p)
 161 {
 162         const struct tip_addr *addr = p;
 163
 164         return jhash_1word(addr->addr.s_addr, 0);
 165 }
 166
 167 static bool bgp_tip_hash_cmp(const void *p1, const void *p2)
 168 {
 169         const struct tip_addr *addr1 = p1;
 170         const struct tip_addr *addr2 = p2;
 171
 172         return addr1->addr.s_addr == addr2->addr.s_addr;
 173 }
 174
 175 void bgp_tip_hash_init(struct bgp *bgp)
 176 {
 177         bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
 178                                     "BGP TIP hash");
 179 }
 180
 181 void bgp_tip_hash_destroy(struct bgp *bgp)
 182 {
 183         if (bgp->tip_hash == NULL)
 184                 return;
 185         hash_clean(bgp->tip_hash, bgp_tip_hash_free);
 186         hash_free(bgp->tip_hash);
 187         bgp->tip_hash = NULL;
 188 }
 189
 190 void bgp_tip_add(struct bgp *bgp, struct in_addr *tip)
 191 {
 192         struct tip_addr tmp;
 193         struct tip_addr *addr;
 194
 195         tmp.addr = *tip;
 196
 197         addr = hash_get(bgp->tip_hash, &tmp, bgp_tip_hash_alloc);
 198         addr->refcnt++;
 199 }
 200
 201 void bgp_tip_del(struct bgp *bgp, struct in_addr *tip)
 202 {
 203         struct tip_addr tmp;
 204         struct tip_addr *addr;
 205
 206         tmp.addr = *tip;
 207
 208         addr = hash_lookup(bgp->tip_hash, &tmp);
 209         /* may have been deleted earlier by bgp_interface_down() */
 210         if (addr == NULL)
 211                 return;
 212
 213         addr->refcnt--;
 214
 215         if (addr->refcnt == 0) {
 216                 hash_release(bgp->tip_hash, addr);
 217                 XFREE(MTYPE_TIP_ADDR, addr);
 218         }
 219 }
 220
 221 /* BGP own address structure */
 222 struct bgp_addr {
 223         struct prefix p;
 224         struct list *ifp_name_list;
 225 };
 226
 227 static void show_address_entry(struct hash_bucket *bucket, void *args)
 228 {
 229         struct vty *vty = (struct vty *)args;
 230         struct bgp_addr *addr = (struct bgp_addr *)bucket->data;
 231         char *name;
 232         struct listnode *node;
 233         char str[INET6_ADDRSTRLEN] = {0};
 234
 235         vty_out(vty, "addr: %s, count: %d : ",
 236                 inet_ntop(addr->p.family, &(addr->p.u.prefix),
 237                           str, INET6_ADDRSTRLEN),
 238                 addr->ifp_name_list->count);
 239
 240         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 241                 vty_out(vty, " %s,", name);
 242         }
 243
 244         vty_out(vty, "\n");
 245 }
 246
 247 void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp)
 248 {
 249         hash_iterate(bgp->address_hash,
 250                      (void (*)(struct hash_bucket *, void *))show_address_entry,
 251                      vty);
 252 }
 253
 254 static void bgp_address_hash_string_del(void *val)
 255 {
 256         char *data = val;
 257
 258         XFREE(MTYPE_MARTIAN_STRING, data);
 259 }
 260
 261 static void *bgp_address_hash_alloc(void *p)
 262 {
 263         struct bgp_addr *copy_addr = p;
 264         struct bgp_addr *addr = NULL;
 265
 266         addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
 267         prefix_copy(&addr->p, &copy_addr->p);
 268
 269         addr->ifp_name_list = list_new();
 270         addr->ifp_name_list->del = bgp_address_hash_string_del;
 271
 272         return addr;
 273 }
 274
 275 static void bgp_address_hash_free(void *data)
 276 {
 277         struct bgp_addr *addr = data;
 278
 279         list_delete(&addr->ifp_name_list);
 280         XFREE(MTYPE_BGP_ADDR, addr);
 281 }
 282
 283 static unsigned int bgp_address_hash_key_make(const void *p)
 284 {
 285         const struct bgp_addr *addr = p;
 286
 287         return prefix_hash_key(&addr->p);
 288 }
 289
 290 static bool bgp_address_hash_cmp(const void *p1, const void *p2)
 291 {
 292         const struct bgp_addr *addr1 = p1;
 293         const struct bgp_addr *addr2 = p2;
 294
 295         return prefix_same(&addr1->p, &addr2->p);
 296 }
 297
 298 void bgp_address_init(struct bgp *bgp)
 299 {
 300         bgp->address_hash =
 301                 hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
 302                                 "BGP Connected Address Hash");
 303 }
 304
 305 void bgp_address_destroy(struct bgp *bgp)
 306 {
 307         if (bgp->address_hash == NULL)
 308                 return;
 309         hash_clean(bgp->address_hash, bgp_address_hash_free);
 310         hash_free(bgp->address_hash);
 311         bgp->address_hash = NULL;
 312 }
 313
 314 static void bgp_address_add(struct bgp *bgp, struct connected *ifc,
 315                             struct prefix *p)
 316 {
 317         struct bgp_addr tmp;
 318         struct bgp_addr *addr;
 319         struct listnode *node;
 320         char *name;
 321
 322         tmp.p = *p;
 323
 324         if (tmp.p.family == AF_INET)
 325                 tmp.p.prefixlen = IPV4_MAX_BITLEN;
 326         else if (tmp.p.family == AF_INET6)
 327                 tmp.p.prefixlen = IPV6_MAX_BITLEN;
 328
 329         addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);
 330
 331         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 332                 if (strcmp(ifc->ifp->name, name) == 0)
 333                         break;
 334         }
 335         if (!node) {
 336                 name = XSTRDUP(MTYPE_MARTIAN_STRING, ifc->ifp->name);
 337                 listnode_add(addr->ifp_name_list, name);
 338         }
 339 }
 340
 341 static void bgp_address_del(struct bgp *bgp, struct connected *ifc,
 342                             struct prefix *p)
 343 {
 344         struct bgp_addr tmp;
 345         struct bgp_addr *addr;
 346         struct listnode *node;
 347         char *name;
 348
 349         tmp.p = *p;
 350
 351         if (tmp.p.family == AF_INET)
 352                 tmp.p.prefixlen = IPV4_MAX_BITLEN;
 353         else if (tmp.p.family == AF_INET6)
 354                 tmp.p.prefixlen = IPV6_MAX_BITLEN;
 355
 356         addr = hash_lookup(bgp->address_hash, &tmp);
 357         /* may have been deleted earlier by bgp_interface_down() */
 358         if (addr == NULL)
 359                 return;
 360
 361         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 362                 if (strcmp(ifc->ifp->name, name) == 0)
 363                         break;
 364         }
 365
 366         if (node) {
 367                 list_delete_node(addr->ifp_name_list, node);
 368                 XFREE(MTYPE_MARTIAN_STRING, name);
 369         }
 370
 371         if (addr->ifp_name_list->count == 0) {
 372                 hash_release(bgp->address_hash, addr);
 373                 list_delete(&addr->ifp_name_list);
 374                 XFREE(MTYPE_BGP_ADDR, addr);
 375         }
 376 }
 377
 378
 379 struct bgp_connected_ref {
 380         unsigned int refcnt;
 381 };
 382
 383 void bgp_connected_add(struct bgp *bgp, struct connected *ifc)
 384 {
 385         struct prefix p;
 386         struct prefix *addr;
 387         struct bgp_dest *dest;
 388         struct bgp_connected_ref *bc;
 389         struct listnode *node, *nnode;
 390         struct peer *peer;
 391
 392         addr = ifc->address;
 393
 394         p = *(CONNECTED_PREFIX(ifc));
 395         if (addr->family == AF_INET) {
 396                 apply_mask_ipv4((struct prefix_ipv4 *)&p);
 397
 398                 if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
 399                         return;
 400
 401                 bgp_address_add(bgp, ifc, addr);
 402
 403                 dest = bgp_node_get(bgp->connected_table[AFI_IP], &p);
 404                 bc = bgp_dest_get_bgp_connected_ref_info(dest);
 405                 if (bc)
 406                         bc->refcnt++;
 407                 else {
 408                         bc = XCALLOC(MTYPE_BGP_CONN,
 409                                      sizeof(struct bgp_connected_ref));
 410                         bc->refcnt = 1;
 411                         bgp_dest_set_bgp_connected_ref_info(dest, bc);
 412                 }
 413
 414                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 415                         if (peer->conf_if
 416                             && (strcmp(peer->conf_if, ifc->ifp->name) == 0)
 417                             && !peer_established(peer)
 418                             && !CHECK_FLAG(peer->flags,
 419                                            PEER_FLAG_IFPEER_V6ONLY)) {
 420                                 if (peer_active(peer))
 421                                         BGP_EVENT_ADD(peer, BGP_Stop);
 422                                 BGP_EVENT_ADD(peer, BGP_Start);
 423                         }
 424                 }
 425         } else if (addr->family == AF_INET6) {
 426                 apply_mask_ipv6((struct prefix_ipv6 *)&p);
 427
 428                 if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
 429                         return;
 430
 431                 if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
 432                         return;
 433
 434                 bgp_address_add(bgp, ifc, addr);
 435
 436                 dest = bgp_node_get(bgp->connected_table[AFI_IP6], &p);
 437
 438                 bc = bgp_dest_get_bgp_connected_ref_info(dest);
 439                 if (bc)
 440                         bc->refcnt++;
 441                 else {
 442                         bc = XCALLOC(MTYPE_BGP_CONN,
 443                                      sizeof(struct bgp_connected_ref));
 444                         bc->refcnt = 1;
 445                         bgp_dest_set_bgp_connected_ref_info(dest, bc);
 446                 }
 447         }
 448 }
 449
 450 void bgp_connected_delete(struct bgp *bgp, struct connected *ifc)
 451 {
 452         struct prefix p;
 453         struct prefix *addr;
 454         struct bgp_dest *dest = NULL;
 455         struct bgp_connected_ref *bc;
 456
 457         addr = ifc->address;
 458
 459         p = *(CONNECTED_PREFIX(ifc));
 460         apply_mask(&p);
 461         if (addr->family == AF_INET) {
 462                 if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
 463                         return;
 464
 465                 bgp_address_del(bgp, ifc, addr);
 466
 467                 dest = bgp_node_lookup(bgp->connected_table[AFI_IP], &p);
 468         } else if (addr->family == AF_INET6) {
 469                 if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
 470                         return;
 471
 472                 if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
 473                         return;
 474
 475                 bgp_address_del(bgp, ifc, addr);
 476
 477                 dest = bgp_node_lookup(bgp->connected_table[AFI_IP6], &p);
 478         }
 479
 480         if (!dest)
 481                 return;
 482
 483         bc = bgp_dest_get_bgp_connected_ref_info(dest);
 484         bc->refcnt--;
 485         if (bc->refcnt == 0) {
 486                 XFREE(MTYPE_BGP_CONN, bc);
 487                 bgp_dest_set_bgp_connected_ref_info(dest, NULL);
 488         }
 489         bgp_dest_unlock_node(dest);
 490         bgp_dest_unlock_node(dest);
 491 }
 492
 493 static void bgp_connected_cleanup(struct route_table *table,
 494                                   struct route_node *rn)
 495 {
 496         struct bgp_connected_ref *bc;
 497         struct bgp_dest *bn = bgp_dest_from_rnode(rn);
 498
 499         bc = bgp_dest_get_bgp_connected_ref_info(bn);
 500         if (!bc)
 501                 return;
 502
 503         bc->refcnt--;
 504         if (bc->refcnt == 0) {
 505                 XFREE(MTYPE_BGP_CONN, bc);
 506                 bgp_dest_set_bgp_connected_ref_info(bn, NULL);
 507         }
 508 }
 509
 510 bool bgp_nexthop_self(struct bgp *bgp, afi_t afi, uint8_t type,
 511                       uint8_t sub_type, struct attr *attr,
 512                       struct bgp_dest *dest)
 513 {
 514         uint8_t new_afi = afi == AFI_IP ? AF_INET : AF_INET6;
 515         struct bgp_addr tmp_addr = {{0}}, *addr = NULL;
 516         struct tip_addr tmp_tip, *tip = NULL;
 517         const struct prefix *p = bgp_dest_get_prefix(dest);
 518         bool is_bgp_static_route =
 519                 ((type == ZEBRA_ROUTE_BGP) && (sub_type == BGP_ROUTE_STATIC))
 520                         ? true
 521                         : false;
 522
 523         if (!is_bgp_static_route)
 524                 new_afi = BGP_ATTR_NEXTHOP_AFI_IP6(attr) ? AF_INET6 : AF_INET;
 525
 526         tmp_addr.p.family = new_afi;
 527         switch (new_afi) {
 528         case AF_INET:
 529                 if (is_bgp_static_route) {
 530                         tmp_addr.p.u.prefix4 = p->u.prefix4;
 531                         tmp_addr.p.prefixlen = p->prefixlen;
 532                 } else {
 533                         /* Here we need to find out which nexthop to be used*/
 534                         if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) {
 535                                 tmp_addr.p.u.prefix4 = attr->nexthop;
 536                                 tmp_addr.p.prefixlen = IPV4_MAX_BITLEN;
 537                         } else if ((attr->mp_nexthop_len)
 538                                    && ((attr->mp_nexthop_len
 539                                         == BGP_ATTR_NHLEN_IPV4)
 540                                        || (attr->mp_nexthop_len
 541                                            == BGP_ATTR_NHLEN_VPNV4))) {
 542                                 tmp_addr.p.u.prefix4 =
 543                                         attr->mp_nexthop_global_in;
 544                                 tmp_addr.p.prefixlen = IPV4_MAX_BITLEN;
 545                         } else
 546                                 return false;
 547                 }
 548                 break;
 549         case AF_INET6:
 550                 if (is_bgp_static_route) {
 551                         tmp_addr.p.u.prefix6 = p->u.prefix6;
 552                         tmp_addr.p.prefixlen = p->prefixlen;
 553                 } else {
 554                         tmp_addr.p.u.prefix6 = attr->mp_nexthop_global;
 555                         tmp_addr.p.prefixlen = IPV6_MAX_BITLEN;
 556                 }
 557                 break;
 558         default:
 559                 break;
 560         }
 561
 562         addr = hash_lookup(bgp->address_hash, &tmp_addr);
 563         if (addr)
 564                 return true;
 565
 566         if (new_afi == AF_INET && hashcount(bgp->tip_hash)) {
 567                 memset(&tmp_tip, 0, sizeof(tmp_tip));
 568                 tmp_tip.addr = attr->nexthop;
 569
 570                 if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) {
 571                         tmp_tip.addr = attr->nexthop;
 572                 } else if ((attr->mp_nexthop_len) &&
 573                            ((attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4)
 574                             || (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV4))) {
 575                         tmp_tip.addr = attr->mp_nexthop_global_in;
 576                 }
 577
 578                 tip = hash_lookup(bgp->tip_hash, &tmp_tip);
 579                 if (tip)
 580                         return true;
 581         }
 582
 583         return false;
 584 }
 585
 586 bool bgp_multiaccess_check_v4(struct in_addr nexthop, struct peer *peer)
 587 {
 588         struct bgp_dest *dest1;
 589         struct bgp_dest *dest2;
 590         struct prefix p;
 591         int ret;
 592
 593         p.family = AF_INET;
 594         p.prefixlen = IPV4_MAX_BITLEN;
 595         p.u.prefix4 = nexthop;
 596
 597         dest1 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
 598         if (!dest1)
 599                 return false;
 600
 601         p.family = AF_INET;
 602         p.prefixlen = IPV4_MAX_BITLEN;
 603         p.u.prefix4 = peer->su.sin.sin_addr;
 604
 605         dest2 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
 606         if (!dest2) {
 607                 bgp_dest_unlock_node(dest1);
 608                 return false;
 609         }
 610
 611         ret = (dest1 == dest2);
 612
 613         bgp_dest_unlock_node(dest1);
 614         bgp_dest_unlock_node(dest2);
 615
 616         return ret;
 617 }
 618
 619 bool bgp_multiaccess_check_v6(struct in6_addr nexthop, struct peer *peer)
 620 {
 621         struct bgp_dest *dest1;
 622         struct bgp_dest *dest2;
 623         struct prefix p;
 624         int ret;
 625
 626         p.family = AF_INET6;
 627         p.prefixlen = IPV6_MAX_BITLEN;
 628         p.u.prefix6 = nexthop;
 629
 630         dest1 = bgp_node_match(peer->bgp->connected_table[AFI_IP6], &p);
 631         if (!dest1)
 632                 return false;
 633
 634         p.family = AF_INET6;
 635         p.prefixlen = IPV6_MAX_BITLEN;
 636         p.u.prefix6 = peer->su.sin6.sin6_addr;
 637
 638         dest2 = bgp_node_match(peer->bgp->connected_table[AFI_IP6], &p);
 639         if (!dest2) {
 640                 bgp_dest_unlock_node(dest1);
 641                 return false;
 642         }
 643
 644         ret = (dest1 == dest2);
 645
 646         bgp_dest_unlock_node(dest1);
 647         bgp_dest_unlock_node(dest2);
 648
 649         return ret;
 650 }
 651
 652 bool bgp_subgrp_multiaccess_check_v6(struct in6_addr nexthop,
 653                                      struct update_subgroup *subgrp,
 654                                      struct peer *exclude)
 655 {
 656         struct bgp_dest *dest1 = NULL, *dest2 = NULL;
 657         struct peer_af *paf = NULL;
 658         struct prefix p = {0}, np = {0};
 659         struct bgp *bgp = NULL;
 660
 661         np.family = AF_INET6;
 662         np.prefixlen = IPV6_MAX_BITLEN;
 663         np.u.prefix6 = nexthop;
 664
 665         p.family = AF_INET;
 666         p.prefixlen = IPV6_MAX_BITLEN;
 667
 668         bgp = SUBGRP_INST(subgrp);
 669         dest1 = bgp_node_match(bgp->connected_table[AFI_IP6], &np);
 670         if (!dest1)
 671                 return false;
 672
 673         SUBGRP_FOREACH_PEER (subgrp, paf) {
 674                 /* Skip peer we're told to exclude - e.g., source of route. */
 675                 if (paf->peer == exclude)
 676                         continue;
 677
 678                 p.u.prefix6 = paf->peer->su.sin6.sin6_addr;
 679                 dest2 = bgp_node_match(bgp->connected_table[AFI_IP6], &p);
 680                 if (dest1 == dest2) {
 681                         bgp_dest_unlock_node(dest1);
 682                         bgp_dest_unlock_node(dest2);
 683                         return true;
 684                 }
 685
 686                 if (dest2)
 687                         bgp_dest_unlock_node(dest2);
 688         }
 689
 690         bgp_dest_unlock_node(dest1);
 691         return false;
 692 }
 693
 694 bool bgp_subgrp_multiaccess_check_v4(struct in_addr nexthop,
 695                                      struct update_subgroup *subgrp,
 696                                      struct peer *exclude)
 697 {
 698         struct bgp_dest *dest1, *dest2;
 699         struct peer_af *paf;
 700         struct prefix p, np;
 701         struct bgp *bgp;
 702
 703         np.family = AF_INET;
 704         np.prefixlen = IPV4_MAX_BITLEN;
 705         np.u.prefix4 = nexthop;
 706
 707         p.family = AF_INET;
 708         p.prefixlen = IPV4_MAX_BITLEN;
 709
 710         bgp = SUBGRP_INST(subgrp);
 711         dest1 = bgp_node_match(bgp->connected_table[AFI_IP], &np);
 712         if (!dest1)
 713                 return false;
 714
 715         SUBGRP_FOREACH_PEER (subgrp, paf) {
 716                 /* Skip peer we're told to exclude - e.g., source of route. */
 717                 if (paf->peer == exclude)
 718                         continue;
 719
 720                 p.u.prefix4 = paf->peer->su.sin.sin_addr;
 721
 722                 dest2 = bgp_node_match(bgp->connected_table[AFI_IP], &p);
 723                 if (dest1 == dest2) {
 724                         bgp_dest_unlock_node(dest1);
 725                         bgp_dest_unlock_node(dest2);
 726                         return true;
 727                 }
 728
 729                 if (dest2)
 730                         bgp_dest_unlock_node(dest2);
 731         }
 732
 733         bgp_dest_unlock_node(dest1);
 734         return false;
 735 }
 736
 737 static void bgp_show_nexthop_paths(struct vty *vty, struct bgp *bgp,
 738                                    struct bgp_nexthop_cache *bnc)
 739 {
 740         struct bgp_dest *dest;
 741         struct bgp_path_info *path;
 742         int afi;
 743         safi_t safi;
 744         struct bgp_table *table;
 745         struct bgp *bgp_path;
 746
 747         vty_out(vty, "  Paths:\n");
 748         LIST_FOREACH (path, &(bnc->paths), nh_thread) {
 749                 dest = path->net;
 750                 assert(dest && bgp_dest_table(dest));
 751                 afi = family2afi(bgp_dest_get_prefix(dest)->family);
 752                 table = bgp_dest_table(dest);
 753                 safi = table->safi;
 754                 bgp_path = table->bgp;
 755
 756                 if (dest->pdest)
 757                         vty_out(vty, "    %d/%d %pBD RD %pRD %s flags 0x%x\n",
 758                                 afi, safi, dest,
 759                                 (struct prefix_rd *)bgp_dest_get_prefix(
 760                                         dest->pdest),
 761                                 bgp_path->name_pretty, path->flags);
 762                 else
 763                         vty_out(vty, "    %d/%d %pBD %s flags 0x%x\n",
 764                                 afi, safi, dest, bgp_path->name_pretty, path->flags);
 765         }
 766 }
 767
 768 static void bgp_show_nexthops_detail(struct vty *vty, struct bgp *bgp,
 769                                      struct bgp_nexthop_cache *bnc)
 770 {
 771         struct nexthop *nexthop;
 772
 773         for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next) {
 774                 switch (nexthop->type) {
 775                 case NEXTHOP_TYPE_IPV6:
 776                         vty_out(vty, "  gate %pI6\n", &nexthop->gate.ipv6);
 777                         break;
 778                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 779                         vty_out(vty, "  gate %pI6, if %s\n",
 780                                 &nexthop->gate.ipv6,
 781                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 782                                                             : nexthop->ifindex,
 783                                                bgp->vrf_id));
 784                         break;
 785                 case NEXTHOP_TYPE_IPV4:
 786                         vty_out(vty, "  gate %pI4\n", &nexthop->gate.ipv4);
 787                         break;
 788                 case NEXTHOP_TYPE_IFINDEX:
 789                         vty_out(vty, "  if %s\n",
 790                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 791                                                             : nexthop->ifindex,
 792                                                bgp->vrf_id));
 793                         break;
 794                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 795                         vty_out(vty, "  gate %pI4, if %s\n",
 796                                 &nexthop->gate.ipv4,
 797                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 798                                                             : nexthop->ifindex,
 799                                                bgp->vrf_id));
 800                         break;
 801                 case NEXTHOP_TYPE_BLACKHOLE:
 802                         vty_out(vty, "  blackhole\n");
 803                         break;
 804                 default:
 805                         vty_out(vty, "  invalid nexthop type %u\n",
 806                                 nexthop->type);
 807                 }
 808         }
 809 }
 810
 811 static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
 812                              struct bgp_nexthop_cache *bnc,
 813                              bool specific)
 814 {
 815         char buf[PREFIX2STR_BUFFER];
 816         time_t tbuf;
 817         struct peer *peer;
 818
 819         peer = (struct peer *)bnc->nht_info;
 820
 821         if (bnc->srte_color)
 822                 vty_out(vty, " SR-TE color %u -", bnc->srte_color);
 823         if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
 824                 vty_out(vty, " %s valid [IGP metric %d], #paths %d",
 825                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 826                                   buf, sizeof(buf)),
 827                         bnc->metric, bnc->path_count);
 828                 if (peer)
 829                         vty_out(vty, ", peer %s", peer->host);
 830                 if (bnc->is_evpn_gwip_nexthop)
 831                         vty_out(vty, " EVPN Gateway IP");
 832                 vty_out(vty, "\n");
 833                 bgp_show_nexthops_detail(vty, bgp, bnc);
 834         } else if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_EVPN_INCOMPLETE)) {
 835                 vty_out(vty,
 836                         " %s overlay index unresolved [IGP metric %d], #paths %d",
 837                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 838                                   buf, sizeof(buf)),
 839                         bnc->metric, bnc->path_count);
 840                 if (bnc->is_evpn_gwip_nexthop)
 841                         vty_out(vty, " EVPN Gateway IP");
 842                 vty_out(vty, "\n");
 843                 bgp_show_nexthops_detail(vty, bgp, bnc);
 844         } else {
 845                 vty_out(vty, " %s invalid, #paths %d",
 846                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 847                                   buf, sizeof(buf)),
 848                         bnc->path_count);
 849                 if (peer)
 850                         vty_out(vty, ", peer %s", peer->host);
 851                 if (bnc->is_evpn_gwip_nexthop)
 852                         vty_out(vty, " EVPN Gateway IP");
 853                 vty_out(vty, "\n");
 854                 if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
 855                         vty_out(vty, "  Must be Connected\n");
 856                 if (!CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED))
 857                         vty_out(vty, "  Is not Registered\n");
 858         }
 859         tbuf = time(NULL) - (monotime(NULL) - bnc->last_update);
 860         vty_out(vty, "  Last update: %s", ctime(&tbuf));
 861
 862         /* show paths dependent on nexthop, if needed. */
 863         if (specific)
 864                 bgp_show_nexthop_paths(vty, bgp, bnc);
 865 }
 866
 867 static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp,
 868                               bool import_table)
 869 {
 870         struct bgp_nexthop_cache *bnc;
 871         afi_t afi;
 872         struct bgp_nexthop_cache_head(*tree)[AFI_MAX];
 873
 874         if (import_table)
 875                 vty_out(vty, "Current BGP import check cache:\n");
 876         else
 877                 vty_out(vty, "Current BGP nexthop cache:\n");
 878         if (import_table)
 879                 tree = &bgp->import_check_table;
 880         else
 881                 tree = &bgp->nexthop_cache_table;
 882         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 883                 frr_each (bgp_nexthop_cache, &(*tree)[afi], bnc)
 884                         bgp_show_nexthop(vty, bgp, bnc, false);
 885         }
 886 }
 887
 888 static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
 889                                      const char *nhopip_str,
 890                                      bool import_table)
 891 {
 892         struct bgp *bgp;
 893
 894         if (name)
 895                 bgp = bgp_lookup_by_name(name);
 896         else
 897                 bgp = bgp_get_default();
 898         if (!bgp) {
 899                 vty_out(vty, "%% No such BGP instance exist\n");
 900                 return CMD_WARNING;
 901         }
 902
 903         if (nhopip_str) {
 904                 struct prefix nhop;
 905                 struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
 906                 struct bgp_nexthop_cache *bnc;
 907                 bool found = false;
 908
 909                 if (!str2prefix(nhopip_str, &nhop)) {
 910                         vty_out(vty, "nexthop address is malformed\n");
 911                         return CMD_WARNING;
 912                 }
 913                 tree = import_table ? &bgp->import_check_table
 914                                     : &bgp->nexthop_cache_table;
 915                 frr_each (bgp_nexthop_cache, &(*tree)[family2afi(nhop.family)],
 916                           bnc) {
 917                         if (prefix_cmp(&bnc->prefix, &nhop))
 918                                 continue;
 919                         bgp_show_nexthop(vty, bgp, bnc, true);
 920                         found = true;
 921                 }
 922                 if (!found)
 923                         vty_out(vty, "nexthop %s does not have entry\n",
 924                                 nhopip_str);
 925         } else
 926                 bgp_show_nexthops(vty, bgp, import_table);
 927
 928         return CMD_SUCCESS;
 929 }
 930
 931 static void bgp_show_all_instances_nexthops_vty(struct vty *vty)
 932 {
 933         struct listnode *node, *nnode;
 934         struct bgp *bgp;
 935
 936         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 937                 vty_out(vty, "\nInstance %s:\n",
 938                         (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 939                                 ? VRF_DEFAULT_NAME
 940                                 : bgp->name);
 941                 bgp_show_nexthops(vty, bgp, false);
 942         }
 943 }
 944
 945 DEFUN (show_ip_bgp_nexthop,
 946        show_ip_bgp_nexthop_cmd,
 947        "show [ip] bgp [<view|vrf> VIEWVRFNAME] nexthop [<A.B.C.D|X:X::X:X>] [detail]",
 948        SHOW_STR
 949        IP_STR
 950        BGP_STR
 951        BGP_INSTANCE_HELP_STR
 952        "BGP nexthop table\n"
 953        "IPv4 nexthop address\n"
 954        "IPv6 nexthop address\n"
 955        "Show detailed information\n")
 956 {
 957         int idx = 0;
 958         int nh_idx = 0;
 959         char *vrf = NULL;
 960         char *nhop_ip = NULL;
 961
 962         if (argv_find(argv, argc, "view", &idx)
 963             || argv_find(argv, argc, "vrf", &idx))
 964                 vrf = argv[++idx]->arg;
 965
 966         if (argv_find(argv, argc, "A.B.C.D", &nh_idx)
 967             || argv_find(argv, argc, "X:X::X:X", &nh_idx))
 968                 nhop_ip = argv[nh_idx]->arg;
 969
 970         return show_ip_bgp_nexthop_table(vty, vrf, nhop_ip, false);
 971 }
 972
 973 DEFUN (show_ip_bgp_import_check,
 974        show_ip_bgp_import_check_cmd,
 975        "show [ip] bgp [<view|vrf> VIEWVRFNAME] import-check-table [detail]",
 976        SHOW_STR
 977        IP_STR
 978        BGP_STR
 979        BGP_INSTANCE_HELP_STR
 980        "BGP import check table\n"
 981        "Show detailed information\n")
 982 {
 983         int idx = 0;
 984         char *vrf = NULL;
 985
 986         if (argv_find(argv, argc, "view", &idx)
 987             || argv_find(argv, argc, "vrf", &idx))
 988                 vrf = argv[++idx]->arg;
 989
 990         return show_ip_bgp_nexthop_table(vty, vrf, NULL, true);
 991 }
 992
 993 DEFUN (show_ip_bgp_instance_all_nexthop,
 994        show_ip_bgp_instance_all_nexthop_cmd,
 995        "show [ip] bgp <view|vrf> all nexthop",
 996        SHOW_STR
 997        IP_STR
 998        BGP_STR
 999        BGP_INSTANCE_ALL_HELP_STR
1000        "BGP nexthop table\n")
1001 {
1002         bgp_show_all_instances_nexthops_vty(vty);
1003         return CMD_SUCCESS;
1004 }
1005
1006 void bgp_scan_init(struct bgp *bgp)
1007 {
1008         afi_t afi;
1009
1010         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1011                 bgp_nexthop_cache_init(&bgp->nexthop_cache_table[afi]);
1012                 bgp_nexthop_cache_init(&bgp->import_check_table[afi]);
1013                 bgp->connected_table[afi] = bgp_table_init(bgp, afi,
1014                         SAFI_UNICAST);
1015         }
1016 }
1017
1018 void bgp_scan_vty_init(void)
1019 {
1020         install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
1021         install_element(VIEW_NODE, &show_ip_bgp_import_check_cmd);
1022         install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
1023 }
1024
1025 void bgp_scan_finish(struct bgp *bgp)
1026 {
1027         afi_t afi;
1028
1029         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1030                 /* Only the current one needs to be reset. */
1031                 bgp_nexthop_cache_reset(&bgp->nexthop_cache_table[afi]);
1032                 bgp_nexthop_cache_reset(&bgp->import_check_table[afi]);
1033
1034                 bgp->connected_table[afi]->route_table->cleanup =
1035                         bgp_connected_cleanup;
1036                 bgp_table_unlock(bgp->connected_table[afi]);
1037                 bgp->connected_table[afi] = NULL;
1038         }
1039 }
1040
1041 char *bgp_nexthop_dump_bnc_flags(struct bgp_nexthop_cache *bnc, char *buf,
1042                                  size_t len)
1043 {
1044         if (bnc->flags == 0) {
1045                 snprintfrr(buf, len, "None ");
1046                 return buf;
1047         }
1048
1049         snprintfrr(buf, len, "%s%s%s%s%s%s%s",
1050                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID) ? "Valid " : "",
1051                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED) ? "Reg " : "",
1052                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED) ? "Conn " : "",
1053                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_PEER_NOTIFIED) ? "Notify "
1054                                                                      : "",
1055                    CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE) ? "Static " : "",
1056                    CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE_EXACT_MATCH)
1057                            ? "Static Exact "
1058                            : "",
1059                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_LABELED_VALID)
1060                            ? "Label Valid "
1061                            : "");
1062
1063         return buf;
1064 }
1065
1066 char *bgp_nexthop_dump_bnc_change_flags(struct bgp_nexthop_cache *bnc,
1067                                         char *buf, size_t len)
1068 {
1069         if (bnc->flags == 0) {
1070                 snprintfrr(buf, len, "None ");
1071                 return buf;
1072         }
1073
1074         snprintfrr(buf, len, "%s%s%s",
1075                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CHANGED)
1076                            ? "Changed "
1077                            : "",
1078                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_METRIC_CHANGED)
1079                            ? "Metric "
1080                            : "",
1081                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CONNECTED_CHANGED)
1082                            ? "Connected "
1083                            : "");
1084
1085         return buf;
1086 }