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_table.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 "zebra/rib.h"
  48 #include "zebra/zserv.h"        /* For ZEBRA_SERV_PATH. */
  49
  50 char *
  51 bnc_str (struct bgp_nexthop_cache *bnc, char *buf, int size)
  52 {
  53   prefix2str(&(bnc->node->p), buf, size);
  54   return buf;
  55 }
  56
  57 void
  58 bnc_nexthop_free (struct bgp_nexthop_cache *bnc)
  59 {
  60   nexthops_free(bnc->nexthop);
  61 }
  62
  63 struct bgp_nexthop_cache *
  64 bnc_new (void)
  65 {
  66   struct bgp_nexthop_cache *bnc;
  67
  68   bnc = XCALLOC (MTYPE_BGP_NEXTHOP_CACHE, sizeof (struct bgp_nexthop_cache));
  69   LIST_INIT(&(bnc->paths));
  70   return bnc;
  71 }
  72
  73 void
  74 bnc_free (struct bgp_nexthop_cache *bnc)
  75 {
  76   bnc_nexthop_free (bnc);
  77   XFREE (MTYPE_BGP_NEXTHOP_CACHE, bnc);
  78 }
  79
  80 /* Reset and free all BGP nexthop cache. */
  81 static void
  82 bgp_nexthop_cache_reset (struct bgp_table *table)
  83 {
  84   struct bgp_node *rn;
  85   struct bgp_nexthop_cache *bnc;
  86
  87   for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn))
  88     if ((bnc = rn->info) != NULL)
  89       {
  90         bnc_free (bnc);
  91         rn->info = NULL;
  92         bgp_unlock_node (rn);
  93       }
  94 }
  95
  96 /* BGP own address structure */
  97 struct bgp_addr
  98 {
  99   struct in_addr addr;
 100   int refcnt;
 101 };
 102
 103 static void *
 104 bgp_address_hash_alloc (void *p)
 105 {
 106   const struct in_addr *val = (const struct in_addr *)p;
 107   struct bgp_addr *addr;
 108
 109   addr = XMALLOC (MTYPE_BGP_ADDR, sizeof (struct bgp_addr));
 110   addr->refcnt = 0;
 111   addr->addr.s_addr = val->s_addr;
 112
 113   return addr;
 114 }
 115
 116 static void
 117 bgp_address_hash_free (void *addr)
 118 {
 119   XFREE (MTYPE_BGP_ADDR, addr);
 120 }
 121
 122 static unsigned int
 123 bgp_address_hash_key_make (void *p)
 124 {
 125   const struct bgp_addr *addr = p;
 126
 127   return jhash_1word(addr->addr.s_addr, 0);
 128 }
 129
 130 static int
 131 bgp_address_hash_cmp (const void *p1, const void *p2)
 132 {
 133   const struct bgp_addr *addr1 = p1;
 134   const struct bgp_addr *addr2 = p2;
 135
 136   return addr1->addr.s_addr == addr2->addr.s_addr;
 137 }
 138
 139 void
 140 bgp_address_init (struct bgp *bgp)
 141 {
 142   bgp->address_hash = hash_create (bgp_address_hash_key_make,
 143                                   bgp_address_hash_cmp);
 144 }
 145
 146 void
 147 bgp_address_destroy (struct bgp *bgp)
 148 {
 149   if (bgp->address_hash == NULL)
 150     return;
 151   hash_clean(bgp->address_hash, bgp_address_hash_free);
 152   hash_free(bgp->address_hash);
 153   bgp->address_hash = NULL;
 154 }
 155
 156 static void
 157 bgp_address_add (struct bgp *bgp, struct prefix *p)
 158 {
 159   struct bgp_addr tmp;
 160   struct bgp_addr *addr;
 161
 162   tmp.addr = p->u.prefix4;
 163
 164   addr = hash_get (bgp->address_hash, &tmp, bgp_address_hash_alloc);
 165   if (!addr)
 166     return;
 167
 168   addr->refcnt++;
 169 }
 170
 171 static void
 172 bgp_address_del (struct bgp *bgp, struct prefix *p)
 173 {
 174   struct bgp_addr tmp;
 175   struct bgp_addr *addr;
 176
 177   tmp.addr = p->u.prefix4;
 178
 179   addr = hash_lookup (bgp->address_hash, &tmp);
 180   /* may have been deleted earlier by bgp_interface_down() */
 181   if (addr == NULL)
 182     return;
 183
 184   addr->refcnt--;
 185
 186   if (addr->refcnt == 0)
 187     {
 188       hash_release (bgp->address_hash, addr);
 189       XFREE (MTYPE_BGP_ADDR, addr);
 190     }
 191 }
 192
 193
 194 struct bgp_connected_ref
 195 {
 196   unsigned int refcnt;
 197 };
 198
 199 void
 200 bgp_connected_add (struct bgp *bgp, struct connected *ifc)
 201 {
 202   struct prefix p;
 203   struct prefix *addr;
 204   struct bgp_node *rn;
 205   struct bgp_connected_ref *bc;
 206   struct listnode *node, *nnode;
 207   struct peer *peer;
 208
 209   addr = ifc->address;
 210
 211   p = *(CONNECTED_PREFIX(ifc));
 212   if (addr->family == AF_INET)
 213     {
 214       apply_mask_ipv4 ((struct prefix_ipv4 *) &p);
 215
 216       if (prefix_ipv4_any ((struct prefix_ipv4 *) &p))
 217         return;
 218
 219       bgp_address_add (bgp, addr);
 220
 221       rn = bgp_node_get (bgp->connected_table[AFI_IP], (struct prefix *) &p);
 222       if (rn->info)
 223         {
 224           bc = rn->info;
 225           bc->refcnt++;
 226         }
 227       else
 228         {
 229           bc = XCALLOC (MTYPE_BGP_CONN, sizeof (struct bgp_connected_ref));
 230           bc->refcnt = 1;
 231           rn->info = bc;
 232         }
 233
 234       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
 235         {
 236           if (peer->conf_if && (strcmp (peer->conf_if, ifc->ifp->name) == 0) &&
 237               peer->status != Established &&
 238               !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
 239             {
 240               if (peer_active(peer))
 241                 BGP_EVENT_ADD (peer, BGP_Stop);
 242               BGP_EVENT_ADD (peer, BGP_Start);
 243             }
 244         }
 245     }
 246   else if (addr->family == AF_INET6)
 247     {
 248       apply_mask_ipv6 ((struct prefix_ipv6 *) &p);
 249
 250       if (IN6_IS_ADDR_UNSPECIFIED (&p.u.prefix6))
 251         return;
 252
 253       if (IN6_IS_ADDR_LINKLOCAL (&p.u.prefix6))
 254         return;
 255
 256       rn = bgp_node_get (bgp->connected_table[AFI_IP6], (struct prefix *) &p);
 257       if (rn->info)
 258         {
 259           bc = rn->info;
 260           bc->refcnt++;
 261         }
 262       else
 263         {
 264           bc = XCALLOC (MTYPE_BGP_CONN, sizeof (struct bgp_connected_ref));
 265           bc->refcnt = 1;
 266           rn->info = bc;
 267         }
 268     }
 269 }
 270
 271 void
 272 bgp_connected_delete (struct bgp *bgp, struct connected *ifc)
 273 {
 274   struct prefix p;
 275   struct prefix *addr;
 276   struct bgp_node *rn;
 277   struct bgp_connected_ref *bc;
 278
 279   addr = ifc->address;
 280
 281   p = *(CONNECTED_PREFIX(ifc));
 282   if (addr->family == AF_INET)
 283     {
 284       apply_mask_ipv4 ((struct prefix_ipv4 *) &p);
 285
 286       if (prefix_ipv4_any ((struct prefix_ipv4 *) &p))
 287         return;
 288
 289       bgp_address_del (bgp, addr);
 290
 291       rn = bgp_node_lookup (bgp->connected_table[AFI_IP], &p);
 292       if (! rn)
 293         return;
 294
 295       bc = rn->info;
 296       bc->refcnt--;
 297       if (bc->refcnt == 0)
 298         {
 299           XFREE (MTYPE_BGP_CONN, bc);
 300           rn->info = NULL;
 301         }
 302       bgp_unlock_node (rn);
 303       bgp_unlock_node (rn);
 304     }
 305   else if (addr->family == AF_INET6)
 306     {
 307       apply_mask_ipv6 ((struct prefix_ipv6 *) &p);
 308
 309       if (IN6_IS_ADDR_UNSPECIFIED (&p.u.prefix6))
 310         return;
 311
 312       if (IN6_IS_ADDR_LINKLOCAL (&p.u.prefix6))
 313         return;
 314
 315       rn = bgp_node_lookup (bgp->connected_table[AFI_IP6], (struct prefix *) &p);
 316       if (! rn)
 317         return;
 318
 319       bc = rn->info;
 320       bc->refcnt--;
 321       if (bc->refcnt == 0)
 322         {
 323           XFREE (MTYPE_BGP_CONN, bc);
 324           rn->info = NULL;
 325         }
 326       bgp_unlock_node (rn);
 327       bgp_unlock_node (rn);
 328     }
 329 }
 330
 331 int
 332 bgp_nexthop_self (struct bgp *bgp, struct attr *attr)
 333 {
 334   struct bgp_addr tmp, *addr;
 335
 336   tmp.addr = attr->nexthop;
 337
 338   addr = hash_lookup (bgp->address_hash, &tmp);
 339   if (addr)
 340     return 1;
 341
 342   return 0;
 343 }
 344
 345 int
 346 bgp_multiaccess_check_v4 (struct in_addr nexthop, struct peer *peer)
 347 {
 348   struct bgp_node *rn1;
 349   struct bgp_node *rn2;
 350   struct prefix p;
 351   int ret;
 352
 353   p.family = AF_INET;
 354   p.prefixlen = IPV4_MAX_BITLEN;
 355   p.u.prefix4 = nexthop;
 356
 357   rn1 = bgp_node_match (peer->bgp->connected_table[AFI_IP], &p);
 358   if (!rn1)
 359     return 0;
 360
 361   p.family = AF_INET;
 362   p.prefixlen = IPV4_MAX_BITLEN;
 363   p.u.prefix4 = peer->su.sin.sin_addr;
 364
 365   rn2 = bgp_node_match (peer->bgp->connected_table[AFI_IP], &p);
 366   if (!rn2)
 367     {
 368       bgp_unlock_node(rn1);
 369       return 0;
 370     }
 371
 372   ret = (rn1 == rn2) ? 1 : 0;
 373
 374   bgp_unlock_node(rn1);
 375   bgp_unlock_node(rn2);
 376
 377   return (ret);
 378 }
 379
 380 static void
 381 bgp_show_nexthops (struct vty *vty, struct bgp *bgp, int detail)
 382 {
 383   struct bgp_node *rn;
 384   struct bgp_nexthop_cache *bnc;
 385   char buf[PREFIX2STR_BUFFER];
 386   struct nexthop *nexthop;
 387   time_t tbuf;
 388   afi_t afi;
 389
 390   vty_out (vty, "Current BGP nexthop cache:%s", VTY_NEWLINE);
 391   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
 392     {
 393       if (!bgp->nexthop_cache_table[afi])
 394         continue;
 395
 396       for (rn = bgp_table_top (bgp->nexthop_cache_table[afi]); rn; rn = bgp_route_next (rn))
 397         {
 398           if ((bnc = rn->info) != NULL)
 399             {
 400               if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID))
 401                 {
 402                   vty_out (vty, " %s valid [IGP metric %d], #paths %d%s",
 403                            inet_ntop (rn->p.family, &rn->p.u.prefix, buf, sizeof (buf)),
 404                            bnc->metric, bnc->path_count, VTY_NEWLINE);
 405                   if (detail)
 406                     for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next)
 407                       switch (nexthop->type)
 408                         {
 409                         case NEXTHOP_TYPE_IPV6:
 410                           vty_out (vty, "  gate %s%s",
 411                                    inet_ntop (AF_INET6, &nexthop->gate.ipv6,
 412                                               buf, sizeof (buf)), VTY_NEWLINE);
 413                           break;
 414                         case NEXTHOP_TYPE_IPV6_IFINDEX:
 415                           vty_out(vty, "  gate %s, if %s%s",
 416                                   inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
 417                                             sizeof (buf)),
 418                                   ifindex2ifname(nexthop->ifindex, bgp->vrf_id),
 419                                   VTY_NEWLINE);
 420                           break;
 421                         case NEXTHOP_TYPE_IPV4:
 422                           vty_out (vty, "  gate %s%s",
 423                                    inet_ntop (AF_INET, &nexthop->gate.ipv4, buf,
 424                                               sizeof (buf)), VTY_NEWLINE);
 425                           break;
 426                         case NEXTHOP_TYPE_IFINDEX:
 427                           vty_out (vty, "  if %s%s",
 428                                    ifindex2ifname(nexthop->ifindex, bgp->vrf_id), VTY_NEWLINE);
 429                           break;
 430                         case NEXTHOP_TYPE_IPV4_IFINDEX:
 431                           vty_out (vty, "  gate %s, if %s%s",
 432                                    inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
 433                                              sizeof (buf)),
 434                                    ifindex2ifname(nexthop->ifindex, bgp->vrf_id), VTY_NEWLINE);
 435                           break;
 436                         default:
 437                           vty_out (vty, "  invalid nexthop type %u%s",
 438                                    nexthop->type, VTY_NEWLINE);
 439                         }
 440                 }
 441               else
 442                 {
 443                   vty_out (vty, " %s invalid%s",
 444                            inet_ntop (rn->p.family, &rn->p.u.prefix,
 445                                       buf, sizeof (buf)), VTY_NEWLINE);
 446                   if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
 447                     vty_out (vty, "  Must be Connected%s", VTY_NEWLINE);
 448                 }
 449               tbuf = time(NULL) - (bgp_clock() - bnc->last_update);
 450               vty_out (vty, "  Last update: %s", ctime(&tbuf));
 451               vty_out(vty, "%s", VTY_NEWLINE);
 452             }
 453         }
 454     }
 455 }
 456
 457 static int
 458 show_ip_bgp_nexthop_table (struct vty *vty, const char *name, int detail)
 459 {
 460   struct bgp *bgp;
 461
 462   if (name)
 463     bgp = bgp_lookup_by_name (name);
 464   else
 465     bgp = bgp_get_default ();
 466   if (!bgp)
 467     {
 468       vty_out (vty, "%% No such BGP instance exist%s", VTY_NEWLINE);
 469       return CMD_WARNING;
 470     }
 471
 472   bgp_show_nexthops (vty, bgp, detail);
 473
 474   return CMD_SUCCESS;
 475 }
 476
 477 static void
 478 bgp_show_all_instances_nexthops_vty (struct vty *vty)
 479 {
 480   struct listnode *node, *nnode;
 481   struct bgp *bgp;
 482
 483   for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
 484     {
 485       vty_out (vty, "%sInstance %s:%s",
 486                VTY_NEWLINE,
 487                (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) ? "Default" : bgp->name,
 488                VTY_NEWLINE);
 489       bgp_show_nexthops (vty, bgp, 0);
 490     }
 491 }
 492
 493 DEFUN (show_ip_bgp_nexthop,
 494        show_ip_bgp_nexthop_cmd,
 495        "show [ip] bgp [<view|vrf> VIEWVRFNAME] nexthop [detail]",
 496        SHOW_STR
 497        IP_STR
 498        BGP_STR
 499        BGP_INSTANCE_HELP_STR
 500        "BGP nexthop table\n"
 501        "Show detailed information\n")
 502 {
 503   int idx = 0;
 504   char *vrf = argv_find (argv, argc, "WORD", &idx) ? argv[idx]->arg : NULL;
 505   int detail = argv_find (argv, argc, "detail", &idx) ? 1 : 0;
 506   return show_ip_bgp_nexthop_table (vty, vrf, detail);
 507 }
 508
 509 DEFUN (show_ip_bgp_instance_all_nexthop,
 510        show_ip_bgp_instance_all_nexthop_cmd,
 511        "show [ip] bgp <view|vrf> all nexthop",
 512        SHOW_STR
 513        IP_STR
 514        BGP_STR
 515        BGP_INSTANCE_ALL_HELP_STR
 516        "BGP nexthop table\n")
 517 {
 518   bgp_show_all_instances_nexthops_vty (vty);
 519   return CMD_SUCCESS;
 520 }
 521
 522 void
 523 bgp_scan_init (struct bgp *bgp)
 524 {
 525   afi_t afi;
 526
 527   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 528     {
 529       bgp->nexthop_cache_table[afi] = bgp_table_init (afi, SAFI_UNICAST);
 530       bgp->connected_table[afi] = bgp_table_init (afi, SAFI_UNICAST);
 531       bgp->import_check_table[afi] = bgp_table_init (afi, SAFI_UNICAST);
 532     }
 533 }
 534
 535 void
 536 bgp_scan_vty_init (void)
 537 {
 538   install_element (VIEW_NODE, &show_ip_bgp_nexthop_cmd);
 539   install_element (VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
 540 }
 541
 542 void
 543 bgp_scan_finish (struct bgp *bgp)
 544 {
 545   afi_t afi;
 546
 547   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 548     {
 549       /* Only the current one needs to be reset. */
 550       bgp_nexthop_cache_reset (bgp->nexthop_cache_table[afi]);
 551       bgp_table_unlock (bgp->nexthop_cache_table[afi]);
 552       bgp->nexthop_cache_table[afi] = NULL;
 553
 554       bgp_table_unlock (bgp->connected_table[afi]);
 555       bgp->connected_table[afi] = NULL;
 556
 557       bgp_table_unlock (bgp->import_check_table[afi]);
 558       bgp->import_check_table[afi] = NULL;
 559     }
 560 }