pimd/pim_nht.c

   1 /*
   2  * PIM for Quagga
   3  * Copyright (C) 2017 Cumulus Networks, Inc.
   4  * Chirag Shah
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program 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 #include "network.h"
  22 #include "zclient.h"
  23 #include "stream.h"
  24 #include "nexthop.h"
  25 #include "if.h"
  26 #include "hash.h"
  27 #include "jhash.h"
  28
  29 #include "pimd.h"
  30 #include "pimd/pim_nht.h"
  31 #include "log.h"
  32 #include "pim_time.h"
  33 #include "pim_oil.h"
  34 #include "pim_ifchannel.h"
  35 #include "pim_mroute.h"
  36 #include "pim_zebra.h"
  37 #include "pim_upstream.h"
  38 #include "pim_join.h"
  39 #include "pim_jp_agg.h"
  40 #include "pim_zebra.h"
  41 #include "pim_zlookup.h"
  42
  43 /**
  44  * pim_sendmsg_zebra_rnh -- Format and send a nexthop register/Unregister
  45  *   command to Zebra.
  46  */
  47 void pim_sendmsg_zebra_rnh(struct pim_instance *pim, struct zclient *zclient,
  48                            struct pim_nexthop_cache *pnc, int command)
  49 {
  50         struct prefix *p;
  51         int ret;
  52
  53         p = &(pnc->rpf.rpf_addr);
  54         ret = zclient_send_rnh(zclient, command, p, false, pim->vrf_id);
  55         if (ret < 0)
  56                 zlog_warn("sendmsg_nexthop: zclient_send_message() failed");
  57
  58         if (PIM_DEBUG_PIM_NHT) {
  59                 char buf[PREFIX2STR_BUFFER];
  60                 prefix2str(p, buf, sizeof(buf));
  61                 zlog_debug(
  62                         "%s: NHT %sregistered addr %s(%s) with Zebra ret:%d ",
  63                         __PRETTY_FUNCTION__,
  64                         (command == ZEBRA_NEXTHOP_REGISTER) ? " " : "de", buf,
  65                         pim->vrf->name, ret);
  66         }
  67
  68         return;
  69 }
  70
  71 struct pim_nexthop_cache *pim_nexthop_cache_find(struct pim_instance *pim,
  72                                                  struct pim_rpf *rpf)
  73 {
  74         struct pim_nexthop_cache *pnc = NULL;
  75         struct pim_nexthop_cache lookup;
  76
  77         lookup.rpf.rpf_addr.family = rpf->rpf_addr.family;
  78         lookup.rpf.rpf_addr.prefixlen = rpf->rpf_addr.prefixlen;
  79         lookup.rpf.rpf_addr.u.prefix4.s_addr = rpf->rpf_addr.u.prefix4.s_addr;
  80
  81         pnc = hash_lookup(pim->rpf_hash, &lookup);
  82
  83         return pnc;
  84 }
  85
  86 static struct pim_nexthop_cache *pim_nexthop_cache_add(struct pim_instance *pim,
  87                                                        struct pim_rpf *rpf_addr)
  88 {
  89         struct pim_nexthop_cache *pnc;
  90         char hash_name[64];
  91         char buf1[64];
  92
  93         pnc = XCALLOC(MTYPE_PIM_NEXTHOP_CACHE,
  94                       sizeof(struct pim_nexthop_cache));
  95         if (!pnc) {
  96                 zlog_err("%s: NHT PIM XCALLOC failure ", __PRETTY_FUNCTION__);
  97                 return NULL;
  98         }
  99         pnc->rpf.rpf_addr.family = rpf_addr->rpf_addr.family;
 100         pnc->rpf.rpf_addr.prefixlen = rpf_addr->rpf_addr.prefixlen;
 101         pnc->rpf.rpf_addr.u.prefix4.s_addr =
 102                 rpf_addr->rpf_addr.u.prefix4.s_addr;
 103
 104         pnc = hash_get(pim->rpf_hash, pnc, hash_alloc_intern);
 105
 106         pnc->rp_list = list_new();
 107         pnc->rp_list->cmp = pim_rp_list_cmp;
 108
 109         snprintf(hash_name, 64, "PNC %s(%s) Upstream Hash",
 110                  prefix2str(&pnc->rpf.rpf_addr, buf1, 64), pim->vrf->name);
 111         pnc->upstream_hash = hash_create_size(8192, pim_upstream_hash_key,
 112                                               pim_upstream_equal, hash_name);
 113
 114         return pnc;
 115 }
 116
 117 /*
 118  * pim_find_or_track_nexthop
 119  *
 120  * This API is used to Register an address with Zebra
 121  *
 122  * 1 -> Success
 123  * 0 -> Failure
 124  */
 125 int pim_find_or_track_nexthop(struct pim_instance *pim, struct prefix *addr,
 126                               struct pim_upstream *up, struct rp_info *rp,
 127                               struct pim_nexthop_cache *out_pnc)
 128 {
 129         struct pim_nexthop_cache *pnc = NULL;
 130         struct pim_rpf rpf;
 131         struct listnode *ch_node = NULL;
 132         struct zclient *zclient = NULL;
 133
 134         zclient = pim_zebra_zclient_get();
 135         memset(&rpf, 0, sizeof(struct pim_rpf));
 136         rpf.rpf_addr.family = addr->family;
 137         rpf.rpf_addr.prefixlen = addr->prefixlen;
 138         rpf.rpf_addr.u.prefix4 = addr->u.prefix4;
 139
 140         pnc = pim_nexthop_cache_find(pim, &rpf);
 141         if (!pnc) {
 142                 pnc = pim_nexthop_cache_add(pim, &rpf);
 143                 if (!pnc) {
 144                         char rpf_str[PREFIX_STRLEN];
 145                         pim_addr_dump("<nht-pnc?>", addr, rpf_str,
 146                                       sizeof(rpf_str));
 147                         zlog_warn("%s: pnc node allocation failed. addr %s ",
 148                                   __PRETTY_FUNCTION__, rpf_str);
 149                         return 0;
 150                 }
 151                 pim_sendmsg_zebra_rnh(pim, zclient, pnc,
 152                                       ZEBRA_NEXTHOP_REGISTER);
 153                 if (PIM_DEBUG_PIM_NHT) {
 154                         char buf[PREFIX2STR_BUFFER];
 155                         prefix2str(addr, buf, sizeof(buf));
 156                         zlog_debug(
 157                                 "%s: NHT cache and zebra notification added for %s(%s)",
 158                                 __PRETTY_FUNCTION__, buf, pim->vrf->name);
 159                 }
 160         }
 161
 162         if (rp != NULL) {
 163                 ch_node = listnode_lookup(pnc->rp_list, rp);
 164                 if (ch_node == NULL)
 165                         listnode_add_sort(pnc->rp_list, rp);
 166         }
 167
 168         if (up != NULL)
 169                 hash_get(pnc->upstream_hash, up, hash_alloc_intern);
 170
 171         if (pnc && CHECK_FLAG(pnc->flags, PIM_NEXTHOP_VALID)) {
 172                 memcpy(out_pnc, pnc, sizeof(struct pim_nexthop_cache));
 173                 return 1;
 174         }
 175
 176         return 0;
 177 }
 178
 179 void pim_delete_tracked_nexthop(struct pim_instance *pim, struct prefix *addr,
 180                                 struct pim_upstream *up, struct rp_info *rp)
 181 {
 182         struct pim_nexthop_cache *pnc = NULL;
 183         struct pim_nexthop_cache lookup;
 184         struct zclient *zclient = NULL;
 185
 186         zclient = pim_zebra_zclient_get();
 187
 188         /* Remove from RPF hash if it is the last entry */
 189         lookup.rpf.rpf_addr = *addr;
 190         pnc = hash_lookup(pim->rpf_hash, &lookup);
 191         if (pnc) {
 192                 if (rp)
 193                         listnode_delete(pnc->rp_list, rp);
 194                 if (up)
 195                         hash_release(pnc->upstream_hash, up);
 196
 197                 if (PIM_DEBUG_PIM_NHT) {
 198                         char buf[PREFIX_STRLEN];
 199                         prefix2str(addr, buf, sizeof buf);
 200                         zlog_debug(
 201                                 "%s: NHT %s(%s) rp_list count:%d upstream count:%ld",
 202                                 __PRETTY_FUNCTION__, buf, pim->vrf->name,
 203                                 pnc->rp_list->count, pnc->upstream_hash->count);
 204                 }
 205
 206                 if (pnc->rp_list->count == 0
 207                     && pnc->upstream_hash->count == 0) {
 208                         pim_sendmsg_zebra_rnh(pim, zclient, pnc,
 209                                               ZEBRA_NEXTHOP_UNREGISTER);
 210
 211                         list_delete_and_null(&pnc->rp_list);
 212                         hash_free(pnc->upstream_hash);
 213
 214                         hash_release(pim->rpf_hash, pnc);
 215                         if (pnc->nexthop)
 216                                 nexthops_free(pnc->nexthop);
 217                         XFREE(MTYPE_PIM_NEXTHOP_CACHE, pnc);
 218                 }
 219         }
 220 }
 221
 222 /* Update RP nexthop info based on Nexthop update received from Zebra.*/
 223 static void pim_update_rp_nh(struct pim_instance *pim,
 224                              struct pim_nexthop_cache *pnc)
 225 {
 226         struct listnode *node = NULL;
 227         struct rp_info *rp_info = NULL;
 228
 229         /*Traverse RP list and update each RP Nexthop info */
 230         for (ALL_LIST_ELEMENTS_RO(pnc->rp_list, node, rp_info)) {
 231                 if (rp_info->rp.rpf_addr.u.prefix4.s_addr == INADDR_NONE)
 232                         continue;
 233
 234                 // Compute PIM RPF using cached nexthop
 235                 pim_ecmp_nexthop_search(pim, pnc, &rp_info->rp.source_nexthop,
 236                                         &rp_info->rp.rpf_addr, &rp_info->group,
 237                                         1);
 238         }
 239 }
 240
 241 /* This API is used to traverse nexthop cache of RPF addr
 242    of upstream entry whose IPv4 nexthop address is in
 243    unresolved state and due to event like pim neighbor
 244    UP event if it can be resolved.
 245 */
 246 void pim_resolve_upstream_nh(struct pim_instance *pim, struct prefix *nht_p)
 247 {
 248         struct nexthop *nh_node = NULL;
 249         struct pim_nexthop_cache pnc;
 250         struct pim_neighbor *nbr = NULL;
 251
 252         memset(&pnc, 0, sizeof(struct pim_nexthop_cache));
 253         if (!pim_find_or_track_nexthop(pim, nht_p, NULL, NULL, &pnc))
 254                 return;
 255
 256         for (nh_node = pnc.nexthop; nh_node; nh_node = nh_node->next) {
 257                 if (nh_node->gate.ipv4.s_addr != 0)
 258                         continue;
 259
 260                 struct interface *ifp1 =
 261                         if_lookup_by_index(nh_node->ifindex, pim->vrf_id);
 262                 nbr = pim_neighbor_find_if(ifp1);
 263                 if (!nbr)
 264                         continue;
 265
 266                 nh_node->gate.ipv4 = nbr->source_addr;
 267                 if (PIM_DEBUG_PIM_NHT) {
 268                         char str[PREFIX_STRLEN];
 269                         char str1[INET_ADDRSTRLEN];
 270                         pim_inet4_dump("<nht_nbr?>", nbr->source_addr, str1,
 271                                        sizeof(str1));
 272                         pim_addr_dump("<nht_addr?>", nht_p, str, sizeof(str));
 273                         zlog_debug(
 274                                 "%s: addr %s new nexthop addr %s interface %s",
 275                                 __PRETTY_FUNCTION__, str, str1, ifp1->name);
 276                 }
 277         }
 278 }
 279
 280 /* Update Upstream nexthop info based on Nexthop update received from Zebra.*/
 281 static int pim_update_upstream_nh_helper(struct hash_backet *backet, void *arg)
 282 {
 283         struct pim_instance *pim = (struct pim_instance *)arg;
 284         struct pim_upstream *up = (struct pim_upstream *)backet->data;
 285         int vif_index = 0;
 286
 287         enum pim_rpf_result rpf_result;
 288         struct pim_rpf old;
 289
 290         old.source_nexthop.interface = up->rpf.source_nexthop.interface;
 291         rpf_result = pim_rpf_update(pim, up, &old, 0);
 292         if (rpf_result == PIM_RPF_FAILURE) {
 293                 pim_mroute_del(up->channel_oil, __PRETTY_FUNCTION__);
 294                 return HASHWALK_CONTINUE;
 295         }
 296
 297         /* update kernel multicast forwarding cache (MFC) */
 298         if (up->channel_oil) {
 299                 ifindex_t ifindex = up->rpf.source_nexthop.interface->ifindex;
 300
 301                 vif_index = pim_if_find_vifindex_by_ifindex(pim, ifindex);
 302                 /* Pass Current selected NH vif index to mroute download
 303                  */
 304                 if (vif_index)
 305                         pim_scan_individual_oil(up->channel_oil, vif_index);
 306                 else {
 307                         if (PIM_DEBUG_PIM_NHT)
 308                                 zlog_debug(
 309                                         "%s: NHT upstream %s channel_oil IIF %s vif_index is not valid",
 310                                         __PRETTY_FUNCTION__, up->sg_str,
 311                                         up->rpf.source_nexthop.interface->name);
 312                 }
 313         }
 314
 315         if (rpf_result == PIM_RPF_CHANGED) {
 316                 struct pim_neighbor *nbr;
 317
 318                 nbr = pim_neighbor_find(old.source_nexthop.interface,
 319                                         old.rpf_addr.u.prefix4);
 320                 if (nbr)
 321                         pim_jp_agg_remove_group(nbr->upstream_jp_agg, up);
 322
 323                 /*
 324                  * We have detected a case where we might need to rescan
 325                  * the inherited o_list so do it.
 326                  */
 327                 if (up->channel_oil && up->channel_oil->oil_inherited_rescan) {
 328                         pim_upstream_inherited_olist_decide(pim, up);
 329                         up->channel_oil->oil_inherited_rescan = 0;
 330                 }
 331
 332                 if (up->join_state == PIM_UPSTREAM_JOINED) {
 333                         /*
 334                          * If we come up real fast we can be here
 335                          * where the mroute has not been installed
 336                          * so install it.
 337                          */
 338                         if (up->channel_oil && !up->channel_oil->installed)
 339                                 pim_mroute_add(up->channel_oil,
 340                                                __PRETTY_FUNCTION__);
 341
 342                         /*
 343                          * RFC 4601: 4.5.7.  Sending (S,G) Join/Prune Messages
 344                          *
 345                          * Transitions from Joined State
 346                          *
 347                          * RPF'(S,G) changes not due to an Assert
 348                          *
 349                          * The upstream (S,G) state machine remains in Joined
 350                          * state. Send Join(S,G) to the new upstream
 351                          * neighbor, which is the new value of RPF'(S,G).
 352                          * Send Prune(S,G) to the old upstream neighbor, which
 353                          * is the old value of RPF'(S,G).  Set the Join
 354                          * Timer (JT) to expire after t_periodic seconds.
 355                          */
 356                         pim_jp_agg_switch_interface(&old, &up->rpf, up);
 357
 358                         pim_upstream_join_timer_restart(up, &old);
 359                 } /* up->join_state == PIM_UPSTREAM_JOINED */
 360
 361                 /*
 362                  * FIXME can join_desired actually be changed by
 363                  * pim_rpf_update() returning PIM_RPF_CHANGED ?
 364                  */
 365                 pim_upstream_update_join_desired(pim, up);
 366
 367         } /* PIM_RPF_CHANGED */
 368
 369         if (PIM_DEBUG_PIM_NHT) {
 370                 zlog_debug("%s: NHT upstream %s(%s) old ifp %s new ifp %s",
 371                            __PRETTY_FUNCTION__, up->sg_str, pim->vrf->name,
 372                            old.source_nexthop.interface->name,
 373                            up->rpf.source_nexthop.interface->name);
 374         }
 375
 376         return HASHWALK_CONTINUE;
 377 }
 378
 379 static int pim_update_upstream_nh(struct pim_instance *pim,
 380                                   struct pim_nexthop_cache *pnc)
 381 {
 382         struct listnode *node;
 383         struct interface *ifp;
 384
 385         hash_walk(pnc->upstream_hash, pim_update_upstream_nh_helper, pim);
 386
 387         FOR_ALL_INTERFACES (pim->vrf, ifp)
 388                 if (ifp->info) {
 389                         struct pim_interface *pim_ifp = ifp->info;
 390                         struct pim_iface_upstream_switch *us;
 391
 392                         for (ALL_LIST_ELEMENTS_RO(pim_ifp->upstream_switch_list,
 393                                                   node, us)) {
 394                                 struct pim_rpf rpf;
 395                                 rpf.source_nexthop.interface = ifp;
 396                                 rpf.rpf_addr.u.prefix4 = us->address;
 397                                 pim_joinprune_send(&rpf, us->us);
 398                                 pim_jp_agg_clear_group(us->us);
 399                         }
 400                 }
 401
 402         return 0;
 403 }
 404
 405 uint32_t pim_compute_ecmp_hash(struct prefix *src, struct prefix *grp)
 406 {
 407         uint32_t hash_val;
 408         uint32_t s = 0, g = 0;
 409
 410         if ((!src))
 411                 return 0;
 412
 413         switch (src->family) {
 414         case AF_INET: {
 415                 s = src->u.prefix4.s_addr;
 416                 s = s == 0 ? 1 : s;
 417                 if (grp)
 418                         g = grp->u.prefix4.s_addr;
 419         } break;
 420         default:
 421                 break;
 422         }
 423
 424         hash_val = jhash_2words(g, s, 101);
 425         return hash_val;
 426 }
 427
 428 int pim_ecmp_nexthop_search(struct pim_instance *pim,
 429                             struct pim_nexthop_cache *pnc,
 430                             struct pim_nexthop *nexthop, struct prefix *src,
 431                             struct prefix *grp, int neighbor_needed)
 432 {
 433         struct pim_neighbor *nbr = NULL;
 434         struct nexthop *nh_node = NULL;
 435         ifindex_t first_ifindex;
 436         struct interface *ifp = NULL;
 437         uint32_t hash_val = 0, mod_val = 0;
 438         uint8_t nh_iter = 0, found = 0;
 439
 440         if (!pnc || !pnc->nexthop_num || !nexthop)
 441                 return 0;
 442
 443         // Current Nexthop is VALID, check to stay on the current path.
 444         if (nexthop->interface && nexthop->interface->info
 445             && nexthop->mrib_nexthop_addr.u.prefix4.s_addr
 446                        != PIM_NET_INADDR_ANY) {
 447                 /* User configured knob to explicitly switch
 448                    to new path is disabled or current path
 449                    metric is less than nexthop update.
 450                  */
 451
 452                 if (qpim_ecmp_rebalance_enable == 0) {
 453                         uint8_t curr_route_valid = 0;
 454                         // Check if current nexthop is present in new updated
 455                         // Nexthop list.
 456                         // If the current nexthop is not valid, candidate to
 457                         // choose new Nexthop.
 458                         for (nh_node = pnc->nexthop; nh_node;
 459                              nh_node = nh_node->next) {
 460                                 curr_route_valid = (nexthop->interface->ifindex
 461                                                     == nh_node->ifindex);
 462                                 if (curr_route_valid)
 463                                         break;
 464                         }
 465
 466                         if (curr_route_valid
 467                             && !pim_if_connected_to_source(nexthop->interface,
 468                                                            src->u.prefix4)) {
 469                                 nbr = pim_neighbor_find(
 470                                         nexthop->interface,
 471                                         nexthop->mrib_nexthop_addr.u.prefix4);
 472                                 if (!nbr
 473                                     && !if_is_loopback(nexthop->interface)) {
 474                                         if (PIM_DEBUG_PIM_NHT)
 475                                                 zlog_debug(
 476                                                         "%s: current nexthop does not have nbr ",
 477                                                         __PRETTY_FUNCTION__);
 478                                 } else {
 479                                         if (PIM_DEBUG_PIM_NHT) {
 480                                                 char src_str[INET_ADDRSTRLEN];
 481                                                 pim_inet4_dump("<addr?>",
 482                                                                src->u.prefix4,
 483                                                                src_str,
 484                                                                sizeof(src_str));
 485                                                 char grp_str[INET_ADDRSTRLEN];
 486                                                 pim_inet4_dump("<addr?>",
 487                                                                grp->u.prefix4,
 488                                                                grp_str,
 489                                                                sizeof(grp_str));
 490                                                 zlog_debug(
 491                                                         "%s: (%s,%s)(%s) current nexthop %s is valid, skipping new path selection",
 492                                                         __PRETTY_FUNCTION__,
 493                                                         src_str, grp_str,
 494                                                         pim->vrf->name,
 495                                                         nexthop->interface->name);
 496                                         }
 497                                         return 1;
 498                                 }
 499                         }
 500                 }
 501         }
 502         if (qpim_ecmp_enable) {
 503                 // PIM ECMP flag is enable then choose ECMP path.
 504                 hash_val = pim_compute_ecmp_hash(src, grp);
 505                 mod_val = hash_val % pnc->nexthop_num;
 506         }
 507
 508         for (nh_node = pnc->nexthop; nh_node && (found == 0);
 509              nh_node = nh_node->next) {
 510                 first_ifindex = nh_node->ifindex;
 511                 ifp = if_lookup_by_index(first_ifindex, pim->vrf_id);
 512                 if (!ifp) {
 513                         if (PIM_DEBUG_PIM_NHT) {
 514                                 char addr_str[INET_ADDRSTRLEN];
 515                                 pim_inet4_dump("<addr?>", src->u.prefix4,
 516                                                addr_str, sizeof(addr_str));
 517                                 zlog_debug(
 518                                         "%s %s: could not find interface for ifindex %d (address %s(%s))",
 519                                         __FILE__, __PRETTY_FUNCTION__,
 520                                         first_ifindex, addr_str,
 521                                         pim->vrf->name);
 522                         }
 523                         if (nh_iter == mod_val)
 524                                 mod_val++; // Select nexthpath
 525                         nh_iter++;
 526                         continue;
 527                 }
 528                 if (!ifp->info) {
 529                         if (PIM_DEBUG_PIM_NHT) {
 530                                 char addr_str[INET_ADDRSTRLEN];
 531                                 pim_inet4_dump("<addr?>", src->u.prefix4,
 532                                                addr_str, sizeof(addr_str));
 533                                 zlog_debug(
 534                                         "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %s)",
 535                                         __PRETTY_FUNCTION__, ifp->name,
 536                                         pim->vrf->name, first_ifindex,
 537                                         addr_str);
 538                         }
 539                         if (nh_iter == mod_val)
 540                                 mod_val++; // Select nexthpath
 541                         nh_iter++;
 542                         continue;
 543                 }
 544
 545                 if (neighbor_needed
 546                     && !pim_if_connected_to_source(ifp, src->u.prefix4)) {
 547                         nbr = pim_neighbor_find(ifp, nh_node->gate.ipv4);
 548                         if (!nbr && !if_is_loopback(ifp)) {
 549                                 if (PIM_DEBUG_PIM_NHT)
 550                                         zlog_debug(
 551                                                 "%s: pim nbr not found on input interface %s(%s)",
 552                                                 __PRETTY_FUNCTION__, ifp->name,
 553                                                 pim->vrf->name);
 554                                 if (nh_iter == mod_val)
 555                                         mod_val++; // Select nexthpath
 556                                 nh_iter++;
 557                                 continue;
 558                         }
 559                 }
 560
 561                 if (nh_iter == mod_val) {
 562                         nexthop->interface = ifp;
 563                         nexthop->mrib_nexthop_addr.family = AF_INET;
 564                         nexthop->mrib_nexthop_addr.prefixlen = IPV4_MAX_BITLEN;
 565                         nexthop->mrib_nexthop_addr.u.prefix4 =
 566                                 nh_node->gate.ipv4;
 567                         nexthop->mrib_metric_preference = pnc->distance;
 568                         nexthop->mrib_route_metric = pnc->metric;
 569                         nexthop->last_lookup = src->u.prefix4;
 570                         nexthop->last_lookup_time = pim_time_monotonic_usec();
 571                         nexthop->nbr = nbr;
 572                         found = 1;
 573                         if (PIM_DEBUG_PIM_NHT) {
 574                                 char buf[INET_ADDRSTRLEN];
 575                                 char buf2[INET_ADDRSTRLEN];
 576                                 char buf3[INET_ADDRSTRLEN];
 577                                 pim_inet4_dump("<src?>", src->u.prefix4, buf2,
 578                                                sizeof(buf2));
 579                                 pim_inet4_dump("<grp?>", grp->u.prefix4, buf3,
 580                                                sizeof(buf3));
 581                                 pim_inet4_dump(
 582                                         "<rpf?>",
 583                                         nexthop->mrib_nexthop_addr.u.prefix4,
 584                                         buf, sizeof(buf));
 585                                 zlog_debug(
 586                                         "%s: (%s,%s)(%s) selected nhop interface %s addr %s mod_val %u iter %d ecmp %d",
 587                                         __PRETTY_FUNCTION__, buf2, buf3,
 588                                         pim->vrf->name, ifp->name, buf, mod_val,
 589                                         nh_iter, qpim_ecmp_enable);
 590                         }
 591                 }
 592                 nh_iter++;
 593         }
 594
 595         if (found)
 596                 return 1;
 597         else
 598                 return 0;
 599 }
 600
 601 /* This API is used to parse Registered address nexthop update coming from Zebra
 602  */
 603 int pim_parse_nexthop_update(int command, struct zclient *zclient,
 604                              zebra_size_t length, vrf_id_t vrf_id)
 605 {
 606         struct nexthop *nexthop;
 607         struct nexthop *nhlist_head = NULL;
 608         struct nexthop *nhlist_tail = NULL;
 609         int i;
 610         struct pim_rpf rpf;
 611         struct pim_nexthop_cache *pnc = NULL;
 612         struct pim_neighbor *nbr = NULL;
 613         struct interface *ifp = NULL;
 614         struct interface *ifp1 = NULL;
 615         struct vrf *vrf = vrf_lookup_by_id(vrf_id);
 616         struct pim_instance *pim;
 617         struct zapi_route nhr;
 618
 619         if (!vrf)
 620                 return 0;
 621         pim = vrf->info;
 622
 623         if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
 624                 if (PIM_DEBUG_PIM_NHT)
 625                         zlog_debug(
 626                                 "%s: Decode of nexthop update from zebra failed",
 627                                 __PRETTY_FUNCTION__);
 628                 return 0;
 629         }
 630
 631         if (command == ZEBRA_NEXTHOP_UPDATE) {
 632                 prefix_copy(&rpf.rpf_addr, &nhr.prefix);
 633                 pnc = pim_nexthop_cache_find(pim, &rpf);
 634                 if (!pnc) {
 635                         if (PIM_DEBUG_PIM_NHT) {
 636                                 char buf[PREFIX2STR_BUFFER];
 637                                 prefix2str(&rpf.rpf_addr, buf, sizeof(buf));
 638                                 zlog_debug(
 639                                         "%s: Skipping NHT update, addr %s is not in local cached DB.",
 640                                         __PRETTY_FUNCTION__, buf);
 641                         }
 642                         return 0;
 643                 }
 644         } else {
 645                 /*
 646                  * We do not currently handle ZEBRA_IMPORT_CHECK_UPDATE
 647                  */
 648                 return 0;
 649         }
 650
 651         pnc->last_update = pim_time_monotonic_usec();
 652
 653         if (nhr.nexthop_num) {
 654                 pnc->nexthop_num = 0; // Only increment for pim enabled rpf.
 655
 656                 for (i = 0; i < nhr.nexthop_num; i++) {
 657                         nexthop = nexthop_from_zapi_nexthop(&nhr.nexthops[i]);
 658                         switch (nexthop->type) {
 659                         case NEXTHOP_TYPE_IPV4:
 660                         case NEXTHOP_TYPE_IFINDEX:
 661                         case NEXTHOP_TYPE_IPV4_IFINDEX:
 662                         case NEXTHOP_TYPE_IPV6:
 663                         case NEXTHOP_TYPE_BLACKHOLE:
 664                                 break;
 665                         case NEXTHOP_TYPE_IPV6_IFINDEX:
 666                                 ifp1 = if_lookup_by_index(nexthop->ifindex,
 667                                                           pim->vrf_id);
 668                                 nbr = pim_neighbor_find_if(ifp1);
 669                                 /* Overwrite with Nbr address as NH addr */
 670                                 if (nbr)
 671                                         nexthop->gate.ipv4 = nbr->source_addr;
 672                                 else {
 673                                         // Mark nexthop address to 0 until PIM
 674                                         // Nbr is resolved.
 675                                         nexthop->gate.ipv4.s_addr =
 676                                                 PIM_NET_INADDR_ANY;
 677                                 }
 678
 679                                 break;
 680                         }
 681
 682                         ifp = if_lookup_by_index(nexthop->ifindex, pim->vrf_id);
 683                         if (!ifp) {
 684                                 if (PIM_DEBUG_PIM_NHT) {
 685                                         char buf[NEXTHOP_STRLEN];
 686                                         zlog_debug(
 687                                                 "%s: could not find interface for ifindex %d(%s) (addr %s)",
 688                                                 __PRETTY_FUNCTION__,
 689                                                 nexthop->ifindex,
 690                                                 pim->vrf->name,
 691                                                 nexthop2str(nexthop, buf,
 692                                                             sizeof(buf)));
 693                                 }
 694                                 nexthop_free(nexthop);
 695                                 continue;
 696                         }
 697
 698                         if (PIM_DEBUG_PIM_NHT) {
 699                                 char p_str[PREFIX2STR_BUFFER];
 700
 701                                 prefix2str(&nhr.prefix, p_str, sizeof(p_str));
 702                                 zlog_debug(
 703                                         "%s: NHT addr %s(%s) %d-nhop via %s(%s) type %d distance:%u metric:%u ",
 704                                         __PRETTY_FUNCTION__, p_str,
 705                                         pim->vrf->name, i + 1,
 706                                         inet_ntoa(nexthop->gate.ipv4),
 707                                         ifp->name, nexthop->type, nhr.distance,
 708                                         nhr.metric);
 709                         }
 710
 711                         if (!ifp->info) {
 712                                 if (PIM_DEBUG_PIM_NHT) {
 713                                         char buf[NEXTHOP_STRLEN];
 714
 715                                         zlog_debug(
 716                                                 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, addr %s)",
 717                                                 __PRETTY_FUNCTION__, ifp->name,
 718                                                 pim->vrf->name,
 719                                                 nexthop->ifindex,
 720                                                 nexthop2str(nexthop, buf,
 721                                                             sizeof(buf)));
 722                                 }
 723                                 nexthop_free(nexthop);
 724                                 continue;
 725                         }
 726
 727                         if (nhlist_tail) {
 728                                 nhlist_tail->next = nexthop;
 729                                 nhlist_tail = nexthop;
 730                         } else {
 731                                 nhlist_tail = nexthop;
 732                                 nhlist_head = nexthop;
 733                         }
 734                         // Only keep track of nexthops which are PIM enabled.
 735                         pnc->nexthop_num++;
 736                 }
 737                 /* Reset existing pnc->nexthop before assigning new list */
 738                 nexthops_free(pnc->nexthop);
 739                 pnc->nexthop = nhlist_head;
 740                 if (pnc->nexthop_num) {
 741                         pnc->flags |= PIM_NEXTHOP_VALID;
 742                         pnc->distance = nhr.distance;
 743                         pnc->metric = nhr.metric;
 744                 }
 745         } else {
 746                 pnc->flags &= ~PIM_NEXTHOP_VALID;
 747                 pnc->nexthop_num = nhr.nexthop_num;
 748                 nexthops_free(pnc->nexthop);
 749                 pnc->nexthop = NULL;
 750         }
 751
 752         if (PIM_DEBUG_PIM_NHT) {
 753                 char buf[PREFIX2STR_BUFFER];
 754                 prefix2str(&nhr.prefix, buf, sizeof(buf));
 755                 zlog_debug(
 756                         "%s: NHT Update for %s(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
 757                         __PRETTY_FUNCTION__, buf, pim->vrf->name,
 758                         nhr.nexthop_num, pnc->nexthop_num, vrf_id,
 759                         pnc->upstream_hash->count, listcount(pnc->rp_list));
 760         }
 761
 762         pim_rpf_set_refresh_time(pim);
 763
 764         if (listcount(pnc->rp_list))
 765                 pim_update_rp_nh(pim, pnc);
 766         if (pnc->upstream_hash->count)
 767                 pim_update_upstream_nh(pim, pnc);
 768
 769         return 0;
 770 }
 771
 772 int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
 773                             struct pim_nexthop *nexthop, struct in_addr addr,
 774                             struct prefix *src, struct prefix *grp,
 775                             int neighbor_needed)
 776 {
 777         struct pim_zlookup_nexthop nexthop_tab[MULTIPATH_NUM];
 778         struct pim_neighbor *nbr = NULL;
 779         int num_ifindex;
 780         struct interface *ifp;
 781         int first_ifindex;
 782         int found = 0;
 783         uint8_t i = 0;
 784         uint32_t hash_val = 0, mod_val = 0;
 785
 786         if (PIM_DEBUG_PIM_NHT) {
 787                 char addr_str[INET_ADDRSTRLEN];
 788                 pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
 789                 zlog_debug("%s: Looking up: %s(%s), last lookup time: %lld",
 790                            __PRETTY_FUNCTION__, addr_str, pim->vrf->name,
 791                            nexthop->last_lookup_time);
 792         }
 793
 794         memset(nexthop_tab, 0,
 795                sizeof(struct pim_zlookup_nexthop) * MULTIPATH_NUM);
 796         num_ifindex = zclient_lookup_nexthop(pim, nexthop_tab, MULTIPATH_NUM,
 797                                              addr, PIM_NEXTHOP_LOOKUP_MAX);
 798         if (num_ifindex < 1) {
 799                 if (PIM_DEBUG_PIM_NHT) {
 800                         char addr_str[INET_ADDRSTRLEN];
 801                         pim_inet4_dump("<addr?>", addr, addr_str,
 802                                        sizeof(addr_str));
 803                         zlog_warn(
 804                                 "%s: could not find nexthop ifindex for address %s(%s)",
 805                                 __PRETTY_FUNCTION__, addr_str, pim->vrf->name);
 806                 }
 807                 return 0;
 808         }
 809
 810         // If PIM ECMP enable then choose ECMP path.
 811         if (qpim_ecmp_enable) {
 812                 hash_val = pim_compute_ecmp_hash(src, grp);
 813                 mod_val = hash_val % num_ifindex;
 814                 if (PIM_DEBUG_PIM_NHT_DETAIL)
 815                         zlog_debug("%s: hash_val %u mod_val %u",
 816                                    __PRETTY_FUNCTION__, hash_val, mod_val);
 817         }
 818
 819         while (!found && (i < num_ifindex)) {
 820                 first_ifindex = nexthop_tab[i].ifindex;
 821
 822                 ifp = if_lookup_by_index(first_ifindex, pim->vrf_id);
 823                 if (!ifp) {
 824                         if (PIM_DEBUG_PIM_NHT) {
 825                                 char addr_str[INET_ADDRSTRLEN];
 826                                 pim_inet4_dump("<addr?>", addr, addr_str,
 827                                                sizeof(addr_str));
 828                                 zlog_debug(
 829                                         "%s %s: could not find interface for ifindex %d (address %s(%s))",
 830                                         __FILE__, __PRETTY_FUNCTION__,
 831                                         first_ifindex, addr_str,
 832                                         pim->vrf->name);
 833                         }
 834                         if (i == mod_val)
 835                                 mod_val++;
 836                         i++;
 837                         continue;
 838                 }
 839
 840                 if (!ifp->info) {
 841                         if (PIM_DEBUG_PIM_NHT) {
 842                                 char addr_str[INET_ADDRSTRLEN];
 843                                 pim_inet4_dump("<addr?>", addr, addr_str,
 844                                                sizeof(addr_str));
 845                                 zlog_debug(
 846                                         "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %s)",
 847                                         __PRETTY_FUNCTION__, ifp->name,
 848                                         pim->vrf->name, first_ifindex,
 849                                         addr_str);
 850                         }
 851                         if (i == mod_val)
 852                                 mod_val++;
 853                         i++;
 854                         continue;
 855                 }
 856                 if (neighbor_needed && !pim_if_connected_to_source(ifp, addr)) {
 857                         nbr = pim_neighbor_find(
 858                                 ifp, nexthop_tab[i].nexthop_addr.u.prefix4);
 859                         if (PIM_DEBUG_PIM_NHT_DETAIL)
 860                                 zlog_debug("ifp name: %s(%s), pim nbr: %p",
 861                                            ifp->name, pim->vrf->name, nbr);
 862                         if (!nbr && !if_is_loopback(ifp)) {
 863                                 if (i == mod_val)
 864                                         mod_val++;
 865                                 i++;
 866                                 if (PIM_DEBUG_PIM_NHT) {
 867                                         char addr_str[INET_ADDRSTRLEN];
 868                                         pim_inet4_dump("<addr?>", addr,
 869                                                        addr_str,
 870                                                        sizeof(addr_str));
 871                                         zlog_debug(
 872                                                 "%s: NBR not found on input interface %s(%s) (RPF for source %s)",
 873                                                 __PRETTY_FUNCTION__, ifp->name,
 874                                                 pim->vrf->name, addr_str);
 875                                 }
 876                                 continue;
 877                         }
 878                 }
 879
 880                 if (i == mod_val) {
 881                         if (PIM_DEBUG_PIM_NHT) {
 882                                 char nexthop_str[PREFIX_STRLEN];
 883                                 char addr_str[INET_ADDRSTRLEN];
 884                                 pim_addr_dump("<nexthop?>",
 885                                               &nexthop_tab[i].nexthop_addr,
 886                                               nexthop_str, sizeof(nexthop_str));
 887                                 pim_inet4_dump("<addr?>", addr, addr_str,
 888                                                sizeof(addr_str));
 889                                 zlog_debug(
 890                                         "%s: found nhop %s for addr %s interface %s(%s) metric %d dist %d",
 891                                         __PRETTY_FUNCTION__, nexthop_str,
 892                                         addr_str, ifp->name, pim->vrf->name,
 893                                         nexthop_tab[i].route_metric,
 894                                         nexthop_tab[i].protocol_distance);
 895                         }
 896                         /* update nexthop data */
 897                         nexthop->interface = ifp;
 898                         nexthop->mrib_nexthop_addr =
 899                                 nexthop_tab[i].nexthop_addr;
 900                         nexthop->mrib_metric_preference =
 901                                 nexthop_tab[i].protocol_distance;
 902                         nexthop->mrib_route_metric =
 903                                 nexthop_tab[i].route_metric;
 904                         nexthop->last_lookup = addr;
 905                         nexthop->last_lookup_time = pim_time_monotonic_usec();
 906                         nexthop->nbr = nbr;
 907                         found = 1;
 908                 }
 909                 i++;
 910         }
 911
 912         if (found)
 913                 return 1;
 914         else
 915                 return 0;
 916 }
 917
 918 int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance *pim,
 919                                      struct in_addr addr, struct prefix *src,
 920                                      struct prefix *grp)
 921 {
 922         struct pim_zlookup_nexthop nexthop_tab[MULTIPATH_NUM];
 923         int num_ifindex;
 924         int vif_index;
 925         ifindex_t first_ifindex;
 926         uint32_t hash_val = 0, mod_val = 0;
 927
 928         memset(nexthop_tab, 0,
 929                sizeof(struct pim_zlookup_nexthop) * MULTIPATH_NUM);
 930         num_ifindex = zclient_lookup_nexthop(pim, nexthop_tab, MULTIPATH_NUM,
 931                                              addr, PIM_NEXTHOP_LOOKUP_MAX);
 932         if (num_ifindex < 1) {
 933                 if (PIM_DEBUG_PIM_NHT) {
 934                         char addr_str[INET_ADDRSTRLEN];
 935                         pim_inet4_dump("<addr?>", addr, addr_str,
 936                                        sizeof(addr_str));
 937                         zlog_debug(
 938                                 "%s: could not find nexthop ifindex for address %s(%s)",
 939                                 __PRETTY_FUNCTION__, addr_str, pim->vrf->name);
 940                 }
 941                 return -1;
 942         }
 943
 944         // If PIM ECMP enable then choose ECMP path.
 945         if (qpim_ecmp_enable) {
 946                 hash_val = pim_compute_ecmp_hash(src, grp);
 947                 mod_val = hash_val % num_ifindex;
 948                 if (PIM_DEBUG_PIM_NHT_DETAIL)
 949                         zlog_debug("%s: hash_val %u mod_val %u",
 950                                    __PRETTY_FUNCTION__, hash_val, mod_val);
 951         }
 952
 953         first_ifindex = nexthop_tab[mod_val].ifindex;
 954
 955         if (PIM_DEBUG_PIM_NHT) {
 956                 char addr_str[INET_ADDRSTRLEN];
 957                 pim_inet4_dump("<ifaddr?>", addr, addr_str, sizeof(addr_str));
 958                 zlog_debug(
 959                         "%s: found nexthop ifindex=%d (interface %s(%s)) for address %s",
 960                         __PRETTY_FUNCTION__, first_ifindex,
 961                         ifindex2ifname(first_ifindex, pim->vrf_id),
 962                         pim->vrf->name, addr_str);
 963         }
 964
 965         vif_index = pim_if_find_vifindex_by_ifindex(pim, first_ifindex);
 966
 967         if (vif_index < 0) {
 968                 if (PIM_DEBUG_PIM_NHT) {
 969                         char addr_str[INET_ADDRSTRLEN];
 970                         pim_inet4_dump("<addr?>", addr, addr_str,
 971                                        sizeof(addr_str));
 972                         zlog_debug(
 973                                 "%s: low vif_index=%d(%s) < 1 nexthop for address %s",
 974                                 __PRETTY_FUNCTION__, vif_index, pim->vrf->name,
 975                                 addr_str);
 976                 }
 977                 return -2;
 978         }
 979
 980         return vif_index;
 981 }