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
  37 #include "bgpd/bgpd.h"
  38 #include "bgpd/bgp_route.h"
  39 #include "bgpd/bgp_attr.h"
  40 #include "bgpd/bgp_nexthop.h"
  41 #include "bgpd/bgp_nht.h"
  42 #include "bgpd/bgp_debug.h"
  43 #include "bgpd/bgp_damp.h"
  44 #include "bgpd/bgp_fsm.h"
  45 #include "bgpd/bgp_vty.h"
  46 #include "bgpd/bgp_rd.h"
  47
  48 DEFINE_MTYPE_STATIC(BGPD, MARTIAN_STRING, "BGP Martian Address Intf String");
  49
  50 int bgp_nexthop_cache_compare(const struct bgp_nexthop_cache *a,
  51                               const struct bgp_nexthop_cache *b)
  52 {
  53         if (a->srte_color < b->srte_color)
  54                 return -1;
  55         if (a->srte_color > b->srte_color)
  56                 return 1;
  57
  58         return prefix_cmp(&a->prefix, &b->prefix);
  59 }
  60
  61 const char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size)
  62 {
  63         return prefix2str(&bnc->prefix, buf, size);
  64 }
  65
  66 void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
  67 {
  68         nexthops_free(bnc->nexthop);
  69 }
  70
  71 struct bgp_nexthop_cache *bnc_new(struct bgp_nexthop_cache_head *tree,
  72                                   struct prefix *prefix, uint32_t srte_color)
  73 {
  74         struct bgp_nexthop_cache *bnc;
  75
  76         bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
  77                       sizeof(struct bgp_nexthop_cache));
  78         bnc->prefix = *prefix;
  79         bnc->srte_color = srte_color;
  80         bnc->tree = tree;
  81         LIST_INIT(&(bnc->paths));
  82         bgp_nexthop_cache_add(tree, bnc);
  83
  84         return bnc;
  85 }
  86
  87 bool bnc_existing_for_prefix(struct bgp_nexthop_cache *bnc)
  88 {
  89         struct bgp_nexthop_cache *bnc_tmp;
  90
  91         frr_each (bgp_nexthop_cache, bnc->tree, bnc_tmp) {
  92                 if (bnc_tmp == bnc)
  93                         continue;
  94                 if (prefix_cmp(&bnc->prefix, &bnc_tmp->prefix) == 0)
  95                         return true;
  96         }
  97         return false;
  98 }
  99
 100 void bnc_free(struct bgp_nexthop_cache *bnc)
 101 {
 102         bnc_nexthop_free(bnc);
 103         bgp_nexthop_cache_del(bnc->tree, bnc);
 104         XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
 105 }
 106
 107 struct bgp_nexthop_cache *bnc_find(struct bgp_nexthop_cache_head *tree,
 108                                    struct prefix *prefix, uint32_t srte_color)
 109 {
 110         struct bgp_nexthop_cache bnc = {};
 111
 112         if (!tree)
 113                 return NULL;
 114
 115         bnc.prefix = *prefix;
 116         bnc.srte_color = srte_color;
 117         return bgp_nexthop_cache_find(tree, &bnc);
 118 }
 119
 120 /* Reset and free all BGP nexthop cache. */
 121 static void bgp_nexthop_cache_reset(struct bgp_nexthop_cache_head *tree)
 122 {
 123         struct bgp_nexthop_cache *bnc;
 124
 125         while (bgp_nexthop_cache_count(tree) > 0) {
 126                 bnc = bgp_nexthop_cache_first(tree);
 127
 128                 while (!LIST_EMPTY(&(bnc->paths))) {
 129                         struct bgp_path_info *path = LIST_FIRST(&(bnc->paths));
 130
 131                         path_nh_map(path, bnc, false);
 132                 }
 133
 134                 bnc_free(bnc);
 135         }
 136 }
 137
 138 static void *bgp_tip_hash_alloc(void *p)
 139 {
 140         const struct in_addr *val = (const struct in_addr *)p;
 141         struct tip_addr *addr;
 142
 143         addr = XMALLOC(MTYPE_TIP_ADDR, sizeof(struct tip_addr));
 144         addr->refcnt = 0;
 145         addr->addr.s_addr = val->s_addr;
 146
 147         return addr;
 148 }
 149
 150 static void bgp_tip_hash_free(void *addr)
 151 {
 152         XFREE(MTYPE_TIP_ADDR, addr);
 153 }
 154
 155 static unsigned int bgp_tip_hash_key_make(const void *p)
 156 {
 157         const struct tip_addr *addr = p;
 158
 159         return jhash_1word(addr->addr.s_addr, 0);
 160 }
 161
 162 static bool bgp_tip_hash_cmp(const void *p1, const void *p2)
 163 {
 164         const struct tip_addr *addr1 = p1;
 165         const struct tip_addr *addr2 = p2;
 166
 167         return addr1->addr.s_addr == addr2->addr.s_addr;
 168 }
 169
 170 void bgp_tip_hash_init(struct bgp *bgp)
 171 {
 172         bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
 173                                     "BGP TIP hash");
 174 }
 175
 176 void bgp_tip_hash_destroy(struct bgp *bgp)
 177 {
 178         if (bgp->tip_hash == NULL)
 179                 return;
 180         hash_clean(bgp->tip_hash, bgp_tip_hash_free);
 181         hash_free(bgp->tip_hash);
 182         bgp->tip_hash = NULL;
 183 }
 184
 185 void bgp_tip_add(struct bgp *bgp, struct in_addr *tip)
 186 {
 187         struct tip_addr tmp;
 188         struct tip_addr *addr;
 189
 190         tmp.addr = *tip;
 191
 192         addr = hash_get(bgp->tip_hash, &tmp, bgp_tip_hash_alloc);
 193         if (!addr)
 194                 return;
 195
 196         addr->refcnt++;
 197 }
 198
 199 void bgp_tip_del(struct bgp *bgp, struct in_addr *tip)
 200 {
 201         struct tip_addr tmp;
 202         struct tip_addr *addr;
 203
 204         tmp.addr = *tip;
 205
 206         addr = hash_lookup(bgp->tip_hash, &tmp);
 207         /* may have been deleted earlier by bgp_interface_down() */
 208         if (addr == NULL)
 209                 return;
 210
 211         addr->refcnt--;
 212
 213         if (addr->refcnt == 0) {
 214                 hash_release(bgp->tip_hash, addr);
 215                 XFREE(MTYPE_TIP_ADDR, addr);
 216         }
 217 }
 218
 219 /* BGP own address structure */
 220 struct bgp_addr {
 221         struct prefix p;
 222         struct list *ifp_name_list;
 223 };
 224
 225 static void show_address_entry(struct hash_bucket *bucket, void *args)
 226 {
 227         struct vty *vty = (struct vty *)args;
 228         struct bgp_addr *addr = (struct bgp_addr *)bucket->data;
 229         char *name;
 230         struct listnode *node;
 231         char str[INET6_ADDRSTRLEN] = {0};
 232
 233         vty_out(vty, "addr: %s, count: %d : ",
 234                 inet_ntop(addr->p.family, &(addr->p.u.prefix),
 235                           str, INET6_ADDRSTRLEN),
 236                 addr->ifp_name_list->count);
 237
 238         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 239                 vty_out(vty, " %s,", name);
 240         }
 241
 242         vty_out(vty, "\n");
 243 }
 244
 245 void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp)
 246 {
 247         hash_iterate(bgp->address_hash,
 248                      (void (*)(struct hash_bucket *, void *))show_address_entry,
 249                      vty);
 250 }
 251
 252 static void bgp_address_hash_string_del(void *val)
 253 {
 254         char *data = val;
 255
 256         XFREE(MTYPE_MARTIAN_STRING, data);
 257 }
 258
 259 static void *bgp_address_hash_alloc(void *p)
 260 {
 261         struct bgp_addr *copy_addr = p;
 262         struct bgp_addr *addr = NULL;
 263
 264         addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
 265         prefix_copy(&addr->p, &copy_addr->p);
 266
 267         addr->ifp_name_list = list_new();
 268         addr->ifp_name_list->del = bgp_address_hash_string_del;
 269
 270         return addr;
 271 }
 272
 273 static void bgp_address_hash_free(void *data)
 274 {
 275         struct bgp_addr *addr = data;
 276
 277         list_delete(&addr->ifp_name_list);
 278         XFREE(MTYPE_BGP_ADDR, addr);
 279 }
 280
 281 static unsigned int bgp_address_hash_key_make(const void *p)
 282 {
 283         const struct bgp_addr *addr = p;
 284
 285         return prefix_hash_key(&addr->p);
 286 }
 287
 288 static bool bgp_address_hash_cmp(const void *p1, const void *p2)
 289 {
 290         const struct bgp_addr *addr1 = p1;
 291         const struct bgp_addr *addr2 = p2;
 292
 293         return prefix_same(&addr1->p, &addr2->p);
 294 }
 295
 296 void bgp_address_init(struct bgp *bgp)
 297 {
 298         bgp->address_hash =
 299                 hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
 300                                 "BGP Connected Address Hash");
 301 }
 302
 303 void bgp_address_destroy(struct bgp *bgp)
 304 {
 305         if (bgp->address_hash == NULL)
 306                 return;
 307         hash_clean(bgp->address_hash, bgp_address_hash_free);
 308         hash_free(bgp->address_hash);
 309         bgp->address_hash = NULL;
 310 }
 311
 312 static void bgp_address_add(struct bgp *bgp, struct connected *ifc,
 313                             struct prefix *p)
 314 {
 315         struct bgp_addr tmp;
 316         struct bgp_addr *addr;
 317         struct listnode *node;
 318         char *name;
 319
 320         tmp.p = *p;
 321
 322         if (tmp.p.family == AF_INET)
 323                 tmp.p.prefixlen = IPV4_MAX_BITLEN;
 324         else if (tmp.p.family == AF_INET6)
 325                 tmp.p.prefixlen = IPV6_MAX_BITLEN;
 326
 327         addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);
 328
 329         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 330                 if (strcmp(ifc->ifp->name, name) == 0)
 331                         break;
 332         }
 333         if (!node) {
 334                 name = XSTRDUP(MTYPE_MARTIAN_STRING, ifc->ifp->name);
 335                 listnode_add(addr->ifp_name_list, name);
 336         }
 337 }
 338
 339 static void bgp_address_del(struct bgp *bgp, struct connected *ifc,
 340                             struct prefix *p)
 341 {
 342         struct bgp_addr tmp;
 343         struct bgp_addr *addr;
 344         struct listnode *node;
 345         char *name;
 346
 347         tmp.p = *p;
 348
 349         if (tmp.p.family == AF_INET)
 350                 tmp.p.prefixlen = IPV4_MAX_BITLEN;
 351         else if (tmp.p.family == AF_INET6)
 352                 tmp.p.prefixlen = IPV6_MAX_BITLEN;
 353
 354         addr = hash_lookup(bgp->address_hash, &tmp);
 355         /* may have been deleted earlier by bgp_interface_down() */
 356         if (addr == NULL)
 357                 return;
 358
 359         for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
 360                 if (strcmp(ifc->ifp->name, name) == 0)
 361                         break;
 362         }
 363
 364         if (node) {
 365                 list_delete_node(addr->ifp_name_list, node);
 366                 XFREE(MTYPE_MARTIAN_STRING, name);
 367         }
 368
 369         if (addr->ifp_name_list->count == 0) {
 370                 hash_release(bgp->address_hash, addr);
 371                 list_delete(&addr->ifp_name_list);
 372                 XFREE(MTYPE_BGP_ADDR, addr);
 373         }
 374 }
 375
 376
 377 struct bgp_connected_ref {
 378         unsigned int refcnt;
 379 };
 380
 381 void bgp_connected_add(struct bgp *bgp, struct connected *ifc)
 382 {
 383         struct prefix p;
 384         struct prefix *addr;
 385         struct bgp_dest *dest;
 386         struct bgp_connected_ref *bc;
 387         struct listnode *node, *nnode;
 388         struct peer *peer;
 389
 390         addr = ifc->address;
 391
 392         p = *(CONNECTED_PREFIX(ifc));
 393         if (addr->family == AF_INET) {
 394                 apply_mask_ipv4((struct prefix_ipv4 *)&p);
 395
 396                 if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
 397                         return;
 398
 399                 bgp_address_add(bgp, ifc, addr);
 400
 401                 dest = bgp_node_get(bgp->connected_table[AFI_IP],
 402                                     (struct prefix *)&p);
 403                 bc = bgp_dest_get_bgp_connected_ref_info(dest);
 404                 if (bc)
 405                         bc->refcnt++;
 406                 else {
 407                         bc = XCALLOC(MTYPE_BGP_CONN,
 408                                      sizeof(struct bgp_connected_ref));
 409                         bc->refcnt = 1;
 410                         bgp_dest_set_bgp_connected_ref_info(dest, bc);
 411                 }
 412
 413                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 414                         if (peer->conf_if
 415                             && (strcmp(peer->conf_if, ifc->ifp->name) == 0)
 416                             && peer->status != Established
 417                             && !CHECK_FLAG(peer->flags,
 418                                            PEER_FLAG_IFPEER_V6ONLY)) {
 419                                 if (peer_active(peer))
 420                                         BGP_EVENT_ADD(peer, BGP_Stop);
 421                                 BGP_EVENT_ADD(peer, BGP_Start);
 422                         }
 423                 }
 424         } else if (addr->family == AF_INET6) {
 425                 apply_mask_ipv6((struct prefix_ipv6 *)&p);
 426
 427                 if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
 428                         return;
 429
 430                 if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
 431                         return;
 432
 433                 bgp_address_add(bgp, ifc, addr);
 434
 435                 dest = bgp_node_get(bgp->connected_table[AFI_IP6],
 436                                     (struct prefix *)&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(struct tip_addr));
 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         char buf1[BUFSIZ];
 747
 748         vty_out(vty, "  Paths:\n");
 749         LIST_FOREACH (path, &(bnc->paths), nh_thread) {
 750                 dest = path->net;
 751                 assert(dest && bgp_dest_table(dest));
 752                 afi = family2afi(bgp_dest_get_prefix(dest)->family);
 753                 table = bgp_dest_table(dest);
 754                 safi = table->safi;
 755                 bgp_path = table->bgp;
 756
 757                 if (dest->pdest) {
 758                         prefix_rd2str((struct prefix_rd *)bgp_dest_get_prefix(dest->pdest),
 759                                         buf1, sizeof(buf1));
 760                         vty_out(vty, "    %d/%d %pBD RD %s %s flags 0x%x\n",
 761                                 afi, safi, dest, buf1, 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(nexthop->ifindex, bgp->vrf_id));
 786                         break;
 787                 case NEXTHOP_TYPE_IPV4:
 788                         vty_out(vty, "  gate %s\n",
 789                                 inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
 790                                           sizeof(buf)));
 791                         break;
 792                 case NEXTHOP_TYPE_IFINDEX:
 793                         vty_out(vty, "  if %s\n",
 794                                 ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
 795                         break;
 796                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 797                         vty_out(vty, "  gate %s, if %s\n",
 798                                 inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
 799                                           sizeof(buf)),
 800                                 ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
 801                         break;
 802                 case NEXTHOP_TYPE_BLACKHOLE:
 803                         vty_out(vty, "  blackhole\n");
 804                         break;
 805                 default:
 806                         vty_out(vty, "  invalid nexthop type %u\n",
 807                                 nexthop->type);
 808                 }
 809         }
 810 }
 811
 812 static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
 813                              struct bgp_nexthop_cache *bnc,
 814                              bool specific)
 815 {
 816         char buf[PREFIX2STR_BUFFER];
 817         time_t tbuf;
 818         struct peer *peer;
 819
 820         peer = (struct peer *)bnc->nht_info;
 821
 822         if (bnc->srte_color)
 823                 vty_out(vty, " SR-TE color %u -", bnc->srte_color);
 824         if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
 825                 vty_out(vty, " %s valid [IGP metric %d], #paths %d",
 826                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 827                                   buf, sizeof(buf)),
 828                         bnc->metric, bnc->path_count);
 829                 if (peer)
 830                         vty_out(vty, ", peer %s", peer->host);
 831                 vty_out(vty, "\n");
 832                 bgp_show_nexthops_detail(vty, bgp, bnc);
 833         } else {
 834                 vty_out(vty, " %s invalid, #paths %d",
 835                         inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix,
 836                                   buf, sizeof(buf)),
 837                         bnc->path_count);
 838                 if (peer)
 839                         vty_out(vty, ", peer %s", peer->host);
 840                 vty_out(vty, "\n");
 841                 if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
 842                         vty_out(vty, "  Must be Connected\n");
 843                 if (!CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED))
 844                         vty_out(vty, "  Is not Registered\n");
 845         }
 846         tbuf = time(NULL) - (bgp_clock() - bnc->last_update);
 847         vty_out(vty, "  Last update: %s", ctime(&tbuf));
 848         vty_out(vty, "\n");
 849
 850         /* show paths dependent on nexthop, if needed. */
 851         if (specific)
 852                 bgp_show_nexthop_paths(vty, bgp, bnc);
 853 }
 854
 855 static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp,
 856                               bool import_table)
 857 {
 858         struct bgp_nexthop_cache *bnc;
 859         afi_t afi;
 860         struct bgp_nexthop_cache_head(*tree)[AFI_MAX];
 861
 862         if (import_table)
 863                 vty_out(vty, "Current BGP import check cache:\n");
 864         else
 865                 vty_out(vty, "Current BGP nexthop cache:\n");
 866         if (import_table)
 867                 tree = &bgp->import_check_table;
 868         else
 869                 tree = &bgp->nexthop_cache_table;
 870         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 871                 frr_each (bgp_nexthop_cache, &(*tree)[afi], bnc)
 872                         bgp_show_nexthop(vty, bgp, bnc, false);
 873         }
 874 }
 875
 876 static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
 877                                      const char *nhopip_str,
 878                                      bool import_table)
 879 {
 880         struct bgp *bgp;
 881
 882         if (name)
 883                 bgp = bgp_lookup_by_name(name);
 884         else
 885                 bgp = bgp_get_default();
 886         if (!bgp) {
 887                 vty_out(vty, "%% No such BGP instance exist\n");
 888                 return CMD_WARNING;
 889         }
 890
 891         if (nhopip_str) {
 892                 struct prefix nhop;
 893                 struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
 894                 struct bgp_nexthop_cache *bnc;
 895
 896                 if (!str2prefix(nhopip_str, &nhop)) {
 897                         vty_out(vty, "nexthop address is malformed\n");
 898                         return CMD_WARNING;
 899                 }
 900                 tree = import_table ? &bgp->import_check_table
 901                                     : &bgp->nexthop_cache_table;
 902                 bnc = bnc_find(tree[family2afi(nhop.family)], &nhop, 0);
 903                 if (!bnc) {
 904                         vty_out(vty, "specified nexthop does not have entry\n");
 905                         return CMD_SUCCESS;
 906                 }
 907                 bgp_show_nexthop(vty, bgp, bnc, true);
 908         } else
 909                 bgp_show_nexthops(vty, bgp, import_table);
 910
 911         return CMD_SUCCESS;
 912 }
 913
 914 static void bgp_show_all_instances_nexthops_vty(struct vty *vty)
 915 {
 916         struct listnode *node, *nnode;
 917         struct bgp *bgp;
 918
 919         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 920                 vty_out(vty, "\nInstance %s:\n",
 921                         (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 922                                 ? VRF_DEFAULT_NAME
 923                                 : bgp->name);
 924                 bgp_show_nexthops(vty, bgp, false);
 925         }
 926 }
 927
 928 DEFUN (show_ip_bgp_nexthop,
 929        show_ip_bgp_nexthop_cmd,
 930        "show [ip] bgp [<view|vrf> VIEWVRFNAME] nexthop [<A.B.C.D|X:X::X:X>] [detail]",
 931        SHOW_STR
 932        IP_STR
 933        BGP_STR
 934        BGP_INSTANCE_HELP_STR
 935        "BGP nexthop table\n"
 936        "IPv4 nexthop address\n"
 937        "IPv6 nexthop address\n"
 938        "Show detailed information\n")
 939 {
 940         int idx = 0;
 941         int nh_idx = 0;
 942         char *vrf = NULL;
 943         char *nhop_ip = NULL;
 944
 945         if (argv_find(argv, argc, "view", &idx)
 946             || argv_find(argv, argc, "vrf", &idx))
 947                 vrf = argv[++idx]->arg;
 948
 949         if (argv_find(argv, argc, "A.B.C.D", &nh_idx)
 950             || argv_find(argv, argc, "X:X::X:X", &nh_idx))
 951                 nhop_ip = argv[nh_idx]->arg;
 952
 953         return show_ip_bgp_nexthop_table(vty, vrf, nhop_ip, false);
 954 }
 955
 956 DEFUN (show_ip_bgp_import_check,
 957        show_ip_bgp_import_check_cmd,
 958        "show [ip] bgp [<view|vrf> VIEWVRFNAME] import-check-table [detail]",
 959        SHOW_STR
 960        IP_STR
 961        BGP_STR
 962        BGP_INSTANCE_HELP_STR
 963        "BGP import check table\n"
 964        "Show detailed information\n")
 965 {
 966         int idx = 0;
 967         char *vrf = NULL;
 968
 969         if (argv_find(argv, argc, "view", &idx)
 970             || argv_find(argv, argc, "vrf", &idx))
 971                 vrf = argv[++idx]->arg;
 972
 973         return show_ip_bgp_nexthop_table(vty, vrf, NULL, true);
 974 }
 975
 976 DEFUN (show_ip_bgp_instance_all_nexthop,
 977        show_ip_bgp_instance_all_nexthop_cmd,
 978        "show [ip] bgp <view|vrf> all nexthop",
 979        SHOW_STR
 980        IP_STR
 981        BGP_STR
 982        BGP_INSTANCE_ALL_HELP_STR
 983        "BGP nexthop table\n")
 984 {
 985         bgp_show_all_instances_nexthops_vty(vty);
 986         return CMD_SUCCESS;
 987 }
 988
 989 void bgp_scan_init(struct bgp *bgp)
 990 {
 991         afi_t afi;
 992
 993         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 994                 bgp_nexthop_cache_init(&bgp->nexthop_cache_table[afi]);
 995                 bgp_nexthop_cache_init(&bgp->import_check_table[afi]);
 996                 bgp->connected_table[afi] = bgp_table_init(bgp, afi,
 997                         SAFI_UNICAST);
 998         }
 999 }
1000
1001 void bgp_scan_vty_init(void)
1002 {
1003         install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
1004         install_element(VIEW_NODE, &show_ip_bgp_import_check_cmd);
1005         install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
1006 }
1007
1008 void bgp_scan_finish(struct bgp *bgp)
1009 {
1010         afi_t afi;
1011
1012         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1013                 /* Only the current one needs to be reset. */
1014                 bgp_nexthop_cache_reset(&bgp->nexthop_cache_table[afi]);
1015                 bgp_nexthop_cache_reset(&bgp->import_check_table[afi]);
1016
1017                 bgp->connected_table[afi]->route_table->cleanup =
1018                         bgp_connected_cleanup;
1019                 bgp_table_unlock(bgp->connected_table[afi]);
1020                 bgp->connected_table[afi] = NULL;
1021         }
1022 }