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->status, RIB_ENTRY_SELECTED_FIB))
 380             continue;
 381
 382           if (CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED))
 383             {
 384               if (rib->type == ZEBRA_ROUTE_CONNECT)
 385                 break;
 386               if (rib->type == ZEBRA_ROUTE_NHRP)
 387                 {
 388                   struct nexthop *nexthop;
 389                   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 390                     if (nexthop->type == NEXTHOP_TYPE_IFINDEX)
 391                       break;
 392                   if (nexthop)
 393                     break;
 394                 }
 395             }
 396           else if ((type == RNH_IMPORT_CHECK_TYPE) &&
 397                    (rib->type == ZEBRA_ROUTE_BGP))
 398             continue;
 399           else
 400             break;
 401         }
 402     }
 403
 404   /* Need to unlock route node */
 405   route_unlock_node(rn);
 406   if (rib)
 407     *prn = rn;
 408   return rib;
 409 }
 410
 411 /*
 412  * See if a tracked route entry for import (by BGP) has undergone any
 413  * change, and if so, notify the client.
 414  */
 415 static void
 416 zebra_rnh_eval_import_check_entry (vrf_id_t vrfid, int family, int force,
 417                                    struct route_node *nrn, struct rnh *rnh,
 418                                    struct rib *rib)
 419 {
 420   int state_changed = 0;
 421   struct zserv *client;
 422   char bufn[INET6_ADDRSTRLEN];
 423   struct listnode *node;
 424   struct nexthop *nexthop, *tnexthop;
 425   int recursing;
 426
 427   if (rib && (rnh->state == NULL))
 428     {
 429       for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
 430         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 431           {
 432             state_changed = 1;
 433             break;
 434           }
 435     }
 436   else if (!rib && (rnh->state != NULL))
 437     state_changed = 1;
 438
 439   if (compare_state(rib, rnh->state))
 440     copy_state(rnh, rib, nrn);
 441
 442   if (state_changed || force)
 443     {
 444       if (IS_ZEBRA_DEBUG_NHT)
 445         {
 446           prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 447           zlog_debug("%u:%s: Route import check %s %s\n",
 448                      vrfid, bufn, rnh->state ? "passed" : "failed",
 449                      state_changed ? "(state changed)" : "");
 450         }
 451       /* state changed, notify clients */
 452       for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
 453         {
 454           send_client(rnh, client, RNH_IMPORT_CHECK_TYPE, vrfid);
 455         }
 456     }
 457 }
 458
 459 /*
 460  * Notify clients registered for this nexthop about a change.
 461  */
 462 static void
 463 zebra_rnh_notify_protocol_clients (vrf_id_t vrfid, int family,
 464                                    struct route_node *nrn, struct rnh *rnh,
 465                                    struct route_node *prn, struct rib *rib)
 466 {
 467   struct listnode *node;
 468   struct zserv *client;
 469   char bufn[INET6_ADDRSTRLEN];
 470   char bufp[INET6_ADDRSTRLEN];
 471   int num_resolving_nh;
 472
 473   if (IS_ZEBRA_DEBUG_NHT)
 474     {
 475       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 476       if (prn && rib)
 477         {
 478           prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
 479           zlog_debug("%u:%s: NH resolved over route %s", vrfid, bufn, bufp);
 480         }
 481       else
 482         zlog_debug("%u:%s: NH has become unresolved", vrfid, bufn);
 483     }
 484
 485   for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
 486     {
 487       if (prn && rib)
 488         {
 489           /* Apply route-map for this client to route resolving this
 490            * nexthop to see if it is filtered or not.
 491            */
 492           num_resolving_nh = zebra_rnh_apply_nht_rmap(family, prn, rib,
 493                                                       client->proto);
 494           if (num_resolving_nh)
 495             rnh->filtered[client->proto] = 0;
 496           else
 497             rnh->filtered[client->proto] = 1;
 498
 499           if (IS_ZEBRA_DEBUG_NHT)
 500             zlog_debug("%u:%s: Notifying client %s about NH %s",
 501                        vrfid, bufn, zebra_route_string(client->proto),
 502                        num_resolving_nh ? "" : "(filtered by route-map)");
 503         }
 504       else
 505         {
 506           rnh->filtered[client->proto] = 0;
 507           if (IS_ZEBRA_DEBUG_NHT)
 508             zlog_debug("%u:%s: Notifying client %s about NH (unreachable)",
 509                        vrfid, bufn, zebra_route_string(client->proto));
 510         }
 511
 512       send_client(rnh, client, RNH_NEXTHOP_TYPE, vrfid);
 513     }
 514 }
 515
 516 static void
 517 zebra_rnh_process_static_routes (vrf_id_t vrfid, int family,
 518                                  struct route_node *nrn, struct rnh *rnh,
 519                                  struct route_node *prn, struct rib *rib)
 520 {
 521   struct listnode *node;
 522   int num_resolving_nh = 0;
 523   struct route_node *static_rn;
 524   struct rib *srib;
 525   struct nexthop *nexthop;
 526   char bufn[INET6_ADDRSTRLEN];
 527   char bufp[INET6_ADDRSTRLEN];
 528   char bufs[INET6_ADDRSTRLEN];
 529
 530   if (IS_ZEBRA_DEBUG_NHT)
 531     {
 532       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 533       if (prn)
 534         prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
 535     }
 536
 537   if (prn && rib)
 538     {
 539       /* Apply route-map for "static" to route resolving this
 540        * nexthop to see if it is filtered or not.
 541        */
 542       num_resolving_nh = zebra_rnh_apply_nht_rmap(family, prn, rib,
 543                                                   ZEBRA_ROUTE_STATIC);
 544       if (num_resolving_nh)
 545         rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
 546       else
 547         rnh->filtered[ZEBRA_ROUTE_STATIC] = 1;
 548     }
 549   else
 550     rnh->filtered[ZEBRA_ROUTE_STATIC] = 0;
 551
 552   /* Evaluate each static route associated with this nexthop. */
 553   for (ALL_LIST_ELEMENTS_RO(rnh->zebra_static_route_list, node,
 554                             static_rn))
 555     {
 556       RNODE_FOREACH_RIB(static_rn, srib)
 557         {
 558           if (srib->type != ZEBRA_ROUTE_STATIC)
 559             continue;
 560
 561           /* Set the filter flag for the correct nexthop - static route may
 562            * be having multiple. We care here only about registered nexthops.
 563            */
 564           for (nexthop = srib->nexthop; nexthop; nexthop = nexthop->next)
 565             {
 566               switch (nexthop->type)
 567                 {
 568                 case NEXTHOP_TYPE_IPV4:
 569                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 570                   if (nexthop->gate.ipv4.s_addr == nrn->p.u.prefix4.s_addr)
 571                     {
 572                       if (num_resolving_nh)
 573                         UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 574                       else
 575                         SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 576                     }
 577                   break;
 578                 case NEXTHOP_TYPE_IPV6:
 579                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 580
 581               if (memcmp(&nexthop->gate.ipv6,&nrn->p.u.prefix6, 16) == 0)
 582                 {
 583                   if (num_resolving_nh)
 584                     UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 585                   else
 586                     SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FILTERED);
 587                 }
 588               break;
 589             default:
 590               break;
 591             }
 592         }
 593
 594           if (IS_ZEBRA_DEBUG_NHT)
 595             {
 596               prefix2str(&static_rn->p, bufs, INET6_ADDRSTRLEN);
 597               if (prn && rib)
 598                 zlog_debug("%u:%s: NH change %s, scheduling static route %s",
 599                            vrfid, bufn, num_resolving_nh ?
 600                            "" : "(filtered by route-map)", bufs);
 601               else
 602                 zlog_debug("%u:%s: NH unreachable, scheduling static route %s",
 603                            vrfid, bufn, bufs);
 604             }
 605
 606           SET_FLAG(srib->status, RIB_ENTRY_CHANGED);
 607           SET_FLAG(srib->status, RIB_ENTRY_NEXTHOPS_CHANGED);
 608         }
 609
 610       rib_queue_add(static_rn);
 611     }
 612 }
 613
 614 /*
 615  * See if a tracked nexthop entry has undergone any change, and if so,
 616  * take appropriate action; this involves notifying any clients and/or
 617  * scheduling dependent static routes for processing.
 618  */
 619 static void
 620 zebra_rnh_eval_nexthop_entry (vrf_id_t vrfid, int family, int force,
 621                               struct route_node *nrn, struct rnh *rnh,
 622                               struct route_node *prn, struct rib *rib)
 623 {
 624   int state_changed = 0;
 625
 626   /* If we're resolving over a different route, resolution has changed or
 627    * the resolving route has some change (e.g., metric), there is a state
 628    * change.
 629    */
 630   if (!prefix_same(&rnh->resolved_route, &prn->p))
 631     {
 632       if (prn)
 633         prefix_copy(&rnh->resolved_route, &prn->p);
 634       else
 635         memset(&rnh->resolved_route, 0, sizeof(struct prefix));
 636
 637       copy_state(rnh, rib, nrn);
 638       state_changed = 1;
 639     }
 640   else if (compare_state(rib, rnh->state))
 641     {
 642       copy_state(rnh, rib, nrn);
 643       state_changed = 1;
 644     }
 645
 646   if (state_changed || force)
 647     {
 648       /* NOTE: Use the "copy" of resolving route stored in 'rnh' i.e.,
 649        * rnh->state.
 650        */
 651       /* Notify registered protocol clients. */
 652       zebra_rnh_notify_protocol_clients (vrfid, family, nrn, rnh,
 653                                          prn, rnh->state);
 654
 655       /* Process static routes attached to this nexthop */
 656       zebra_rnh_process_static_routes (vrfid, family, nrn, rnh,
 657                                        prn, rnh->state);
 658     }
 659 }
 660
 661 /* Evaluate one tracked entry */
 662 static void
 663 zebra_rnh_evaluate_entry (vrf_id_t vrfid, int family, int force, rnh_type_t type,
 664                           struct route_node *nrn)
 665 {
 666   struct rnh *rnh;
 667   struct rib *rib;
 668   struct route_node *prn;
 669   char bufn[INET6_ADDRSTRLEN];
 670
 671   if (IS_ZEBRA_DEBUG_NHT)
 672     {
 673       prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
 674       zlog_debug("%u:%s: Evaluate RNH, type %d %s",
 675                  vrfid, bufn, type, force ? "(force)" : "");
 676     }
 677
 678   rnh = nrn->info;
 679
 680   /* Identify route entry (RIB) resolving this tracked entry. */
 681   rib = zebra_rnh_resolve_entry (vrfid, family, type, nrn, rnh, &prn);
 682
 683   /* If the entry cannot be resolved and that is also the existing state,
 684    * there is nothing further to do.
 685    */
 686   if (!rib && rnh->state == NULL && !force)
 687     return;
 688
 689   /* Process based on type of entry. */
 690   if (type == RNH_IMPORT_CHECK_TYPE)
 691     zebra_rnh_eval_import_check_entry (vrfid, family, force,
 692                                        nrn, rnh, rib);
 693   else
 694     zebra_rnh_eval_nexthop_entry (vrfid, family, force,
 695                                   nrn, rnh, prn, rib);
 696 }
 697
 698 /*
 699  * Clear the RIB_ENTRY_NEXTHOPS_CHANGED flag
 700  * from the rib entries.
 701  *
 702  * Please note we are doing this *after* we have
 703  * notified the world about each nexthop as that
 704  * we can have a situation where one rib entry
 705  * covers multiple nexthops we are interested in.
 706  */
 707 static void
 708 zebra_rnh_clear_nhc_flag (vrf_id_t vrfid, int family, rnh_type_t type,
 709                           struct route_node *nrn)
 710 {
 711   struct rnh *rnh;
 712   struct rib *rib;
 713   struct route_node *prn;
 714
 715   rnh = nrn->info;
 716
 717   rib = zebra_rnh_resolve_entry (vrfid, family, type, nrn, rnh, &prn);
 718
 719   if (rib)
 720     UNSET_FLAG (rib->status, RIB_ENTRY_NEXTHOPS_CHANGED);
 721 }
 722
 723 /* Evaluate all tracked entries (nexthops or routes for import into BGP)
 724  * of a particular VRF and address-family or a specific prefix.
 725  */
 726 void
 727 zebra_evaluate_rnh (vrf_id_t vrfid, int family, int force, rnh_type_t type,
 728                     struct prefix *p)
 729 {
 730   struct route_table *rnh_table;
 731   struct route_node *nrn;
 732
 733   rnh_table = get_rnh_table(vrfid, family, type);
 734   if (!rnh_table) // unexpected
 735     return;
 736
 737   if (p)
 738     {
 739       /* Evaluating a specific entry, make sure it exists. */
 740       nrn = route_node_lookup (rnh_table, p);
 741       if (nrn && nrn->info)
 742         zebra_rnh_evaluate_entry (vrfid, family, force, type, nrn);
 743
 744       if (nrn)
 745         route_unlock_node (nrn);
 746     }
 747   else
 748     {
 749       /* Evaluate entire table. */
 750       nrn = route_top (rnh_table);
 751       while (nrn)
 752         {
 753           if (nrn->info)
 754             zebra_rnh_evaluate_entry (vrfid, family, force, type, nrn);
 755           nrn = route_next(nrn); /* this will also unlock nrn */
 756         }
 757       nrn = route_top (rnh_table);
 758       while (nrn)
 759         {
 760           if (nrn->info)
 761             zebra_rnh_clear_nhc_flag (vrfid, family, type, nrn);
 762           nrn = route_next(nrn); /* this will also unlock nrn */
 763         }
 764     }
 765 }
 766
 767 void
 768 zebra_print_rnh_table (vrf_id_t vrfid, int af, struct vty *vty, rnh_type_t type)
 769 {
 770   struct route_table *table;
 771   struct route_node *rn;
 772
 773   table = get_rnh_table(vrfid, af, type);
 774   if (!table)
 775     {
 776       zlog_debug("print_rnhs: rnh table not found\n");
 777       return;
 778     }
 779
 780   for (rn = route_top(table); rn; rn = route_next(rn))
 781       if (rn->info)
 782         print_rnh(rn, vty);
 783 }
 784
 785 int
 786 zebra_cleanup_rnh_client (vrf_id_t vrf_id, int family, struct zserv *client,
 787                           rnh_type_t type)
 788 {
 789   struct route_table *ntable;
 790   struct route_node *nrn;
 791   struct rnh *rnh;
 792
 793   if (IS_ZEBRA_DEBUG_NHT)
 794     zlog_debug("%u: Client %s RNH cleanup for family %d type %d",
 795                vrf_id, zebra_route_string(client->proto), family, type);
 796
 797   ntable = get_rnh_table(vrf_id, family, type);
 798   if (!ntable)
 799     {
 800       zlog_debug("cleanup_rnh_client: rnh table not found\n");
 801       return -1;
 802     }
 803
 804   for (nrn = route_top (ntable); nrn; nrn = route_next (nrn))
 805     {
 806       if (!nrn->info)
 807           continue;
 808
 809       rnh = nrn->info;
 810       zebra_remove_rnh_client(rnh, client, type);
 811     }
 812   return 1;
 813 }
 814
 815 /**
 816  * free_state - free up the rib structure associated with the rnh.
 817  */
 818 static void
 819 free_state (vrf_id_t vrf_id, struct rib *rib, struct route_node *rn)
 820 {
 821
 822   if (!rib)
 823     return;
 824
 825   /* free RIB and nexthops */
 826   zebra_deregister_rnh_static_nexthops (vrf_id, rib->nexthop, rn);
 827   nexthops_free(rib->nexthop);
 828   XFREE (MTYPE_RIB, rib);
 829 }
 830
 831 static void
 832 copy_state (struct rnh *rnh, struct rib *rib, struct route_node *rn)
 833 {
 834   struct rib *state;
 835   struct nexthop *nh;
 836
 837   if (rnh->state)
 838     {
 839       free_state(rnh->vrf_id, rnh->state, rn);
 840       rnh->state = NULL;
 841     }
 842
 843   if (!rib)
 844     return;
 845
 846   state = XCALLOC (MTYPE_RIB, sizeof (struct rib));
 847   state->type = rib->type;
 848   state->metric = rib->metric;
 849
 850   for (nh = rib->nexthop; nh; nh = nh->next)
 851     rib_copy_nexthops(state, nh);
 852   rnh->state = state;
 853 }
 854
 855 static int
 856 compare_state (struct rib *r1, struct rib *r2)
 857 {
 858
 859   if (!r1 && !r2)
 860     return 0;
 861
 862   if ((!r1 && r2) || (r1 && !r2))
 863       return 1;
 864
 865   if (r1->metric != r2->metric)
 866       return 1;
 867
 868   if (r1->nexthop_num != r2->nexthop_num)
 869       return 1;
 870
 871   if (CHECK_FLAG(r1->status, RIB_ENTRY_NEXTHOPS_CHANGED))
 872     return 1;
 873
 874   return 0;
 875 }
 876
 877 static int
 878 send_client (struct rnh *rnh, struct zserv *client, rnh_type_t type, vrf_id_t vrf_id)
 879 {
 880   struct stream *s;
 881   struct rib *rib;
 882   unsigned long nump;
 883   u_char num;
 884   struct nexthop *nexthop;
 885   struct route_node *rn;
 886   int cmd = (type == RNH_IMPORT_CHECK_TYPE)
 887     ? ZEBRA_IMPORT_CHECK_UPDATE : ZEBRA_NEXTHOP_UPDATE;
 888
 889   rn = rnh->node;
 890   rib = rnh->state;
 891
 892   /* Get output stream. */
 893   s = client->obuf;
 894   stream_reset (s);
 895
 896   zserv_create_header (s, cmd, vrf_id);
 897
 898   stream_putw(s, rn->p.family);
 899   switch (rn->p.family)
 900     {
 901     case AF_INET:
 902       stream_putc(s, rn->p.prefixlen);
 903       stream_put_in_addr(s, &rn->p.u.prefix4);
 904       break;
 905     case AF_INET6:
 906       stream_putc(s, rn->p.prefixlen);
 907       stream_put(s, &rn->p.u.prefix6, IPV6_MAX_BYTELEN);
 908       break;
 909     default:
 910       zlog_err("%s: Unknown family (%d) notification attempted\n",
 911                __FUNCTION__, rn->p.family);
 912       break;
 913     }
 914   if (rib)
 915     {
 916       stream_putc (s, rib->distance);
 917       stream_putl (s, rib->metric);
 918       num = 0;
 919       nump = stream_get_endp(s);
 920       stream_putc (s, 0);
 921       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 922         if ((CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB) ||
 923              CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE)) &&
 924             CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 925           {
 926             stream_putc (s, nexthop->type);
 927             switch (nexthop->type)
 928               {
 929               case NEXTHOP_TYPE_IPV4:
 930                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 931                 stream_putl (s, nexthop->ifindex);
 932                 break;
 933               case NEXTHOP_TYPE_IFINDEX:
 934                 stream_putl (s, nexthop->ifindex);
 935                 break;
 936               case NEXTHOP_TYPE_IPV4_IFINDEX:
 937                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 938                 stream_putl (s, nexthop->ifindex);
 939                 break;
 940               case NEXTHOP_TYPE_IPV6:
 941                 stream_put (s, &nexthop->gate.ipv6, 16);
 942                 stream_putl (s, nexthop->ifindex);
 943                 break;
 944               case NEXTHOP_TYPE_IPV6_IFINDEX:
 945                 stream_put (s, &nexthop->gate.ipv6, 16);
 946                 stream_putl (s, nexthop->ifindex);
 947                 break;
 948               default:
 949                 /* do nothing */
 950                 break;
 951               }
 952             num++;
 953           }
 954       stream_putc_at (s, nump, num);
 955     }
 956   else
 957     {
 958       stream_putc (s, 0);  // distance
 959       stream_putl (s, 0);  // metric
 960       stream_putc (s, 0);  // nexthops
 961     }
 962   stream_putw_at (s, 0, stream_get_endp (s));
 963
 964   client->nh_last_upd_time = monotime(NULL);
 965   client->last_write_cmd = cmd;
 966   return zebra_server_send_message(client);
 967 }
 968
 969 static void
 970 print_nh (struct nexthop *nexthop, struct vty *vty)
 971 {
 972   char buf[BUFSIZ];
 973   struct zebra_ns *zns = zebra_ns_lookup (NS_DEFAULT);
 974
 975   switch (nexthop->type)
 976     {
 977     case NEXTHOP_TYPE_IPV4:
 978     case NEXTHOP_TYPE_IPV4_IFINDEX:
 979       vty_out (vty, " via %s", inet_ntoa (nexthop->gate.ipv4));
 980       if (nexthop->ifindex)
 981         vty_out (vty, ", %s", ifindex2ifname_per_ns (zns, nexthop->ifindex));
 982       break;
 983     case NEXTHOP_TYPE_IPV6:
 984     case NEXTHOP_TYPE_IPV6_IFINDEX:
 985       vty_out (vty, " %s",
 986                inet_ntop (AF_INET6, &nexthop->gate.ipv6, buf, BUFSIZ));
 987       if (nexthop->ifindex)
 988         vty_out (vty, ", via %s", ifindex2ifname_per_ns (zns, nexthop->ifindex));
 989       break;
 990     case NEXTHOP_TYPE_IFINDEX:
 991       vty_out (vty, " is directly connected, %s",
 992                ifindex2ifname_per_ns (zns, nexthop->ifindex));
 993       break;
 994     case NEXTHOP_TYPE_BLACKHOLE:
 995       vty_out (vty, " is directly connected, Null0");
 996       break;
 997     default:
 998       break;
 999     }
1000   vty_out(vty, "%s", VTY_NEWLINE);
1001 }
1002
1003 static void
1004 print_rnh (struct route_node *rn, struct vty *vty)
1005 {
1006   struct rnh *rnh;
1007   struct nexthop *nexthop;
1008   struct listnode *node;
1009   struct zserv *client;
1010   char buf[BUFSIZ];
1011
1012   rnh = rn->info;
1013   vty_out(vty, "%s%s%s", inet_ntop(rn->p.family, &rn->p.u.prefix, buf, BUFSIZ),
1014           CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED) ? "(Connected)" : "",
1015           VTY_NEWLINE);
1016   if (rnh->state)
1017     {
1018       vty_out(vty, " resolved via %s%s",
1019               zebra_route_string(rnh->state->type), VTY_NEWLINE);
1020       for (nexthop = rnh->state->nexthop; nexthop; nexthop = nexthop->next)
1021         print_nh(nexthop, vty);
1022     }
1023   else
1024     vty_out(vty, " unresolved%s%s",
1025             CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED) ? "(Connected)" : "",
1026             VTY_NEWLINE);
1027
1028   vty_out(vty, " Client list:");
1029   for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
1030     vty_out(vty, " %s(fd %d)%s", zebra_route_string(client->proto),
1031             client->sock, rnh->filtered[client->proto] ? "(filtered)" : "");
1032   if (!list_isempty(rnh->zebra_static_route_list))
1033     vty_out(vty, " zebra%s", rnh->filtered[ZEBRA_ROUTE_STATIC] ? "(filtered)" : "");
1034   vty_out(vty, "%s", VTY_NEWLINE);
1035 }