zebra/zebra_rnh.c

   1 /* Zebra next hop tracking code
   2  * Copyright (C) 2013 Cumulus Networks, Inc.
   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
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "prefix.h"
  25 #include "table.h"
  26 #include "memory.h"
  27 #include "command.h"
  28 #include "if.h"
  29 #include "log.h"
  30 #include "sockunion.h"
  31 #include "linklist.h"
  32 #include "thread.h"
  33 #include "workqueue.h"
  34 #include "prefix.h"
  35 #include "routemap.h"
  36 #include "stream.h"
  37 #include "nexthop.h"
  38 #include "vrf.h"
  39
  40 #include "zebra/rib.h"
  41 #include "zebra/rt.h"
  42 #include "zebra/zserv.h"
  43 #include "zebra/zebra_ns.h"
  44 #include "zebra/zebra_vrf.h"
  45 #include "zebra/redistribute.h"
  46 #include "zebra/debug.h"
  47 #include "zebra/zebra_rnh.h"
  48 #include "zebra/zebra_routemap.h"
  49 #include "zebra/interface.h"
  50 #include "zebra/zebra_memory.h"
  51
  52 static void free_state(vrf_id_t vrf_id, struct rib *rib, struct route_node *rn);
  53 static void copy_state(struct rnh *rnh, struct rib *rib,
  54                        struct route_node *rn);
  55 #define lookup_rnh_table(v, f)                   \
  56 ({                                               \
  57   struct zebra_vrf *zvrf;                        \
  58   struct route_table *t = NULL;                  \
  59   zvrf = zebra_vrf_lookup_by_id(v);              \
  60   if (zvrf)                                      \
  61     t = zvrf->rnh_table[family2afi(f)];          \
  62   t;                                             \
  63 })
  64
  65 static int compare_state(struct rib *r1, struct rib *r2);
  66 static int send_client(struct rnh *rnh, struct zserv *client, rnh_type_t type,
  67                        vrf_id_t vrf_id);
  68 static void print_rnh(struct route_node *rn, struct vty *vty);
  69
  70 int zebra_rnh_ip_default_route = 0;
  71 int zebra_rnh_ipv6_default_route = 0;
  72
  73 static inline struct route_table *get_rnh_table(vrf_id_t vrfid, int family,
  74                                                 rnh_type_t type)
  75 {
  76   struct zebra_vrf *zvrf;
  77   struct route_table *t = NULL;
  78
  79   zvrf = zebra_vrf_lookup_by_id(vrfid);
  80   if (zvrf)
  81     switch (type)
  82       {
  83       case RNH_NEXTHOP_TYPE:
  84         t = zvrf->rnh_table[family2afi(family)];
  85         break;
  86       case RNH_IMPORT_CHECK_TYPE:
  87         t = zvrf->import_check_table[family2afi(family)];
  88         break;
  89       }
  90
  91   return t;
  92 }
  93
  94 char *rnh_str (struct rnh *rnh, char *buf, int size)
  95 {
  96   prefix2str(&(rnh->node->p), buf, size);
  97   return buf;
  98 }
  99
 100 struct rnh *
 101 zebra_add_rnh (struct prefix *p, vrf_id_t vrfid, rnh_type_t type)
 102 {
 103   struct route_table *table;
 104   struct route_node *rn;
 105   struct rnh *rnh = NULL;
 106   char buf[PREFIX2STR_BUFFER];
 107
 108   if (IS_ZEBRA_DEBUG_NHT)
 109     {
 110       prefix2str(p, buf, sizeof (buf));
 111       zlog_debug("%u: Add RNH %s type %d", vrfid, buf, type);
 112     }
 113   table = get_rnh_table(vrfid, PREFIX_FAMILY(p), type);
 114   if (!table)
 115     {
 116       prefix2str(p, buf, sizeof (buf));
 117       zlog_warn("%u: Add RNH %s type %d - table not found",
 118                 vrfid, buf, type);
 119       return NULL;
 120     }
 121
 122   /* Make it sure prefixlen is applied to the prefix. */
 123   apply_mask (p);
 124
 125   /* Lookup (or add) route node.*/
 126   rn = route_node_get (table, p);
 127
 128   if (!rn->info)
 129     {
 130       rnh = XCALLOC(MTYPE_RNH, sizeof(struct rnh));
 131       rnh->client_list = list_new();
 132       rnh->vrf_id = vrfid;
 133       rnh->zebra_static_route_list = list_new();
 134       route_lock_node (rn);
 135       rn->info = rnh;
 136       rnh->node = rn;
 137     }
 138
 139   route_unlock_node (rn);
 140   return (rn->info);
 141 }
 142
 143 struct rnh *
 144 zebra_lookup_rnh (struct prefix *p, vrf_id_t vrfid, rnh_type_t type)
 145 {
 146   struct route_table *table;
 147   struct route_node *rn;
 148
 149   table = get_rnh_table(vrfid, PREFIX_FAMILY(p), type);
 150   if (!table)
 151     return NULL;
 152
 153   /* Make it sure prefixlen is applied to the prefix. */
 154   apply_mask (p);
 155
 156   /* Lookup route node.*/
 157   rn = route_node_lookup (table, p);
 158   if (!rn)
 159     return NULL;
 160
 161   route_unlock_node (rn);
 162   return (rn->info);
 163 }
 164
 165 void
 166 zebra_free_rnh (struct rnh *rnh)
 167 {
 168   rnh->flags |= ZEBRA_NHT_DELETED;
 169   list_free (rnh->client_list);
 170   list_free (rnh->zebra_static_route_list);
 171   free_state (rnh->vrf_id, rnh->state, rnh->node);
 172   XFREE (MTYPE_RNH, rnh);
 173 }
 174
 175 void
 176 zebra_delete_rnh (struct rnh *rnh, rnh_type_t type)
 177 {
 178   struct route_node *rn;
 179
 180   if (!rnh || (rnh->flags & ZEBRA_NHT_DELETED) || !(rn = rnh->node))
 181     return;
 182
 183   if (IS_ZEBRA_DEBUG_NHT)
 184     {
 185       char buf[PREFIX2STR_BUFFER];
 186       zlog_debug("%u: Del RNH %s type %d",
 187                  rnh->vrf_id, rnh_str(rnh, buf, sizeof (buf)), type);
 188     }
 189
 190   zebra_free_rnh (rnh);
 191   rn->info = NULL;
 192   route_unlock_node (rn);
 193 }
 194
 195 void
 196 zebra_add_rnh_client (struct rnh *rnh, struct zserv *client, rnh_type_t type,
 197                       vrf_id_t vrf_id)
 198 {
 199   if (IS_ZEBRA_DEBUG_NHT)
 200     {
 201       char buf[PREFIX2STR_BUFFER];
 202       zlog_debug("%u: Client %s registers for RNH %s type %d",
 203                  vrf_id, zebra_route_string(client->proto),
 204                  rnh_str(rnh, buf, sizeof (buf)), type);
 205     }
 206   if (!listnode_lookup(rnh->client_list, client))
 207     {
 208       listnode_add(rnh->client_list, client);
 209       send_client(rnh, client, type, vrf_id); // Pending: check if its needed
 210     }
 211 }
 212
 213 void
 214 zebra_remove_rnh_client (struct rnh *rnh, struct zserv *client, rnh_type_t type)
 215 {
 216   if (IS_ZEBRA_DEBUG_NHT)
 217     {
 218       char buf[PREFIX2STR_BUFFER];
 219       zlog_debug("Client %s unregisters for RNH %s type %d",
 220                  zebra_route_string(client->proto),
 221                  rnh_str(rnh, buf, sizeof (buf)), type);
 222     }
 223   listnode_delete(rnh->client_list, client);
 224   if (list_isempty(rnh->client_list) &&
 225       list_isempty(rnh->zebra_static_route_list))
 226     zebra_delete_rnh(rnh, type);
 227 }
 228
 229 void
 230 zebra_register_rnh_static_nh(vrf_id_t vrf_id, struct prefix *nh,
 231                              struct route_node *static_rn)
 232 {
 233   struct rnh *rnh;
 234
 235   rnh = zebra_add_rnh(nh, vrf_id, RNH_NEXTHOP_TYPE);
 236   if (rnh && !listnode_lookup(rnh->zebra_static_route_list, static_rn))
 237     {
 238       listnode_add(rnh->zebra_static_route_list, static_rn);
 239     }
 240 }
 241
 242 void
 243 zebra_deregister_rnh_static_nh(vrf_id_t vrf_id, struct prefix *nh,
 244                                struct route_node *static_rn)
 245 {
 246   struct rnh *rnh;
 247
 248   rnh = zebra_lookup_rnh(nh, vrf_id, RNH_NEXTHOP_TYPE);
 249   if (!rnh || (rnh->flags & ZEBRA_NHT_DELETED))
 250     return;
 251
 252   listnode_delete(rnh->zebra_static_route_list, static_rn);
 253
 254   if (list_isempty(rnh->client_list) &&
 255       list_isempty(rnh->zebra_static_route_list))
 256     zebra_delete_rnh(rnh, RNH_NEXTHOP_TYPE);
 257 }
 258
 259 void
 260 zebra_deregister_rnh_static_nexthops (vrf_id_t vrf_id, struct nexthop *nexthop,
 261                                       struct route_node *rn)
 262 {
 263   struct nexthop *nh;
 264   struct prefix nh_p;
 265
 266   for (nh = nexthop; nh ; nh = nh->next)
 267     {
 268       switch (nh->type)
 269       {
 270         case NEXTHOP_TYPE_IPV4:
 271         case NEXTHOP_TYPE_IPV4_IFINDEX:
 272           nh_p.family = AF_INET;
 273           nh_p.prefixlen = IPV4_MAX_BITLEN;
 274           nh_p.u.prefix4 = nh->gate.ipv4;
 275           break;
 276         case NEXTHOP_TYPE_IPV6:
 277         case NEXTHOP_TYPE_IPV6_IFINDEX:
 278           nh_p.family = AF_INET6;
 279           nh_p.prefixlen = IPV6_MAX_BITLEN;
 280           nh_p.u.prefix6 = nh->gate.ipv6;
 281           break;
 282         /*
 283          * Not sure what really to do here, we are not
 284          * supposed to have either of these for NHT
 285          * and the code has no way to know what prefix
 286          * to use.  So I'm going to just continue
 287          * for the moment, which is preferable to
 288          * what is currently happening which is a
 289          * CRASH and BURN.
 290          * Some simple testing shows that we
 291          * are not leaving slag around for these
 292          * skipped static routes.  Since
 293          * they don't appear to be installed
 294          */
 295         case NEXTHOP_TYPE_IFINDEX:
 296         case NEXTHOP_TYPE_BLACKHOLE:
 297           continue;
 298           break;
 299       }
 300       zebra_deregister_rnh_static_nh(vrf_id, &nh_p, rn);
 301     }
 302 }
 303
 304 /* Apply the NHT route-map for a client to the route (and nexthops)
 305  * resolving a NH.
 306  */
 307 static int
 308 zebra_rnh_apply_nht_rmap(int family, struct route_node *prn,
 309                          struct rib *rib, int proto)
 310 {
 311   int at_least_one = 0;
 312   int rmap_family;             /* Route map has diff AF family enum */
 313   struct nexthop *nexthop;
 314   int ret;
 315
 316   rmap_family = (family == AF_INET) ? AFI_IP : AFI_IP6;
 317
 318   if (prn && rib)
 319     {
 320       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 321         {
 322           ret = zebra_nht_route_map_check(rmap_family, proto, &prn->p, rib,
 323                                           nexthop);
 324           if (ret != RMAP_DENYMATCH)
 325             {
 326               SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 327               at_least_one++; /* at least one valid NH */
 328             }
 329           else
 330             {
 331               UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 332             }
 333         }
 334     }
 335   return (at_least_one);
 336 }
 337
 338 /*
 339  * Determine appropriate route (RIB entry) resolving a tracked entry
 340  * (nexthop or BGP route for import).
 341  */
 342 static struct rib *
 343 zebra_rnh_resolve_entry (vrf_id_t vrfid, int family, rnh_type_t type,
 344                          struct route_node *nrn, struct rnh *rnh,
 345                          struct route_node **prn)
 346 {
 347   struct route_table *route_table;
 348   struct route_node *rn;
 349   struct rib *rib;
 350
 351   *prn = NULL;
 352
 353   route_table = zebra_vrf_table(family2afi(family), SAFI_UNICAST, vrfid);
 354   if (!route_table) // unexpected
 355     return NULL;
 356
 357   rn = route_node_match(route_table, &nrn->p);
 358   if (!rn)
 359     return NULL;
 360
 361   /* When resolving nexthops, do not resolve via the default route unless
 362    * 'ip nht resolve-via-default' is configured.
 363    */
 364   if ((type == RNH_NEXTHOP_TYPE) &&
 365       (is_default_prefix (&rn->p) &&
 366       !nh_resolve_via_default(rn->p.family)))
 367     rib = NULL;
 368  else if ((type == RNH_IMPORT_CHECK_TYPE) &&
 369           CHECK_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH) &&
 370           !prefix_same(&nrn->p, &rn->p))
 371    rib = NULL;
 372   else
 373     {
 374       /* Identify appropriate route entry. */
 375       RNODE_FOREACH_RIB(rn, rib)
 376         {
 377           if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
 378             continue;
 379           if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
 380             {
 381               if (CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED))
 382                 {
 383                   if (rib->type == ZEBRA_ROUTE_CONNECT)
 384                     break;
 385                 }
 386               else if ((type == RNH_IMPORT_CHECK_TYPE) &&
 387                        (rib->type == ZEBRA_ROUTE_BGP))
 388                 continue;
 389               else
 390                 break;
 391             }
 392         }
 393     }
 394
 395   /* Need to unlock route node */
 396   route_unlock_node(rn);
 397   if (rib)
 398     *prn = rn;
 399   return rib;
 400 }
 401
 402 /*
 403  * See if a tracked route entry for import (by BGP) has undergone any
 404  * change, and if so, notify the client.
 405  */
 406 static void
 407 zebra_rnh_eval_import_check_entry (vrf_id_t vrfid, int family, int force,
 408                                    struct route_node *nrn, struct rnh *rnh,
 409                                    struct rib *rib)
 410 {
 411   int state_changed = 0;
 412   struct zserv *client;
 413   char bufn[INET6_ADDRSTRLEN];
 414   struct listnode *node;
 415   struct nexthop *nexthop, *tnexthop;
 416   int recursing;
 417
 418   if (rib && (rnh->state == NULL))
 419     {
 420       for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
 421         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 422           {
 423             state_changed = 1;
 424             break;
 425           }
 426     }
 427   else if (!rib && (rnh->state != NULL))
 428     state_changed = 1;
 429
 430   if (compare_state(rib, rnh->state))
 431     copy_state(rnh, rib, nrn);
 432
 433   if (state_changed || force)
 434     {
 435       if (IS_ZEBRA_DEBUG_NHT)
 436         {
 437           prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 438           zlog_debug("%u:%s: Route import check %s %s\n",
 439                      vrfid, bufn, rnh->state ? "passed" : "failed",
 440                      state_changed ? "(state changed)" : "");
 441         }
 442       /* state changed, notify clients */
 443       for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
 444         {
 445           send_client(rnh, client, RNH_IMPORT_CHECK_TYPE, vrfid);
 446         }
 447     }
 448 }
 449
 450 /*
 451  * Notify clients registered for this nexthop about a change.
 452  */
 453 static void
 454 zebra_rnh_notify_protocol_clients (vrf_id_t vrfid, int family,
 455                                    struct route_node *nrn, struct rnh *rnh,
 456                                    struct route_node *prn, struct rib *rib)
 457 {
 458   struct listnode *node;
 459   struct zserv *client;
 460   char bufn[INET6_ADDRSTRLEN];
 461   char bufp[INET6_ADDRSTRLEN];
 462   int num_resolving_nh;
 463
 464   if (IS_ZEBRA_DEBUG_NHT)
 465     {
 466       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 467       if (prn && rib)
 468         {
 469           prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
 470           zlog_debug("%u:%s: NH resolved over route %s", vrfid, bufn, bufp);
 471         }
 472       else
 473         zlog_debug("%u:%s: NH has become unresolved", vrfid, bufn);
 474     }
 475
 476   for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
 477     {
 478       if (prn && rib)
 479         {
 480           /* Apply route-map for this client to route resolving this
 481            * nexthop to see if it is filtered or not.
 482            */
 483           num_resolving_nh = zebra_rnh_apply_nht_rmap(family, prn, rib,
 484                                                       client->proto);
 485           if (num_resolving_nh)
 486             rnh->filtered[client->proto] = 0;
 487           else
 488             rnh->filtered[client->proto] = 1;
 489
 490           if (IS_ZEBRA_DEBUG_NHT)
 491             zlog_debug("%u:%s: Notifying client %s about NH %s",
 492                        vrfid, bufn, zebra_route_string(client->proto),
 493                        num_resolving_nh ? "" : "(filtered by route-map)");
 494         }
 495       else
 496         {
 497           rnh->filtered[client->proto] = 0;
 498           if (IS_ZEBRA_DEBUG_NHT)
 499             zlog_debug("%u:%s: Notifying client %s about NH (unreachable)",
 500                        vrfid, bufn, zebra_route_string(client->proto));
 501         }
 502
 503       send_client(rnh, client, RNH_NEXTHOP_TYPE, vrfid);
 504     }
 505 }
 506
 507 static void
 508 zebra_rnh_process_static_routes (vrf_id_t vrfid, int family,
 509                                  struct route_node *nrn, struct rnh *rnh,
 510                                  struct route_node *prn, struct rib *rib)
 511 {
 512   struct listnode *node;
 513   int num_resolving_nh = 0;
 514   struct route_node *static_rn;
 515   struct rib *srib;
 516   struct nexthop *nexthop;
 517   char bufn[INET6_ADDRSTRLEN];
 518   char bufp[INET6_ADDRSTRLEN];
 519   char bufs[INET6_ADDRSTRLEN];
 520
 521   if (IS_ZEBRA_DEBUG_NHT)
 522     {
 523       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 524       if (prn)
 525         prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
 526     }
 527
 528   if (prn && rib)
 529     {
 530       /* Apply route-map for "static" to route resolving this
 531        * nexthop to see if it is filtered or not.
 532        */
 533       num_resolving_nh = zebra_rnh_apply_nht_rmap(family, prn, rib,
 534                                                   ZEBRA_ROUTE_STATIC);
 535       if (num_resolving_nh)
 536         rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
 537       else
 538         rnh->filtered[ZEBRA_ROUTE_STATIC] = 1;
 539     }
 540   else
 541     rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
 542
 543   /* Evaluate each static route associated with this nexthop. */
 544   for (ALL_LIST_ELEMENTS_RO(rnh->zebra_static_route_list, node,
 545                             static_rn))
 546     {
 547       RNODE_FOREACH_RIB(static_rn, srib)
 548         {
 549           if (srib->type == ZEBRA_ROUTE_STATIC)
 550             continue;
 551
 552           /* Set the filter flag for the correct nexthop - static route may
 553            * be having multiple. We care here only about registered nexthops.
 554            */
 555           for (nexthop = srib->nexthop; nexthop; nexthop = nexthop->next)
 556             {
 557               switch (nexthop->type)
 558                 {
 559                 case NEXTHOP_TYPE_IPV4:
 560                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 561                   if (nexthop->gate.ipv4.s_addr == nrn->p.u.prefix4.s_addr)
 562                     {
 563                       if (num_resolving_nh)
 564                         UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 565                       else
 566                         SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 567                     }
 568                   break;
 569                 case NEXTHOP_TYPE_IPV6:
 570                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 571
 572               if (memcmp(&nexthop->gate.ipv6,&nrn->p.u.prefix6, 16) == 0)
 573                 {
 574                   if (num_resolving_nh)
 575                     UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 576                   else
 577                     SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 578                 }
 579               break;
 580             default:
 581               break;
 582             }
 583         }
 584
 585           if (IS_ZEBRA_DEBUG_NHT)
 586             {
 587               prefix2str(&static_rn->p, bufs, INET6_ADDRSTRLEN);
 588               if (prn && rib)
 589                 zlog_debug("%u:%s: NH change %s, scheduling static route %s",
 590                            vrfid, bufn, num_resolving_nh ?
 591                            "" : "(filtered by route-map)", bufs);
 592               else
 593                 zlog_debug("%u:%s: NH unreachable, scheduling static route %s",
 594                            vrfid, bufn, bufs);
 595             }
 596
 597           SET_FLAG(srib->status, RIB_ENTRY_CHANGED);
 598           SET_FLAG(srib->status, RIB_ENTRY_NEXTHOPS_CHANGED);
 599         }
 600
 601       rib_queue_add(static_rn);
 602     }
 603 }
 604
 605 /*
 606  * See if a tracked nexthop entry has undergone any change, and if so,
 607  * take appropriate action; this involves notifying any clients and/or
 608  * scheduling dependent static routes for processing.
 609  */
 610 static void
 611 zebra_rnh_eval_nexthop_entry (vrf_id_t vrfid, int family, int force,
 612                               struct route_node *nrn, struct rnh *rnh,
 613                               struct route_node *prn, struct rib *rib)
 614 {
 615   int state_changed = 0;
 616
 617   /* If we're resolving over a different route, resolution has changed or
 618    * the resolving route has some change (e.g., metric), there is a state
 619    * change.
 620    */
 621   if (!prefix_same(&rnh->resolved_route, &prn->p))
 622     {
 623       if (rib)
 624         UNSET_FLAG(rib->status, RIB_ENTRY_NEXTHOPS_CHANGED);
 625
 626       if (prn)
 627         prefix_copy(&rnh->resolved_route, &prn->p);
 628       else
 629         memset(&rnh->resolved_route, 0, sizeof(struct prefix));
 630
 631       copy_state(rnh, rib, nrn);
 632       state_changed = 1;
 633     }
 634   else if (compare_state(rib, rnh->state))
 635     {
 636       if (rib)
 637         UNSET_FLAG(rib->status, RIB_ENTRY_NEXTHOPS_CHANGED);
 638
 639       copy_state(rnh, rib, nrn);
 640       state_changed = 1;
 641     }
 642
 643   if (state_changed || force)
 644     {
 645       /* NOTE: Use the "copy" of resolving route stored in 'rnh' i.e.,
 646        * rnh->state.
 647        */
 648       /* Notify registered protocol clients. */
 649       zebra_rnh_notify_protocol_clients (vrfid, family, nrn, rnh,
 650                                          prn, rnh->state);
 651
 652       /* Process static routes attached to this nexthop */
 653       zebra_rnh_process_static_routes (vrfid, family, nrn, rnh,
 654                                        prn, rnh->state);
 655     }
 656 }
 657
 658 /* Evaluate one tracked entry */
 659 static void
 660 zebra_rnh_evaluate_entry (vrf_id_t vrfid, int family, int force, rnh_type_t type,
 661                           struct route_node *nrn)
 662 {
 663   struct rnh *rnh;
 664   struct rib *rib;
 665   struct route_node *prn;
 666   char bufn[INET6_ADDRSTRLEN];
 667
 668   if (IS_ZEBRA_DEBUG_NHT)
 669     {
 670       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 671       zlog_debug("%u:%s: Evaluate RNH, type %d %s",
 672                  vrfid, bufn, type, force ? "(force)" : "");
 673     }
 674
 675   rnh = nrn->info;
 676
 677   /* Identify route entry (RIB) resolving this tracked entry. */
 678   rib = zebra_rnh_resolve_entry (vrfid, family, type, nrn, rnh, &prn);
 679
 680   /* If the entry cannot be resolved and that is also the existing state,
 681    * there is nothing further to do.
 682    */
 683   if (!rib && rnh->state == NULL && !force)
 684     return;
 685
 686   /* Process based on type of entry. */
 687   if (type == RNH_IMPORT_CHECK_TYPE)
 688     zebra_rnh_eval_import_check_entry (vrfid, family, force,
 689                                        nrn, rnh, rib);
 690   else
 691     zebra_rnh_eval_nexthop_entry (vrfid, family, force,
 692                                   nrn, rnh, prn, rib);
 693 }
 694
 695
 696 /* Evaluate all tracked entries (nexthops or routes for import into BGP)
 697  * of a particular VRF and address-family or a specific prefix.
 698  */
 699 void
 700 zebra_evaluate_rnh (vrf_id_t vrfid, int family, int force, rnh_type_t type,
 701                     struct prefix *p)
 702 {
 703   struct route_table *rnh_table;
 704   struct route_node *nrn;
 705
 706   rnh_table = get_rnh_table(vrfid, family, type);
 707   if (!rnh_table) // unexpected
 708     return;
 709
 710   if (p)
 711     {
 712       /* Evaluating a specific entry, make sure it exists. */
 713       nrn = route_node_lookup (rnh_table, p);
 714       if (nrn && nrn->info)
 715         zebra_rnh_evaluate_entry (vrfid, family, force, type, nrn);
 716       if (nrn)
 717         route_unlock_node (nrn);
 718     }
 719   else
 720     {
 721       /* Evaluate entire table. */
 722       nrn = route_top (rnh_table);
 723       while (nrn)
 724         {
 725           if (nrn->info)
 726             zebra_rnh_evaluate_entry (vrfid, family, force, type, nrn);
 727           nrn = route_next(nrn); /* this will also unlock nrn */
 728         }
 729     }
 730 }
 731
 732 void
 733 zebra_print_rnh_table (vrf_id_t vrfid, int af, struct vty *vty, rnh_type_t type)
 734 {
 735   struct route_table *table;
 736   struct route_node *rn;
 737
 738   table = get_rnh_table(vrfid, af, type);
 739   if (!table)
 740     {
 741       zlog_debug("print_rnhs: rnh table not found\n");
 742       return;
 743     }
 744
 745   for (rn = route_top(table); rn; rn = route_next(rn))
 746       if (rn->info)
 747         print_rnh(rn, vty);
 748 }
 749
 750 int
 751 zebra_cleanup_rnh_client (vrf_id_t vrf_id, int family, struct zserv *client,
 752                           rnh_type_t type)
 753 {
 754   struct route_table *ntable;
 755   struct route_node *nrn;
 756   struct rnh *rnh;
 757
 758   if (IS_ZEBRA_DEBUG_NHT)
 759     zlog_debug("%u: Client %s RNH cleanup for family %d type %d",
 760                vrf_id, zebra_route_string(client->proto), family, type);
 761
 762   ntable = get_rnh_table(vrf_id, family, type);
 763   if (!ntable)
 764     {
 765       zlog_debug("cleanup_rnh_client: rnh table not found\n");
 766       return -1;
 767     }
 768
 769   for (nrn = route_top (ntable); nrn; nrn = route_next (nrn))
 770     {
 771       if (!nrn->info)
 772           continue;
 773
 774       rnh = nrn->info;
 775       zebra_remove_rnh_client(rnh, client, type);
 776     }
 777   return 1;
 778 }
 779
 780 /**
 781  * free_state - free up the rib structure associated with the rnh.
 782  */
 783 static void
 784 free_state (vrf_id_t vrf_id, struct rib *rib, struct route_node *rn)
 785 {
 786
 787   if (!rib)
 788     return;
 789
 790   /* free RIB and nexthops */
 791   zebra_deregister_rnh_static_nexthops (vrf_id, rib->nexthop, rn);
 792   nexthops_free(rib->nexthop);
 793   XFREE (MTYPE_RIB, rib);
 794 }
 795
 796 static void
 797 copy_state (struct rnh *rnh, struct rib *rib, struct route_node *rn)
 798 {
 799   struct rib *state;
 800   struct nexthop *nh;
 801
 802   if (rnh->state)
 803     {
 804       free_state(rnh->vrf_id, rnh->state, rn);
 805       rnh->state = NULL;
 806     }
 807
 808   if (!rib)
 809     return;
 810
 811   state = XCALLOC (MTYPE_RIB, sizeof (struct rib));
 812   state->type = rib->type;
 813   state->metric = rib->metric;
 814
 815   for (nh = rib->nexthop; nh; nh = nh->next)
 816     rib_copy_nexthops(state, nh);
 817   rnh->state = state;
 818 }
 819
 820 static int
 821 compare_state (struct rib *r1, struct rib *r2)
 822 {
 823
 824   if (!r1 && !r2)
 825     return 0;
 826
 827   if ((!r1 && r2) || (r1 && !r2))
 828       return 1;
 829
 830   if (r1->metric != r2->metric)
 831       return 1;
 832
 833   if (r1->nexthop_num != r2->nexthop_num)
 834       return 1;
 835
 836   if (CHECK_FLAG(r1->status, RIB_ENTRY_NEXTHOPS_CHANGED))
 837     return 1;
 838
 839   return 0;
 840 }
 841
 842 static int
 843 send_client (struct rnh *rnh, struct zserv *client, rnh_type_t type, vrf_id_t vrf_id)
 844 {
 845   struct stream *s;
 846   struct rib *rib;
 847   unsigned long nump;
 848   u_char num;
 849   struct nexthop *nexthop;
 850   struct route_node *rn;
 851   int cmd = (type == RNH_IMPORT_CHECK_TYPE)
 852     ? ZEBRA_IMPORT_CHECK_UPDATE : ZEBRA_NEXTHOP_UPDATE;
 853
 854   rn = rnh->node;
 855   rib = rnh->state;
 856
 857   /* Get output stream. */
 858   s = client->obuf;
 859   stream_reset (s);
 860
 861   zserv_create_header (s, cmd, vrf_id);
 862
 863   stream_putw(s, rn->p.family);
 864   switch (rn->p.family)
 865     {
 866     case AF_INET:
 867       stream_putc(s, rn->p.prefixlen);
 868       stream_put_in_addr(s, &rn->p.u.prefix4);
 869       break;
 870     case AF_INET6:
 871       stream_putc(s, rn->p.prefixlen);
 872       stream_put(s, &rn->p.u.prefix6, IPV6_MAX_BYTELEN);
 873       break;
 874     default:
 875       zlog_err("%s: Unknown family (%d) notification attempted\n",
 876                __FUNCTION__, rn->p.family);
 877       break;
 878     }
 879   if (rib)
 880     {
 881       stream_putc (s, rib->distance);
 882       stream_putl (s, rib->metric);
 883       num = 0;
 884       nump = stream_get_endp(s);
 885       stream_putc (s, 0);
 886       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 887         if ((CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB) ||
 888              CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE)) &&
 889             CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 890           {
 891             stream_putc (s, nexthop->type);
 892             switch (nexthop->type)
 893               {
 894               case NEXTHOP_TYPE_IPV4:
 895                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 896                 break;
 897               case NEXTHOP_TYPE_IFINDEX:
 898                 stream_putl (s, nexthop->ifindex);
 899                 break;
 900               case NEXTHOP_TYPE_IPV4_IFINDEX:
 901                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 902                 stream_putl (s, nexthop->ifindex);
 903                 break;
 904               case NEXTHOP_TYPE_IPV6:
 905                 stream_put (s, &nexthop->gate.ipv6, 16);
 906                 break;
 907               case NEXTHOP_TYPE_IPV6_IFINDEX:
 908                 stream_put (s, &nexthop->gate.ipv6, 16);
 909                 stream_putl (s, nexthop->ifindex);
 910                 break;
 911               default:
 912                 /* do nothing */
 913                 break;
 914               }
 915             num++;
 916           }
 917       stream_putc_at (s, nump, num);
 918     }
 919   else
 920     {
 921       stream_putc (s, 0);  // distance
 922       stream_putl (s, 0);  // metric
 923       stream_putc (s, 0);  // nexthops
 924     }
 925   stream_putw_at (s, 0, stream_get_endp (s));
 926
 927   client->nh_last_upd_time = monotime(NULL);
 928   client->last_write_cmd = cmd;
 929   return zebra_server_send_message(client);
 930 }
 931
 932 static void
 933 print_nh (struct nexthop *nexthop, struct vty *vty)
 934 {
 935   char buf[BUFSIZ];
 936   struct zebra_ns *zns = zebra_ns_lookup (NS_DEFAULT);
 937
 938   switch (nexthop->type)
 939     {
 940     case NEXTHOP_TYPE_IPV4:
 941     case NEXTHOP_TYPE_IPV4_IFINDEX:
 942       vty_out (vty, " via %s", inet_ntoa (nexthop->gate.ipv4));
 943       if (nexthop->ifindex)
 944         vty_out (vty, ", %s", ifindex2ifname_per_ns (zns, nexthop->ifindex));
 945       break;
 946     case NEXTHOP_TYPE_IPV6:
 947     case NEXTHOP_TYPE_IPV6_IFINDEX:
 948       vty_out (vty, " %s",
 949                inet_ntop (AF_INET6, &nexthop->gate.ipv6, buf, BUFSIZ));
 950       if (nexthop->ifindex)
 951         vty_out (vty, ", via %s", ifindex2ifname_per_ns (zns, nexthop->ifindex));
 952       break;
 953     case NEXTHOP_TYPE_IFINDEX:
 954       vty_out (vty, " is directly connected, %s",
 955                ifindex2ifname_per_ns (zns, nexthop->ifindex));
 956       break;
 957     case NEXTHOP_TYPE_BLACKHOLE:
 958       vty_out (vty, " is directly connected, Null0");
 959       break;
 960     default:
 961       break;
 962     }
 963   vty_out(vty, "%s", VTY_NEWLINE);
 964 }
 965
 966 static void
 967 print_rnh (struct route_node *rn, struct vty *vty)
 968 {
 969   struct rnh *rnh;
 970   struct nexthop *nexthop;
 971   struct listnode *node;
 972   struct zserv *client;
 973   char buf[BUFSIZ];
 974
 975   rnh = rn->info;
 976   vty_out(vty, "%s%s%s", inet_ntop(rn->p.family, &rn->p.u.prefix, buf, BUFSIZ),
 977           CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED) ? "(Connected)" : "",
 978           VTY_NEWLINE);
 979   if (rnh->state)
 980     {
 981       vty_out(vty, " resolved via %s%s",
 982               zebra_route_string(rnh->state->type), VTY_NEWLINE);
 983       for (nexthop = rnh->state->nexthop; nexthop; nexthop = nexthop->next)
 984         print_nh(nexthop, vty);
 985     }
 986   else
 987     vty_out(vty, " unresolved%s%s",
 988             CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED) ? "(Connected)" : "",
 989             VTY_NEWLINE);
 990
 991   vty_out(vty, " Client list:");
 992   for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
 993     vty_out(vty, " %s(fd %d)%s", zebra_route_string(client->proto),
 994             client->sock, rnh->filtered[client->proto] ? "(filtered)" : "");
 995   if (!list_isempty(rnh->zebra_static_route_list))
 996     vty_out(vty, " zebra%s", rnh->filtered[ZEBRA_ROUTE_STATIC] ? "(filtered)" : "");
 997   vty_out(vty, "%s", VTY_NEWLINE);
 998 }