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         char buf[PREFIX2STR_BUFFER];
 772         struct nexthop *nexthop;
 773
 774         for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next) {
 775                 switch (nexthop->type) {
 776                 case NEXTHOP_TYPE_IPV6:
 777                         vty_out(vty, "  gate %s\n",
 778                                 inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
 779                                           sizeof(buf)));
 780                         break;
 781                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 782                         vty_out(vty, "  gate %s, if %s\n",
 783                                 inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
 784                                           sizeof(buf)),
 785                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 786                                                             : nexthop->ifindex,
 787                                                bgp->vrf_id));
 788                         break;
 789                 case NEXTHOP_TYPE_IPV4:
 790                         vty_out(vty, "  gate %s\n",
 791                                 inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
 792                                           sizeof(buf)));
 793                         break;
 794                 case NEXTHOP_TYPE_IFINDEX:
 795                         vty_out(vty, "  if %s\n",
 796                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 797                                                             : nexthop->ifindex,
 798                                                bgp->vrf_id));
 799                         break;
 800                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 801                         vty_out(vty, "  gate %s, if %s\n",
 802                                 inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
 803                                           sizeof(buf)),
 804                                 ifindex2ifname(bnc->ifindex ? bnc->ifindex
 805                                                             : nexthop->ifindex,
 806                                                bgp->vrf_id));
 807                         break;
 808                 case NEXTHOP_TYPE_BLACKHOLE:
 809                         vty_out(vty, "  blackhole\n");
 810                         break;
 811                 default:
 812                         vty_out(vty, "  invalid nexthop type %u\n",
 813                                 nexthop->type);
 814                 }
 815         }
 816 }
 817
 818 static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
 819                              struct bgp_nexthop_cache *bnc,
 820                              bool specific)
 821 {
 822         char buf[PREFIX2STR_BUFFER];
 823         time_t tbuf;
 824         struct peer *peer;
 825
 826         peer = (struct peer *)bnc->nht_info;
 827
 828         if (bnc->srte_color)
 829                 vty_out(vty, " SR-TE color %u -", bnc->srte_color);
 830         if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
 831                 vty_out(vty, " %s valid [IGP metric %d], #paths %d",
 832                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 833                                   buf, sizeof(buf)),
 834                         bnc->metric, bnc->path_count);
 835                 if (peer)
 836                         vty_out(vty, ", peer %s", peer->host);
 837                 if (bnc->is_evpn_gwip_nexthop)
 838                         vty_out(vty, " EVPN Gateway IP");
 839                 vty_out(vty, "\n");
 840                 bgp_show_nexthops_detail(vty, bgp, bnc);
 841         } else if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_EVPN_INCOMPLETE)) {
 842                 vty_out(vty,
 843                         " %s overlay index unresolved [IGP metric %d], #paths %d",
 844                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 845                                   buf, sizeof(buf)),
 846                         bnc->metric, bnc->path_count);
 847                 if (bnc->is_evpn_gwip_nexthop)
 848                         vty_out(vty, " EVPN Gateway IP");
 849                 vty_out(vty, "\n");
 850                 bgp_show_nexthops_detail(vty, bgp, bnc);
 851         } else {
 852                 vty_out(vty, " %s invalid, #paths %d",
 853                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 854                                   buf, sizeof(buf)),
 855                         bnc->path_count);
 856                 if (peer)
 857                         vty_out(vty, ", peer %s", peer->host);
 858                 if (bnc->is_evpn_gwip_nexthop)
 859                         vty_out(vty, " EVPN Gateway IP");
 860                 vty_out(vty, "\n");
 861                 if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
 862                         vty_out(vty, "  Must be Connected\n");
 863                 if (!CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED))
 864                         vty_out(vty, "  Is not Registered\n");
 865         }
 866         tbuf = time(NULL) - (monotime(NULL) - bnc->last_update);
 867         vty_out(vty, "  Last update: %s", ctime(&tbuf));
 868
 869         /* show paths dependent on nexthop, if needed. */
 870         if (specific)
 871                 bgp_show_nexthop_paths(vty, bgp, bnc);
 872 }
 873
 874 static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp,
 875                               bool import_table)
 876 {
 877         struct bgp_nexthop_cache *bnc;
 878         afi_t afi;
 879         struct bgp_nexthop_cache_head(*tree)[AFI_MAX];
 880
 881         if (import_table)
 882                 vty_out(vty, "Current BGP import check cache:\n");
 883         else
 884                 vty_out(vty, "Current BGP nexthop cache:\n");
 885         if (import_table)
 886                 tree = &bgp->import_check_table;
 887         else
 888                 tree = &bgp->nexthop_cache_table;
 889         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 890                 frr_each (bgp_nexthop_cache, &(*tree)[afi], bnc)
 891                         bgp_show_nexthop(vty, bgp, bnc, false);
 892         }
 893 }
 894
 895 static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
 896                                      const char *nhopip_str,
 897                                      bool import_table)
 898 {
 899         struct bgp *bgp;
 900
 901         if (name)
 902                 bgp = bgp_lookup_by_name(name);
 903         else
 904                 bgp = bgp_get_default();
 905         if (!bgp) {
 906                 vty_out(vty, "%% No such BGP instance exist\n");
 907                 return CMD_WARNING;
 908         }
 909
 910         if (nhopip_str) {
 911                 struct prefix nhop;
 912                 struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
 913                 struct bgp_nexthop_cache *bnc;
 914                 bool found = false;
 915
 916                 if (!str2prefix(nhopip_str, &nhop)) {
 917                         vty_out(vty, "nexthop address is malformed\n");
 918                         return CMD_WARNING;
 919                 }
 920                 tree = import_table ? &bgp->import_check_table
 921                                     : &bgp->nexthop_cache_table;
 922                 frr_each (bgp_nexthop_cache, &(*tree)[family2afi(nhop.family)],
 923                           bnc) {
 924                         if (prefix_cmp(&bnc->prefix, &nhop))
 925                                 continue;
 926                         bgp_show_nexthop(vty, bgp, bnc, true);
 927                         found = true;
 928                 }
 929                 if (!found)
 930                         vty_out(vty, "nexthop %s does not have entry\n",
 931                                 nhopip_str);
 932         } else
 933                 bgp_show_nexthops(vty, bgp, import_table);
 934
 935         return CMD_SUCCESS;
 936 }
 937
 938 static void bgp_show_all_instances_nexthops_vty(struct vty *vty)
 939 {
 940         struct listnode *node, *nnode;
 941         struct bgp *bgp;
 942
 943         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 944                 vty_out(vty, "\nInstance %s:\n",
 945                         (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 946                                 ? VRF_DEFAULT_NAME
 947                                 : bgp->name);
 948                 bgp_show_nexthops(vty, bgp, false);
 949         }
 950 }
 951
 952 DEFUN (show_ip_bgp_nexthop,
 953        show_ip_bgp_nexthop_cmd,
 954        "show [ip] bgp [<view|vrf> VIEWVRFNAME] nexthop [<A.B.C.D|X:X::X:X>] [detail]",
 955        SHOW_STR
 956        IP_STR
 957        BGP_STR
 958        BGP_INSTANCE_HELP_STR
 959        "BGP nexthop table\n"
 960        "IPv4 nexthop address\n"
 961        "IPv6 nexthop address\n"
 962        "Show detailed information\n")
 963 {
 964         int idx = 0;
 965         int nh_idx = 0;
 966         char *vrf = NULL;
 967         char *nhop_ip = NULL;
 968
 969         if (argv_find(argv, argc, "view", &idx)
 970             || argv_find(argv, argc, "vrf", &idx))
 971                 vrf = argv[++idx]->arg;
 972
 973         if (argv_find(argv, argc, "A.B.C.D", &nh_idx)
 974             || argv_find(argv, argc, "X:X::X:X", &nh_idx))
 975                 nhop_ip = argv[nh_idx]->arg;
 976
 977         return show_ip_bgp_nexthop_table(vty, vrf, nhop_ip, false);
 978 }
 979
 980 DEFUN (show_ip_bgp_import_check,
 981        show_ip_bgp_import_check_cmd,
 982        "show [ip] bgp [<view|vrf> VIEWVRFNAME] import-check-table [detail]",
 983        SHOW_STR
 984        IP_STR
 985        BGP_STR
 986        BGP_INSTANCE_HELP_STR
 987        "BGP import check table\n"
 988        "Show detailed information\n")
 989 {
 990         int idx = 0;
 991         char *vrf = NULL;
 992
 993         if (argv_find(argv, argc, "view", &idx)
 994             || argv_find(argv, argc, "vrf", &idx))
 995                 vrf = argv[++idx]->arg;
 996
 997         return show_ip_bgp_nexthop_table(vty, vrf, NULL, true);
 998 }
 999
1000 DEFUN (show_ip_bgp_instance_all_nexthop,
1001        show_ip_bgp_instance_all_nexthop_cmd,
1002        "show [ip] bgp <view|vrf> all nexthop",
1003        SHOW_STR
1004        IP_STR
1005        BGP_STR
1006        BGP_INSTANCE_ALL_HELP_STR
1007        "BGP nexthop table\n")
1008 {
1009         bgp_show_all_instances_nexthops_vty(vty);
1010         return CMD_SUCCESS;
1011 }
1012
1013 void bgp_scan_init(struct bgp *bgp)
1014 {
1015         afi_t afi;
1016
1017         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1018                 bgp_nexthop_cache_init(&bgp->nexthop_cache_table[afi]);
1019                 bgp_nexthop_cache_init(&bgp->import_check_table[afi]);
1020                 bgp->connected_table[afi] = bgp_table_init(bgp, afi,
1021                         SAFI_UNICAST);
1022         }
1023 }
1024
1025 void bgp_scan_vty_init(void)
1026 {
1027         install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
1028         install_element(VIEW_NODE, &show_ip_bgp_import_check_cmd);
1029         install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
1030 }
1031
1032 void bgp_scan_finish(struct bgp *bgp)
1033 {
1034         afi_t afi;
1035
1036         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1037                 /* Only the current one needs to be reset. */
1038                 bgp_nexthop_cache_reset(&bgp->nexthop_cache_table[afi]);
1039                 bgp_nexthop_cache_reset(&bgp->import_check_table[afi]);
1040
1041                 bgp->connected_table[afi]->route_table->cleanup =
1042                         bgp_connected_cleanup;
1043                 bgp_table_unlock(bgp->connected_table[afi]);
1044                 bgp->connected_table[afi] = NULL;
1045         }
1046 }
1047
1048 char *bgp_nexthop_dump_bnc_flags(struct bgp_nexthop_cache *bnc, char *buf,
1049                                  size_t len)
1050 {
1051         if (bnc->flags == 0) {
1052                 snprintfrr(buf, len, "None ");
1053                 return buf;
1054         }
1055
1056         snprintfrr(buf, len, "%s%s%s%s%s%s%s",
1057                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID) ? "Valid " : "",
1058                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED) ? "Reg " : "",
1059                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED) ? "Conn " : "",
1060                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_PEER_NOTIFIED) ? "Notify "
1061                                                                      : "",
1062                    CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE) ? "Static " : "",
1063                    CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE_EXACT_MATCH)
1064                            ? "Static Exact "
1065                            : "",
1066                    CHECK_FLAG(bnc->flags, BGP_NEXTHOP_LABELED_VALID)
1067                            ? "Label Valid "
1068                            : "");
1069
1070         return buf;
1071 }
1072
1073 char *bgp_nexthop_dump_bnc_change_flags(struct bgp_nexthop_cache *bnc,
1074                                         char *buf, size_t len)
1075 {
1076         if (bnc->flags == 0) {
1077                 snprintfrr(buf, len, "None ");
1078                 return buf;
1079         }
1080
1081         snprintfrr(buf, len, "%s%s%s",
1082                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CHANGED)
1083                            ? "Changed "
1084                            : "",
1085                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_METRIC_CHANGED)
1086                            ? "Metric "
1087                            : "",
1088                    CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CONNECTED_CHANGED)
1089                            ? "Connected "
1090                            : "");
1091
1092         return buf;
1093 }