pbrd/pbr_nht.c

   1 /*
   2  * PBR-nht Code
   3  * Copyright (C) 2018 Cumulus Networks, Inc.
   4  *               Donald Sharp
   5  *
   6  * FRR 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  * FRR 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 #include <zebra.h>
  21
  22 #include <log.h>
  23 #include <nexthop.h>
  24 #include <nexthop_group.h>
  25 #include <hash.h>
  26 #include <jhash.h>
  27 #include <vty.h>
  28 #include <zclient.h>
  29 #include <debug.h>
  30
  31 #include "pbrd/pbr_nht.h"
  32 #include "pbrd/pbr_map.h"
  33 #include "pbrd/pbr_zebra.h"
  34 #include "pbrd/pbr_memory.h"
  35 #include "pbrd/pbr_debug.h"
  36
  37 DEFINE_MTYPE_STATIC(PBRD, PBR_NHG, "PBR Nexthop Groups")
  38
  39 static struct hash *pbr_nhg_hash;
  40 static struct hash *pbr_nhrc_hash;
  41
  42 static uint32_t pbr_nhg_low_table;
  43 static uint32_t pbr_nhg_high_table;
  44 static uint32_t pbr_nhg_low_rule;
  45 static uint32_t pbr_nhg_high_rule;
  46 static bool nhg_tableid[65535];
  47
  48 static void pbr_nht_install_nexthop_group(struct pbr_nexthop_group_cache *pnhgc,
  49                                           struct nexthop_group nhg);
  50 static void
  51 pbr_nht_uninstall_nexthop_group(struct pbr_nexthop_group_cache *pnhgc,
  52                                 struct nexthop_group nhg,
  53                                 enum nexthop_types_t nh_afi);
  54
  55 /*
  56  * Nexthop refcount.
  57  */
  58 struct nhrc {
  59         struct nexthop nexthop;
  60         unsigned int refcount;
  61 };
  62
  63 /* Hash functions for pbr_nhrc_hash ---------------------------------------- */
  64
  65 static void *pbr_nhrc_hash_alloc(void *p)
  66 {
  67         struct nhrc *nhrc = XCALLOC(MTYPE_PBR_NHG, sizeof(struct nhrc));
  68         nhrc->nexthop = *(struct nexthop *)p;
  69         return nhrc;
  70 }
  71
  72 static int pbr_nhrc_hash_equal(const void *arg1, const void *arg2)
  73 {
  74         const struct nexthop *nh1, *nh2;
  75
  76         nh1 = arg1;
  77         nh2 = arg2;
  78
  79         return nexthop_same(nh1, nh2);
  80 }
  81
  82 /* ------------------------------------------------------------------------- */
  83
  84 static void *pbr_nh_alloc(void *p)
  85 {
  86         struct pbr_nexthop_cache *new;
  87         struct pbr_nexthop_cache *pnhc = (struct pbr_nexthop_cache *)p;
  88         struct nhrc *nhrc;
  89
  90         new = XCALLOC(MTYPE_PBR_NHG, sizeof(*new));
  91         nhrc = hash_get(pbr_nhrc_hash, pnhc->nexthop, pbr_nhrc_hash_alloc);
  92         new->nexthop = &nhrc->nexthop;
  93
  94         /* Decremented again in pbr_nh_delete */
  95         ++nhrc->refcount;
  96
  97         DEBUGD(&pbr_dbg_nht, "%s: Sending nexthop to Zebra",
  98                __PRETTY_FUNCTION__);
  99
 100         pbr_send_rnh(new->nexthop, true);
 101
 102         new->valid = false;
 103         return new;
 104 }
 105
 106 static void pbr_nh_delete(struct pbr_nexthop_cache **pnhc)
 107 {
 108         struct nhrc *nhrc;
 109
 110         nhrc = hash_lookup(pbr_nhrc_hash, (*pnhc)->nexthop);
 111
 112         if (nhrc)
 113                 --nhrc->refcount;
 114         if (!nhrc || nhrc->refcount == 0) {
 115                 DEBUGD(&pbr_dbg_nht, "%s: Removing nexthop from Zebra",
 116                        __PRETTY_FUNCTION__);
 117                 pbr_send_rnh((*pnhc)->nexthop, false);
 118         }
 119         if (nhrc && nhrc->refcount == 0) {
 120                 hash_release(pbr_nhrc_hash, nhrc);
 121                 XFREE(MTYPE_PBR_NHG, nhrc);
 122         }
 123
 124         XFREE(MTYPE_PBR_NHG, *pnhc);
 125 }
 126
 127 static void pbr_nh_delete_iterate(struct hash_backet *b, void *p)
 128 {
 129         pbr_nh_delete((struct pbr_nexthop_cache **)&b->data);
 130 }
 131
 132 static uint32_t pbr_nh_hash_key(void *arg)
 133 {
 134         uint32_t key;
 135         struct pbr_nexthop_cache *pbrnc = (struct pbr_nexthop_cache *)arg;
 136
 137         key = nexthop_hash(pbrnc->nexthop);
 138
 139         return key;
 140 }
 141
 142 static int pbr_nh_hash_equal(const void *arg1, const void *arg2)
 143 {
 144         const struct pbr_nexthop_cache *pbrnc1 =
 145                 (const struct pbr_nexthop_cache *)arg1;
 146         const struct pbr_nexthop_cache *pbrnc2 =
 147                 (const struct pbr_nexthop_cache *)arg2;
 148
 149         if (pbrnc1->nexthop->vrf_id != pbrnc2->nexthop->vrf_id)
 150                 return 0;
 151
 152         if (pbrnc1->nexthop->ifindex != pbrnc2->nexthop->ifindex)
 153                 return 0;
 154
 155         if (pbrnc1->nexthop->type != pbrnc2->nexthop->type)
 156                 return 0;
 157
 158         switch (pbrnc1->nexthop->type) {
 159         case NEXTHOP_TYPE_IFINDEX:
 160                 return 1;
 161         case NEXTHOP_TYPE_IPV4_IFINDEX:
 162         case NEXTHOP_TYPE_IPV4:
 163                 return pbrnc1->nexthop->gate.ipv4.s_addr
 164                        == pbrnc2->nexthop->gate.ipv4.s_addr;
 165         case NEXTHOP_TYPE_IPV6_IFINDEX:
 166         case NEXTHOP_TYPE_IPV6:
 167                 return !memcmp(&pbrnc1->nexthop->gate.ipv6,
 168                                &pbrnc2->nexthop->gate.ipv6, 16);
 169         case NEXTHOP_TYPE_BLACKHOLE:
 170                 return pbrnc1->nexthop->bh_type == pbrnc2->nexthop->bh_type;
 171         }
 172
 173         /*
 174          * We should not get here
 175          */
 176         return 0;
 177 }
 178
 179 static void pbr_nhgc_delete(struct pbr_nexthop_group_cache *p)
 180 {
 181         hash_iterate(p->nhh, pbr_nh_delete_iterate, NULL);
 182         hash_free(p->nhh);
 183         XFREE(MTYPE_PBR_NHG, p);
 184 }
 185
 186 static void *pbr_nhgc_alloc(void *p)
 187 {
 188         struct pbr_nexthop_group_cache *new;
 189         struct pbr_nexthop_group_cache *pnhgc =
 190                 (struct pbr_nexthop_group_cache *)p;
 191
 192         new = XCALLOC(MTYPE_PBR_NHG, sizeof(*new));
 193
 194         strcpy(new->name, pnhgc->name);
 195         new->table_id = pbr_nht_get_next_tableid();
 196
 197         DEBUGD(&pbr_dbg_nht, "%s: NHT: %s assigned Table ID: %u",
 198                __PRETTY_FUNCTION__, new->name, new->table_id);
 199
 200         new->nhh = hash_create_size(8, pbr_nh_hash_key, pbr_nh_hash_equal,
 201                                     "PBR NH Cache Hash");
 202         return new;
 203 }
 204
 205
 206 void pbr_nhgroup_add_cb(const char *name)
 207 {
 208         struct pbr_nexthop_group_cache *pnhgc;
 209         struct nexthop_group_cmd *nhgc;
 210
 211         nhgc = nhgc_find(name);
 212
 213         if (!nhgc) {
 214                 DEBUGD(&pbr_dbg_nht, "%s: Could not find nhgc with name: %s\n",
 215                        __PRETTY_FUNCTION__, name);
 216                 return;
 217         }
 218
 219         pnhgc = pbr_nht_add_group(name);
 220
 221         DEBUGD(&pbr_dbg_nht, "%s: Added nexthop-group %s", __PRETTY_FUNCTION__,
 222                name);
 223
 224         pbr_nht_install_nexthop_group(pnhgc, nhgc->nhg);
 225         pbr_map_check_nh_group_change(name);
 226 }
 227
 228 void pbr_nhgroup_add_nexthop_cb(const struct nexthop_group_cmd *nhgc,
 229                                 const struct nexthop *nhop)
 230 {
 231         char debugstr[256];
 232         struct pbr_nexthop_group_cache pnhgc_find = {};
 233         struct pbr_nexthop_group_cache *pnhgc;
 234         struct pbr_nexthop_cache pnhc_find = {};
 235         struct pbr_nexthop_cache *pnhc;
 236
 237         /* find pnhgc by name */
 238         strlcpy(pnhgc_find.name, nhgc->name, sizeof(pnhgc_find.name));
 239         pnhgc = hash_get(pbr_nhg_hash, &pnhgc_find, pbr_nhgc_alloc);
 240
 241         /* create & insert new pnhc into pnhgc->nhh */
 242         pnhc_find.nexthop = (struct nexthop *)nhop;
 243         pnhc = hash_get(pnhgc->nhh, &pnhc_find, pbr_nh_alloc);
 244         pnhc_find.nexthop = NULL;
 245
 246         /* set parent pnhgc */
 247         pnhc->parent = pnhgc;
 248
 249         if (DEBUG_MODE_CHECK(&pbr_dbg_nht, DEBUG_MODE_ALL)) {
 250                 nexthop2str(nhop, debugstr, sizeof(debugstr));
 251                 DEBUGD(&pbr_dbg_nht, "%s: Added %s to nexthop-group %s",
 252                        __PRETTY_FUNCTION__, debugstr, nhgc->name);
 253         }
 254
 255         pbr_nht_install_nexthop_group(pnhgc, nhgc->nhg);
 256         pbr_map_check_nh_group_change(nhgc->name);
 257 }
 258
 259 void pbr_nhgroup_del_nexthop_cb(const struct nexthop_group_cmd *nhgc,
 260                                 const struct nexthop *nhop)
 261 {
 262         char debugstr[256];
 263         struct pbr_nexthop_group_cache pnhgc_find = {};
 264         struct pbr_nexthop_group_cache *pnhgc;
 265         struct pbr_nexthop_cache pnhc_find = {};
 266         struct pbr_nexthop_cache *pnhc;
 267         enum nexthop_types_t nh_afi = nhop->type;
 268
 269         /* find pnhgc by name */
 270         strlcpy(pnhgc_find.name, nhgc->name, sizeof(pnhgc_find.name));
 271         pnhgc = hash_get(pbr_nhg_hash, &pnhgc_find, pbr_nhgc_alloc);
 272
 273         /* delete pnhc from pnhgc->nhh */
 274         pnhc_find.nexthop = (struct nexthop *)nhop;
 275         pnhc = hash_release(pnhgc->nhh, &pnhc_find);
 276
 277         /* delete pnhc */
 278         pbr_nh_delete(&pnhc);
 279
 280         if (DEBUG_MODE_CHECK(&pbr_dbg_nht, DEBUG_MODE_ALL)) {
 281                 nexthop2str(nhop, debugstr, sizeof(debugstr));
 282                 DEBUGD(&pbr_dbg_nht, "%s: Removed %s from nexthop-group %s",
 283                        __PRETTY_FUNCTION__, debugstr, nhgc->name);
 284         }
 285
 286         if (pnhgc->nhh->count)
 287                 pbr_nht_install_nexthop_group(pnhgc, nhgc->nhg);
 288         else
 289                 pbr_nht_uninstall_nexthop_group(pnhgc, nhgc->nhg, nh_afi);
 290
 291         pbr_map_check_nh_group_change(nhgc->name);
 292 }
 293
 294 void pbr_nhgroup_delete_cb(const char *name)
 295 {
 296         DEBUGD(&pbr_dbg_nht, "%s: Removed nexthop-group %s",
 297                __PRETTY_FUNCTION__, name);
 298
 299         /* delete group from all pbrms's */
 300         pbr_nht_delete_group(name);
 301
 302         pbr_map_check_nh_group_change(name);
 303 }
 304
 305 #if 0
 306 static struct pbr_nexthop_cache *pbr_nht_lookup_nexthop(struct nexthop *nexthop)
 307 {
 308         return NULL;
 309 }
 310 #endif
 311
 312 static void pbr_nht_find_nhg_from_table_install(struct hash_backet *b,
 313                                                 void *data)
 314 {
 315         struct pbr_nexthop_group_cache *pnhgc =
 316                 (struct pbr_nexthop_group_cache *)b->data;
 317         uint32_t *table_id = (uint32_t *)data;
 318
 319         if (pnhgc->table_id == *table_id) {
 320                 DEBUGD(&pbr_dbg_nht, "%s: Table ID (%u) matches %s",
 321                        __PRETTY_FUNCTION__, *table_id, pnhgc->name);
 322
 323                 /*
 324                  * If the table has been re-handled by zebra
 325                  * and we are already installed no need to do
 326                  * anything here.
 327                  */
 328                 if (!pnhgc->installed) {
 329                         pnhgc->installed = true;
 330                         pbr_map_schedule_policy_from_nhg(pnhgc->name);
 331                 }
 332         }
 333 }
 334
 335 void pbr_nht_route_installed_for_table(uint32_t table_id)
 336 {
 337         hash_iterate(pbr_nhg_hash, pbr_nht_find_nhg_from_table_install,
 338                      &table_id);
 339 }
 340
 341 static void pbr_nht_find_nhg_from_table_remove(struct hash_backet *b,
 342                                                void *data)
 343 {
 344         ;
 345 }
 346
 347 void pbr_nht_route_removed_for_table(uint32_t table_id)
 348 {
 349         hash_iterate(pbr_nhg_hash, pbr_nht_find_nhg_from_table_remove,
 350                      &table_id);
 351 }
 352
 353 /*
 354  * Loop through all nexthops in a nexthop group to check that they are all the
 355  * same. If they are not all the same, log this peculiarity.
 356  *
 357  * nhg
 358  *    The nexthop group to check
 359  *
 360  * Returns:
 361  *    - AFI of last nexthop in the group
 362  *    - AFI_MAX on error
 363  */
 364 static afi_t pbr_nht_which_afi(struct nexthop_group nhg,
 365                                enum nexthop_types_t nh_afi)
 366 {
 367         struct nexthop *nexthop;
 368         afi_t install_afi = AFI_MAX;
 369         bool v6, v4, bh;
 370
 371         v6 = v4 = bh = false;
 372
 373         if (!nh_afi) {
 374                 for (ALL_NEXTHOPS(nhg, nexthop)) {
 375                         nh_afi = nexthop->type;
 376                         break;
 377                 }
 378         }
 379
 380         switch (nh_afi) {
 381         case NEXTHOP_TYPE_IFINDEX:
 382                 break;
 383         case NEXTHOP_TYPE_IPV4:
 384         case NEXTHOP_TYPE_IPV4_IFINDEX:
 385                 v6 = true;
 386                 install_afi = AFI_IP;
 387                 break;
 388         case NEXTHOP_TYPE_IPV6:
 389         case NEXTHOP_TYPE_IPV6_IFINDEX:
 390                 v4 = true;
 391                 install_afi = AFI_IP6;
 392                 break;
 393         case NEXTHOP_TYPE_BLACKHOLE:
 394                 bh = true;
 395                 install_afi = AFI_MAX;
 396                 break;
 397         }
 398
 399         if (!bh && v6 && v4)
 400                 DEBUGD(&pbr_dbg_nht,
 401                        "%s: Saw both V6 and V4 nexthops...using %s",
 402                        __PRETTY_FUNCTION__, afi2str(install_afi));
 403         if (bh && (v6 || v4))
 404                 DEBUGD(&pbr_dbg_nht,
 405                        "%s: Saw blackhole nexthop(s) with %s%s%s nexthop(s), using AFI_MAX.",
 406                        __PRETTY_FUNCTION__, v4 ? "v4" : "",
 407                        (v4 && v6) ? " and " : "", v6 ? "v6" : "");
 408
 409         return install_afi;
 410 }
 411
 412 static void pbr_nht_install_nexthop_group(struct pbr_nexthop_group_cache *pnhgc,
 413                                           struct nexthop_group nhg)
 414 {
 415         afi_t install_afi;
 416         enum nexthop_types_t nh_afi = 0;
 417
 418         install_afi = pbr_nht_which_afi(nhg, nh_afi);
 419
 420         route_add(pnhgc, nhg, install_afi);
 421 }
 422
 423 static void
 424 pbr_nht_uninstall_nexthop_group(struct pbr_nexthop_group_cache *pnhgc,
 425                                 struct nexthop_group nhg,
 426                                 enum nexthop_types_t nh_afi)
 427 {
 428         afi_t install_afi;
 429
 430         install_afi = pbr_nht_which_afi(nhg, nh_afi);
 431
 432         pnhgc->installed = false;
 433         pnhgc->valid = false;
 434         route_delete(pnhgc, install_afi);
 435 }
 436
 437 void pbr_nht_change_group(const char *name)
 438 {
 439         struct nexthop_group_cmd *nhgc;
 440         struct pbr_nexthop_group_cache *pnhgc;
 441         struct pbr_nexthop_group_cache find;
 442         struct nexthop *nhop;
 443
 444         nhgc = nhgc_find(name);
 445         if (!nhgc)
 446                 return;
 447
 448         memset(&find, 0, sizeof(find));
 449         snprintf(find.name, sizeof(find.name), "%s", name);
 450         pnhgc = hash_lookup(pbr_nhg_hash, &find);
 451
 452         if (!pnhgc) {
 453                 DEBUGD(&pbr_dbg_nht,
 454                        "%s: Could not find nexthop-group cache w/ name '%s'",
 455                        __PRETTY_FUNCTION__, name);
 456                 return;
 457         }
 458
 459         for (ALL_NEXTHOPS(nhgc->nhg, nhop)) {
 460                 struct pbr_nexthop_cache lookup;
 461                 struct pbr_nexthop_cache *pnhc;
 462
 463                 lookup.nexthop = nhop;
 464                 pnhc = hash_lookup(pnhgc->nhh, &lookup);
 465                 if (!pnhc) {
 466                         pnhc = hash_get(pnhgc->nhh, &lookup, pbr_nh_alloc);
 467                         pnhc->parent = pnhgc;
 468                 }
 469         }
 470         pbr_nht_install_nexthop_group(pnhgc, nhgc->nhg);
 471 }
 472
 473 char *pbr_nht_nexthop_make_name(char *name, size_t l,
 474                                 uint32_t seqno, char *buffer)
 475 {
 476         snprintf(buffer, l, "%s%u", name, seqno);
 477         return buffer;
 478 }
 479
 480 void pbr_nht_add_individual_nexthop(struct pbr_map_sequence *pbrms)
 481 {
 482         struct pbr_nexthop_group_cache *pnhgc;
 483         struct pbr_nexthop_group_cache find;
 484         struct pbr_nexthop_cache *pnhc;
 485         struct pbr_nexthop_cache lookup;
 486
 487         memset(&find, 0, sizeof(find));
 488         pbr_nht_nexthop_make_name(pbrms->parent->name, PBR_MAP_NAMELEN,
 489                                   pbrms->seqno, find.name);
 490         if (!pbrms->internal_nhg_name)
 491                 pbrms->internal_nhg_name = XSTRDUP(MTYPE_TMP, find.name);
 492
 493         pnhgc = hash_get(pbr_nhg_hash, &find, pbr_nhgc_alloc);
 494
 495         lookup.nexthop = pbrms->nhg->nexthop;
 496         pnhc = hash_get(pnhgc->nhh, &lookup, pbr_nh_alloc);
 497         pnhc->parent = pnhgc;
 498         pbr_nht_install_nexthop_group(pnhgc, *pbrms->nhg);
 499 }
 500
 501 void pbr_nht_delete_individual_nexthop(struct pbr_map_sequence *pbrms)
 502 {
 503         struct pbr_nexthop_group_cache *pnhgc;
 504         struct pbr_nexthop_group_cache find;
 505         struct pbr_nexthop_cache *pnhc;
 506         struct pbr_nexthop_cache lup;
 507         struct pbr_map *pbrm = pbrms->parent;
 508         struct listnode *node;
 509         struct pbr_map_interface *pmi;
 510         struct nexthop *nh;
 511         enum nexthop_types_t nh_afi = 0;
 512
 513         if (pbrm->valid && pbrms->nhs_installed && pbrm->incoming->count) {
 514                 for (ALL_LIST_ELEMENTS_RO(pbrm->incoming, node, pmi))
 515                         pbr_send_pbr_map(pbrms, pmi, false);
 516         }
 517
 518         pbrm->valid = false;
 519         pbrms->nhs_installed = false;
 520         pbrms->reason |= PBR_MAP_INVALID_NO_NEXTHOPS;
 521
 522         memset(&find, 0, sizeof(find));
 523         snprintf(find.name, sizeof(find.name), "%s", pbrms->internal_nhg_name);
 524         pnhgc = hash_lookup(pbr_nhg_hash, &find);
 525
 526         nh = pbrms->nhg->nexthop;
 527         nh_afi = nh->type;
 528         lup.nexthop = nh;
 529         pnhc = hash_lookup(pnhgc->nhh, &lup);
 530         pnhc->parent = NULL;
 531         hash_release(pnhgc->nhh, pnhc);
 532         pbr_nh_delete(&pnhc);
 533         pbr_nht_uninstall_nexthop_group(pnhgc, *pbrms->nhg, nh_afi);
 534
 535         hash_release(pbr_nhg_hash, pnhgc);
 536
 537         nexthop_del(pbrms->nhg, nh);
 538         nexthop_free(nh);
 539         nexthop_group_delete(&pbrms->nhg);
 540         XFREE(MTYPE_TMP, pbrms->internal_nhg_name);
 541 }
 542
 543 struct pbr_nexthop_group_cache *pbr_nht_add_group(const char *name)
 544 {
 545         struct nexthop *nhop;
 546         struct nexthop_group_cmd *nhgc;
 547         struct pbr_nexthop_group_cache *pnhgc;
 548         struct pbr_nexthop_group_cache lookup;
 549
 550         nhgc = nhgc_find(name);
 551
 552         if (!nhgc) {
 553                 zlog_warn("%s: Could not find group %s to add",
 554                           __PRETTY_FUNCTION__, name);
 555                 return NULL;
 556         }
 557
 558         snprintf(lookup.name, sizeof(lookup.name), "%s", name);
 559         pnhgc = hash_get(pbr_nhg_hash, &lookup, pbr_nhgc_alloc);
 560         DEBUGD(&pbr_dbg_nht, "%s: Retrieved NHGC @ %p", __PRETTY_FUNCTION__,
 561                pnhgc);
 562
 563         for (ALL_NEXTHOPS(nhgc->nhg, nhop)) {
 564                 struct pbr_nexthop_cache lookup;
 565                 struct pbr_nexthop_cache *pnhc;
 566
 567                 lookup.nexthop = nhop;
 568                 pnhc = hash_lookup(pnhgc->nhh, &lookup);
 569                 if (!pnhc) {
 570                         pnhc = hash_get(pnhgc->nhh, &lookup, pbr_nh_alloc);
 571                         pnhc->parent = pnhgc;
 572                 }
 573         }
 574
 575         return pnhgc;
 576 }
 577
 578 void pbr_nht_delete_group(const char *name)
 579 {
 580         struct pbr_map_sequence *pbrms;
 581         struct listnode *snode;
 582         struct pbr_map *pbrm;
 583         struct pbr_nexthop_group_cache pnhgc_find;
 584         struct pbr_nexthop_group_cache *pnhgc;
 585
 586         RB_FOREACH (pbrm, pbr_map_entry_head, &pbr_maps) {
 587                 for (ALL_LIST_ELEMENTS_RO(pbrm->seqnumbers, snode, pbrms)) {
 588                         if (pbrms->nhgrp_name
 589                             && strmatch(pbrms->nhgrp_name, name)) {
 590                                 pbrms->reason |= PBR_MAP_INVALID_NO_NEXTHOPS;
 591                                 nexthop_group_delete(&pbrms->nhg);
 592                                 pbrms->nhg = NULL;
 593                                 pbrms->internal_nhg_name = NULL;
 594                                 pbrm->valid = false;
 595                         }
 596                 }
 597         }
 598
 599         strlcpy(pnhgc_find.name, name, sizeof(pnhgc_find.name));
 600         pnhgc = hash_release(pbr_nhg_hash, &pnhgc_find);
 601         pbr_nhgc_delete(pnhgc);
 602 }
 603
 604 bool pbr_nht_nexthop_valid(struct nexthop_group *nhg)
 605 {
 606         DEBUGD(&pbr_dbg_nht, "%s: %p", __PRETTY_FUNCTION__, nhg);
 607         return true;
 608 }
 609
 610 bool pbr_nht_nexthop_group_valid(const char *name)
 611 {
 612         struct pbr_nexthop_group_cache *pnhgc;
 613         struct pbr_nexthop_group_cache lookup;
 614
 615         DEBUGD(&pbr_dbg_nht, "%s: %s", __PRETTY_FUNCTION__, name);
 616
 617         snprintf(lookup.name, sizeof(lookup.name), "%s", name);
 618         pnhgc = hash_get(pbr_nhg_hash, &lookup, NULL);
 619         if (!pnhgc)
 620                 return false;
 621         DEBUGD(&pbr_dbg_nht, "%s: \t%d %d", __PRETTY_FUNCTION__, pnhgc->valid,
 622                pnhgc->installed);
 623         if (pnhgc->valid && pnhgc->installed)
 624                 return true;
 625
 626         return false;
 627 }
 628
 629 struct pbr_nht_individual {
 630         struct zapi_route *nhr;
 631
 632         uint32_t valid;
 633 };
 634
 635 static void pbr_nht_individual_nexthop_update_lookup(struct hash_backet *b,
 636                                                      void *data)
 637 {
 638         struct pbr_nexthop_cache *pnhc = b->data;
 639         struct pbr_nht_individual *pnhi = data;
 640         char buf[PREFIX_STRLEN];
 641         bool old_valid;
 642
 643         old_valid = pnhc->valid;
 644
 645         switch (pnhi->nhr->prefix.family) {
 646         case AF_INET:
 647                 if (pnhc->nexthop->gate.ipv4.s_addr
 648                     == pnhi->nhr->prefix.u.prefix4.s_addr)
 649                         pnhc->valid = !!pnhi->nhr->nexthop_num;
 650                 break;
 651         case AF_INET6:
 652                 if (memcmp(&pnhc->nexthop->gate.ipv6,
 653                            &pnhi->nhr->prefix.u.prefix6, 16)
 654                     == 0)
 655                         pnhc->valid = !!pnhi->nhr->nexthop_num;
 656                 break;
 657         }
 658
 659         DEBUGD(&pbr_dbg_nht, "\tFound %s: old: %d new: %d",
 660                prefix2str(&pnhi->nhr->prefix, buf, sizeof(buf)), old_valid,
 661                pnhc->valid);
 662
 663         if (pnhc->valid)
 664                 pnhi->valid += 1;
 665 }
 666
 667 static void pbr_nht_nexthop_update_lookup(struct hash_backet *b, void *data)
 668 {
 669         struct pbr_nexthop_group_cache *pnhgc = b->data;
 670         struct pbr_nht_individual pnhi;
 671         bool old_valid;
 672
 673         old_valid = pnhgc->valid;
 674
 675         pnhi.nhr = (struct zapi_route *)data;
 676         pnhi.valid = 0;
 677         hash_iterate(pnhgc->nhh, pbr_nht_individual_nexthop_update_lookup,
 678                      &pnhi);
 679
 680         /*
 681          * If any of the specified nexthops are valid we are valid
 682          */
 683         pnhgc->valid = !!pnhi.valid;
 684
 685         if (old_valid != pnhgc->valid)
 686                 pbr_map_check_nh_group_change(pnhgc->name);
 687 }
 688
 689 void pbr_nht_nexthop_update(struct zapi_route *nhr)
 690 {
 691         hash_iterate(pbr_nhg_hash, pbr_nht_nexthop_update_lookup, nhr);
 692 }
 693
 694 static uint32_t pbr_nhg_hash_key(void *arg)
 695 {
 696         struct pbr_nexthop_group_cache *nhgc =
 697                 (struct pbr_nexthop_group_cache *)arg;
 698
 699         return jhash(&nhgc->name, strlen(nhgc->name), 0x52c34a96);
 700 }
 701
 702 static int pbr_nhg_hash_equal(const void *arg1, const void *arg2)
 703 {
 704         const struct pbr_nexthop_group_cache *nhgc1 =
 705                 (const struct pbr_nexthop_group_cache *)arg1;
 706         const struct pbr_nexthop_group_cache *nhgc2 =
 707                 (const struct pbr_nexthop_group_cache *)arg2;
 708
 709         return !strcmp(nhgc1->name, nhgc2->name);
 710 }
 711
 712
 713 uint32_t pbr_nht_get_next_tableid(void)
 714 {
 715         uint32_t i;
 716         bool found = false;
 717
 718         for (i = pbr_nhg_low_table; i <= pbr_nhg_high_table; i++) {
 719                 if (nhg_tableid[i] == false) {
 720                         found = true;
 721                         break;
 722                 }
 723         }
 724
 725         if (found) {
 726                 nhg_tableid[i] = true;
 727                 return i;
 728         } else
 729                 return 0;
 730 }
 731
 732 void pbr_nht_set_tableid_range(uint32_t low, uint32_t high)
 733 {
 734         pbr_nhg_low_table = low;
 735         pbr_nhg_high_table = high;
 736 }
 737
 738 void pbr_nht_write_table_range(struct vty *vty)
 739 {
 740         if (pbr_nhg_low_table != PBR_NHT_DEFAULT_LOW_TABLEID
 741             || pbr_nhg_high_table != PBR_NHT_DEFAULT_HIGH_TABLEID) {
 742                 vty_out(vty, "pbr table range %u %u\n", pbr_nhg_low_table,
 743                         pbr_nhg_high_table);
 744         }
 745 }
 746
 747 uint32_t pbr_nht_get_next_rule(uint32_t seqno)
 748 {
 749         return seqno + pbr_nhg_low_rule - 1;
 750 }
 751 void pbr_nht_set_rule_range(uint32_t low, uint32_t high)
 752 {
 753         pbr_nhg_low_rule = low;
 754         pbr_nhg_high_rule = high;
 755 }
 756
 757 void pbr_nht_write_rule_range(struct vty *vty)
 758 {
 759         if (pbr_nhg_low_rule != PBR_NHT_DEFAULT_LOW_RULE
 760             || pbr_nhg_high_rule != PBR_NHT_DEFAULT_HIGH_RULE) {
 761                 vty_out(vty, "pbr rule range %u %u\n", pbr_nhg_low_rule,
 762                         pbr_nhg_high_rule);
 763         }
 764 }
 765
 766 uint32_t pbr_nht_get_table(const char *name)
 767 {
 768         struct pbr_nexthop_group_cache find;
 769         struct pbr_nexthop_group_cache *pnhgc;
 770
 771         memset(&find, 0, sizeof(find));
 772         snprintf(find.name, sizeof(find.name), "%s", name);
 773         pnhgc = hash_lookup(pbr_nhg_hash, &find);
 774
 775         if (!pnhgc) {
 776                 DEBUGD(&pbr_dbg_nht,
 777                        "%s: Could not find nexthop-group cache w/ name '%s'",
 778                        __PRETTY_FUNCTION__, name);
 779                 return 5000;
 780         }
 781
 782         return pnhgc->table_id;
 783 }
 784
 785 bool pbr_nht_get_installed(const char *name)
 786 {
 787         struct pbr_nexthop_group_cache find;
 788         struct pbr_nexthop_group_cache *pnhgc;
 789
 790         memset(&find, 0, sizeof(find));
 791         snprintf(find.name, sizeof(find.name), "%s", name);
 792
 793         pnhgc = hash_lookup(pbr_nhg_hash, &find);
 794
 795         if (!pnhgc)
 796                 return false;
 797
 798         return pnhgc->installed;
 799 }
 800
 801 static void pbr_nht_show_nhg_nexthops(struct hash_backet *b, void *data)
 802 {
 803         struct pbr_nexthop_cache *pnhc = b->data;
 804         struct vty *vty = data;
 805
 806         vty_out(vty, "\tValid: %d ", pnhc->valid);
 807         nexthop_group_write_nexthop(vty, pnhc->nexthop);
 808 }
 809
 810 struct pbr_nht_show {
 811         struct vty *vty;
 812         const char *name;
 813 };
 814
 815 static void pbr_nht_show_nhg(struct hash_backet *b, void *data)
 816 {
 817         struct pbr_nexthop_group_cache *pnhgc = b->data;
 818         struct pbr_nht_show *pns = data;
 819         struct vty *vty;
 820
 821         if (pns->name && strcmp(pns->name, pnhgc->name) != 0)
 822                 return;
 823
 824         vty = pns->vty;
 825         vty_out(vty, "Nexthop-Group: %s Table: %u Valid: %d Installed: %d\n",
 826                 pnhgc->name, pnhgc->table_id, pnhgc->valid, pnhgc->installed);
 827
 828         hash_iterate(pnhgc->nhh, pbr_nht_show_nhg_nexthops, vty);
 829 }
 830
 831 void pbr_nht_show_nexthop_group(struct vty *vty, const char *name)
 832 {
 833         struct pbr_nht_show pns;
 834
 835         pns.vty = vty;
 836         pns.name = name;
 837
 838         hash_iterate(pbr_nhg_hash, pbr_nht_show_nhg, &pns);
 839 }
 840
 841 void pbr_nht_init(void)
 842 {
 843         pbr_nhg_hash = hash_create_size(
 844                 16, pbr_nhg_hash_key, pbr_nhg_hash_equal, "PBR NHG Cache Hash");
 845         pbr_nhrc_hash =
 846                 hash_create_size(16, (unsigned int (*)(void *))nexthop_hash,
 847                                  pbr_nhrc_hash_equal, "PBR NH Hash");
 848
 849         pbr_nhg_low_table = PBR_NHT_DEFAULT_LOW_TABLEID;
 850         pbr_nhg_high_table = PBR_NHT_DEFAULT_HIGH_TABLEID;
 851         pbr_nhg_low_rule = PBR_NHT_DEFAULT_LOW_RULE;
 852         pbr_nhg_high_rule = PBR_NHT_DEFAULT_HIGH_RULE;
 853         memset(&nhg_tableid, 0, 65535 * sizeof(uint8_t));
 854 }