zebra/zebra_rib.c

   1 /* Routing Information Base.
   2  * Copyright (C) 1997, 98, 99, 2001 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  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 "str.h"
  28 #include "command.h"
  29 #include "if.h"
  30 #include "log.h"
  31 #include "sockunion.h"
  32 #include "linklist.h"
  33 #include "thread.h"
  34 #include "workqueue.h"
  35 #include "prefix.h"
  36 #include "routemap.h"
  37
  38 #include "zebra/rib.h"
  39 #include "zebra/rt.h"
  40 #include "zebra/zserv.h"
  41 #include "zebra/redistribute.h"
  42 #include "zebra/debug.h"
  43
  44 /* Default rtm_table for all clients */
  45 extern struct zebra_t zebrad;
  46
  47 /* Hold time for RIB process, should be very minimal.
  48  * it is useful to able to set it otherwise for testing, hence exported
  49  * as global here for test-rig code.
  50  */
  51 int rib_process_hold_time = 10;
  52
  53 /* Each route type's string and default distance value. */
  54 struct
  55 {
  56   int key;
  57   int distance;
  58 } route_info[] =
  59 {
  60   {ZEBRA_ROUTE_SYSTEM,    0},
  61   {ZEBRA_ROUTE_KERNEL,    0},
  62   {ZEBRA_ROUTE_CONNECT,   0},
  63   {ZEBRA_ROUTE_STATIC,    1},
  64   {ZEBRA_ROUTE_RIP,     120},
  65   {ZEBRA_ROUTE_RIPNG,   120},
  66   {ZEBRA_ROUTE_OSPF,    110},
  67   {ZEBRA_ROUTE_OSPF6,   110},
  68   {ZEBRA_ROUTE_ISIS,    115},
  69   {ZEBRA_ROUTE_BGP,      20  /* IBGP is 200. */}
  70 };
  71 \f
  72 /* Vector for routing table.  */
  73 vector vrf_vector;
  74
  75 /* Allocate new VRF.  */
  76 static struct vrf *
  77 vrf_alloc (const char *name)
  78 {
  79   struct vrf *vrf;
  80
  81   vrf = XCALLOC (MTYPE_VRF, sizeof (struct vrf));
  82
  83   /* Put name.  */
  84   if (name)
  85     vrf->name = XSTRDUP (MTYPE_VRF_NAME, name);
  86
  87   /* Allocate routing table and static table.  */
  88   vrf->table[AFI_IP][SAFI_UNICAST] = route_table_init ();
  89   vrf->table[AFI_IP6][SAFI_UNICAST] = route_table_init ();
  90   vrf->stable[AFI_IP][SAFI_UNICAST] = route_table_init ();
  91   vrf->stable[AFI_IP6][SAFI_UNICAST] = route_table_init ();
  92
  93   return vrf;
  94 }
  95
  96 /* Free VRF.  */
  97 static void
  98 vrf_free (struct vrf *vrf)
  99 {
 100   if (vrf->name)
 101     XFREE (MTYPE_VRF_NAME, vrf->name);
 102   XFREE (MTYPE_VRF, vrf);
 103 }
 104
 105 /* Lookup VRF by identifier.  */
 106 struct vrf *
 107 vrf_lookup (u_int32_t id)
 108 {
 109   return vector_lookup (vrf_vector, id);
 110 }
 111
 112 /* Lookup VRF by name.  */
 113 static struct vrf *
 114 vrf_lookup_by_name (char *name)
 115 {
 116   unsigned int i;
 117   struct vrf *vrf;
 118
 119   for (i = 0; i < vector_active (vrf_vector); i++)
 120     if ((vrf = vector_slot (vrf_vector, i)) != NULL)
 121       if (vrf->name && name && strcmp (vrf->name, name) == 0)
 122         return vrf;
 123   return NULL;
 124 }
 125
 126 /* Initialize VRF.  */
 127 static void
 128 vrf_init (void)
 129 {
 130   struct vrf *default_table;
 131
 132   /* Allocate VRF vector.  */
 133   vrf_vector = vector_init (1);
 134
 135   /* Allocate default main table.  */
 136   default_table = vrf_alloc ("Default-IP-Routing-Table");
 137
 138   /* Default table index must be 0.  */
 139   vector_set_index (vrf_vector, 0, default_table);
 140 }
 141
 142 /* Lookup route table.  */
 143 struct route_table *
 144 vrf_table (afi_t afi, safi_t safi, u_int32_t id)
 145 {
 146   struct vrf *vrf;
 147
 148   vrf = vrf_lookup (id);
 149   if (! vrf)
 150     return NULL;
 151
 152   return vrf->table[afi][safi];
 153 }
 154
 155 /* Lookup static route table.  */
 156 struct route_table *
 157 vrf_static_table (afi_t afi, safi_t safi, u_int32_t id)
 158 {
 159   struct vrf *vrf;
 160
 161   vrf = vrf_lookup (id);
 162   if (! vrf)
 163     return NULL;
 164
 165   return vrf->stable[afi][safi];
 166 }
 167 \f
 168 /* Add nexthop to the end of the list.  */
 169 static void
 170 nexthop_add (struct rib *rib, struct nexthop *nexthop)
 171 {
 172   struct nexthop *last;
 173
 174   for (last = rib->nexthop; last && last->next; last = last->next)
 175     ;
 176   if (last)
 177     last->next = nexthop;
 178   else
 179     rib->nexthop = nexthop;
 180   nexthop->prev = last;
 181
 182   rib->nexthop_num++;
 183 }
 184
 185 /* Delete specified nexthop from the list. */
 186 static void
 187 nexthop_delete (struct rib *rib, struct nexthop *nexthop)
 188 {
 189   if (nexthop->next)
 190     nexthop->next->prev = nexthop->prev;
 191   if (nexthop->prev)
 192     nexthop->prev->next = nexthop->next;
 193   else
 194     rib->nexthop = nexthop->next;
 195   rib->nexthop_num--;
 196 }
 197
 198 /* Free nexthop. */
 199 static void
 200 nexthop_free (struct nexthop *nexthop)
 201 {
 202   if (nexthop->ifname)
 203     XFREE (0, nexthop->ifname);
 204   XFREE (MTYPE_NEXTHOP, nexthop);
 205 }
 206
 207 struct nexthop *
 208 nexthop_ifindex_add (struct rib *rib, unsigned int ifindex)
 209 {
 210   struct nexthop *nexthop;
 211
 212   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 213   memset (nexthop, 0, sizeof (struct nexthop));
 214   nexthop->type = NEXTHOP_TYPE_IFINDEX;
 215   nexthop->ifindex = ifindex;
 216
 217   nexthop_add (rib, nexthop);
 218
 219   return nexthop;
 220 }
 221
 222 struct nexthop *
 223 nexthop_ifname_add (struct rib *rib, char *ifname)
 224 {
 225   struct nexthop *nexthop;
 226
 227   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 228   memset (nexthop, 0, sizeof (struct nexthop));
 229   nexthop->type = NEXTHOP_TYPE_IFNAME;
 230   nexthop->ifname = XSTRDUP (0, ifname);
 231
 232   nexthop_add (rib, nexthop);
 233
 234   return nexthop;
 235 }
 236
 237 struct nexthop *
 238 nexthop_ipv4_add (struct rib *rib, struct in_addr *ipv4, struct in_addr *src)
 239 {
 240   struct nexthop *nexthop;
 241
 242   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 243   memset (nexthop, 0, sizeof (struct nexthop));
 244   nexthop->type = NEXTHOP_TYPE_IPV4;
 245   nexthop->gate.ipv4 = *ipv4;
 246   if (src)
 247     nexthop->src.ipv4 = *src;
 248
 249   nexthop_add (rib, nexthop);
 250
 251   return nexthop;
 252 }
 253
 254 static struct nexthop *
 255 nexthop_ipv4_ifindex_add (struct rib *rib, struct in_addr *ipv4,
 256                           struct in_addr *src, unsigned int ifindex)
 257 {
 258   struct nexthop *nexthop;
 259
 260   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 261   memset (nexthop, 0, sizeof (struct nexthop));
 262   nexthop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
 263   nexthop->gate.ipv4 = *ipv4;
 264   if (src)
 265     nexthop->src.ipv4 = *src;
 266   nexthop->ifindex = ifindex;
 267
 268   nexthop_add (rib, nexthop);
 269
 270   return nexthop;
 271 }
 272
 273 #ifdef HAVE_IPV6
 274 struct nexthop *
 275 nexthop_ipv6_add (struct rib *rib, struct in6_addr *ipv6)
 276 {
 277   struct nexthop *nexthop;
 278
 279   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 280   memset (nexthop, 0, sizeof (struct nexthop));
 281   nexthop->type = NEXTHOP_TYPE_IPV6;
 282   nexthop->gate.ipv6 = *ipv6;
 283
 284   nexthop_add (rib, nexthop);
 285
 286   return nexthop;
 287 }
 288
 289 static struct nexthop *
 290 nexthop_ipv6_ifname_add (struct rib *rib, struct in6_addr *ipv6,
 291                          char *ifname)
 292 {
 293   struct nexthop *nexthop;
 294
 295   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 296   memset (nexthop, 0, sizeof (struct nexthop));
 297   nexthop->type = NEXTHOP_TYPE_IPV6_IFNAME;
 298   nexthop->gate.ipv6 = *ipv6;
 299   nexthop->ifname = XSTRDUP (0, ifname);
 300
 301   nexthop_add (rib, nexthop);
 302
 303   return nexthop;
 304 }
 305
 306 static struct nexthop *
 307 nexthop_ipv6_ifindex_add (struct rib *rib, struct in6_addr *ipv6,
 308                           unsigned int ifindex)
 309 {
 310   struct nexthop *nexthop;
 311
 312   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 313   memset (nexthop, 0, sizeof (struct nexthop));
 314   nexthop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
 315   nexthop->gate.ipv6 = *ipv6;
 316   nexthop->ifindex = ifindex;
 317
 318   nexthop_add (rib, nexthop);
 319
 320   return nexthop;
 321 }
 322 #endif /* HAVE_IPV6 */
 323
 324 struct nexthop *
 325 nexthop_blackhole_add (struct rib *rib)
 326 {
 327   struct nexthop *nexthop;
 328
 329   nexthop = XMALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 330   memset (nexthop, 0, sizeof (struct nexthop));
 331   nexthop->type = NEXTHOP_TYPE_BLACKHOLE;
 332   SET_FLAG (rib->flags, ZEBRA_FLAG_BLACKHOLE);
 333
 334   nexthop_add (rib, nexthop);
 335
 336   return nexthop;
 337 }
 338
 339 /* If force flag is not set, do not modify falgs at all for uninstall
 340    the route from FIB. */
 341 static int
 342 nexthop_active_ipv4 (struct rib *rib, struct nexthop *nexthop, int set,
 343                      struct route_node *top)
 344 {
 345   struct prefix_ipv4 p;
 346   struct route_table *table;
 347   struct route_node *rn;
 348   struct rib *match;
 349   struct nexthop *newhop;
 350
 351   if (nexthop->type == NEXTHOP_TYPE_IPV4)
 352     nexthop->ifindex = 0;
 353
 354   if (set)
 355     UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
 356
 357   /* Make lookup prefix. */
 358   memset (&p, 0, sizeof (struct prefix_ipv4));
 359   p.family = AF_INET;
 360   p.prefixlen = IPV4_MAX_PREFIXLEN;
 361   p.prefix = nexthop->gate.ipv4;
 362
 363   /* Lookup table.  */
 364   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
 365   if (! table)
 366     return 0;
 367
 368   rn = route_node_match (table, (struct prefix *) &p);
 369   while (rn)
 370     {
 371       route_unlock_node (rn);
 372
 373       /* If lookup self prefix return immidiately. */
 374       if (rn == top)
 375         return 0;
 376
 377       /* Pick up selected route. */
 378       for (match = rn->info; match; match = match->next)
 379         if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 380           break;
 381
 382       /* If there is no selected route or matched route is EGP, go up
 383          tree. */
 384       if (! match
 385           || match->type == ZEBRA_ROUTE_BGP)
 386         {
 387           do {
 388             rn = rn->parent;
 389           } while (rn && rn->info == NULL);
 390           if (rn)
 391             route_lock_node (rn);
 392         }
 393       else
 394         {
 395           if (match->type == ZEBRA_ROUTE_CONNECT)
 396             {
 397               /* Directly point connected route. */
 398               newhop = match->nexthop;
 399               if (newhop && nexthop->type == NEXTHOP_TYPE_IPV4)
 400                 nexthop->ifindex = newhop->ifindex;
 401
 402               return 1;
 403             }
 404           else if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_INTERNAL))
 405             {
 406               for (newhop = match->nexthop; newhop; newhop = newhop->next)
 407                 if (CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_FIB)
 408                     && ! CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_RECURSIVE))
 409                   {
 410                     if (set)
 411                       {
 412                         SET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
 413                         nexthop->rtype = newhop->type;
 414                         if (newhop->type == NEXTHOP_TYPE_IPV4 ||
 415                             newhop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 416                           nexthop->rgate.ipv4 = newhop->gate.ipv4;
 417                         if (newhop->type == NEXTHOP_TYPE_IFINDEX
 418                             || newhop->type == NEXTHOP_TYPE_IFNAME
 419                             || newhop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 420                           nexthop->rifindex = newhop->ifindex;
 421                       }
 422                     return 1;
 423                   }
 424               return 0;
 425             }
 426           else
 427             {
 428               return 0;
 429             }
 430         }
 431     }
 432   return 0;
 433 }
 434
 435 #ifdef HAVE_IPV6
 436 /* If force flag is not set, do not modify falgs at all for uninstall
 437    the route from FIB. */
 438 static int
 439 nexthop_active_ipv6 (struct rib *rib, struct nexthop *nexthop, int set,
 440                      struct route_node *top)
 441 {
 442   struct prefix_ipv6 p;
 443   struct route_table *table;
 444   struct route_node *rn;
 445   struct rib *match;
 446   struct nexthop *newhop;
 447
 448   if (nexthop->type == NEXTHOP_TYPE_IPV6)
 449     nexthop->ifindex = 0;
 450
 451   if (set)
 452     UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
 453
 454   /* Make lookup prefix. */
 455   memset (&p, 0, sizeof (struct prefix_ipv6));
 456   p.family = AF_INET6;
 457   p.prefixlen = IPV6_MAX_PREFIXLEN;
 458   p.prefix = nexthop->gate.ipv6;
 459
 460   /* Lookup table.  */
 461   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
 462   if (! table)
 463     return 0;
 464
 465   rn = route_node_match (table, (struct prefix *) &p);
 466   while (rn)
 467     {
 468       route_unlock_node (rn);
 469
 470       /* If lookup self prefix return immidiately. */
 471       if (rn == top)
 472         return 0;
 473
 474       /* Pick up selected route. */
 475       for (match = rn->info; match; match = match->next)
 476         if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 477           break;
 478
 479       /* If there is no selected route or matched route is EGP, go up
 480          tree. */
 481       if (! match
 482           || match->type == ZEBRA_ROUTE_BGP)
 483         {
 484           do {
 485             rn = rn->parent;
 486           } while (rn && rn->info == NULL);
 487           if (rn)
 488             route_lock_node (rn);
 489         }
 490       else
 491         {
 492           if (match->type == ZEBRA_ROUTE_CONNECT)
 493             {
 494               /* Directly point connected route. */
 495               newhop = match->nexthop;
 496
 497               if (newhop && nexthop->type == NEXTHOP_TYPE_IPV6)
 498                 nexthop->ifindex = newhop->ifindex;
 499
 500               return 1;
 501             }
 502           else if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_INTERNAL))
 503             {
 504               for (newhop = match->nexthop; newhop; newhop = newhop->next)
 505                 if (CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_FIB)
 506                     && ! CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_RECURSIVE))
 507                   {
 508                     if (set)
 509                       {
 510                         SET_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE);
 511                         nexthop->rtype = newhop->type;
 512                         if (newhop->type == NEXTHOP_TYPE_IPV6
 513                             || newhop->type == NEXTHOP_TYPE_IPV6_IFINDEX
 514                             || newhop->type == NEXTHOP_TYPE_IPV6_IFNAME)
 515                           nexthop->rgate.ipv6 = newhop->gate.ipv6;
 516                         if (newhop->type == NEXTHOP_TYPE_IFINDEX
 517                             || newhop->type == NEXTHOP_TYPE_IFNAME
 518                             || newhop->type == NEXTHOP_TYPE_IPV6_IFINDEX
 519                             || newhop->type == NEXTHOP_TYPE_IPV6_IFNAME)
 520                           nexthop->rifindex = newhop->ifindex;
 521                       }
 522                     return 1;
 523                   }
 524               return 0;
 525             }
 526           else
 527             {
 528               return 0;
 529             }
 530         }
 531     }
 532   return 0;
 533 }
 534 #endif /* HAVE_IPV6 */
 535
 536 struct rib *
 537 rib_match_ipv4 (struct in_addr addr)
 538 {
 539   struct prefix_ipv4 p;
 540   struct route_table *table;
 541   struct route_node *rn;
 542   struct rib *match;
 543   struct nexthop *newhop;
 544
 545   /* Lookup table.  */
 546   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
 547   if (! table)
 548     return 0;
 549
 550   memset (&p, 0, sizeof (struct prefix_ipv4));
 551   p.family = AF_INET;
 552   p.prefixlen = IPV4_MAX_PREFIXLEN;
 553   p.prefix = addr;
 554
 555   rn = route_node_match (table, (struct prefix *) &p);
 556
 557   while (rn)
 558     {
 559       route_unlock_node (rn);
 560
 561       /* Pick up selected route. */
 562       for (match = rn->info; match; match = match->next)
 563         if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 564           break;
 565
 566       /* If there is no selected route or matched route is EGP, go up
 567          tree. */
 568       if (! match
 569           || match->type == ZEBRA_ROUTE_BGP)
 570         {
 571           do {
 572             rn = rn->parent;
 573           } while (rn && rn->info == NULL);
 574           if (rn)
 575             route_lock_node (rn);
 576         }
 577       else
 578         {
 579           if (match->type == ZEBRA_ROUTE_CONNECT)
 580             /* Directly point connected route. */
 581             return match;
 582           else
 583             {
 584               for (newhop = match->nexthop; newhop; newhop = newhop->next)
 585                 if (CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_FIB))
 586                   return match;
 587               return NULL;
 588             }
 589         }
 590     }
 591   return NULL;
 592 }
 593
 594 struct rib *
 595 rib_lookup_ipv4 (struct prefix_ipv4 *p)
 596 {
 597   struct route_table *table;
 598   struct route_node *rn;
 599   struct rib *match;
 600   struct nexthop *nexthop;
 601
 602   /* Lookup table.  */
 603   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
 604   if (! table)
 605     return 0;
 606
 607   rn = route_node_lookup (table, (struct prefix *) p);
 608
 609   /* No route for this prefix. */
 610   if (! rn)
 611     return NULL;
 612
 613   /* Unlock node. */
 614   route_unlock_node (rn);
 615
 616   /* Pick up selected route. */
 617   for (match = rn->info; match; match = match->next)
 618     if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 619       break;
 620
 621   if (! match || match->type == ZEBRA_ROUTE_BGP)
 622     return NULL;
 623
 624   if (match->type == ZEBRA_ROUTE_CONNECT)
 625     return match;
 626
 627   for (nexthop = match->nexthop; nexthop; nexthop = nexthop->next)
 628     if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 629       return match;
 630
 631   return NULL;
 632 }
 633
 634 /*
 635  * This clone function, unlike its original rib_lookup_ipv4(), checks
 636  * if specified IPv4 route record (prefix/mask -> gate) exists in
 637  * the whole RIB and has ZEBRA_FLAG_SELECTED set.
 638  *
 639  * Return values:
 640  * -1: error
 641  * 0: exact match found
 642  * 1: a match was found with a different gate
 643  * 2: connected route found
 644  * 3: no matches found
 645  */
 646 int
 647 rib_lookup_ipv4_route (struct prefix_ipv4 *p, union sockunion * qgate)
 648 {
 649   struct route_table *table;
 650   struct route_node *rn;
 651   struct rib *match;
 652   struct nexthop *nexthop;
 653
 654   /* Lookup table.  */
 655   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
 656   if (! table)
 657     return ZEBRA_RIB_LOOKUP_ERROR;
 658
 659   /* Scan the RIB table for exactly matching RIB entry. */
 660   rn = route_node_lookup (table, (struct prefix *) p);
 661
 662   /* No route for this prefix. */
 663   if (! rn)
 664     return ZEBRA_RIB_NOTFOUND;
 665
 666   /* Unlock node. */
 667   route_unlock_node (rn);
 668
 669   /* Find out if a "selected" RR for the discovered RIB entry exists ever. */
 670   for (match = rn->info; match; match = match->next)
 671   {
 672     if (CHECK_FLAG (match->status, RIB_ENTRY_REMOVED))
 673       continue;
 674     if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 675       break;
 676   }
 677
 678   /* None such found :( */
 679   if (!match)
 680     return ZEBRA_RIB_NOTFOUND;
 681
 682   if (match->type == ZEBRA_ROUTE_CONNECT)
 683     return ZEBRA_RIB_FOUND_CONNECTED;
 684
 685   /* Ok, we have a cood candidate, let's check it's nexthop list... */
 686   for (nexthop = match->nexthop; nexthop; nexthop = nexthop->next)
 687     if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 688     {
 689       /* We are happy with either direct or recursive hexthop */
 690       if (nexthop->gate.ipv4.s_addr == qgate->sin.sin_addr.s_addr ||
 691           nexthop->rgate.ipv4.s_addr == qgate->sin.sin_addr.s_addr)
 692         return ZEBRA_RIB_FOUND_EXACT;
 693       else
 694       {
 695         if (IS_ZEBRA_DEBUG_RIB)
 696         {
 697           char gate_buf[INET_ADDRSTRLEN], rgate_buf[INET_ADDRSTRLEN], qgate_buf[INET_ADDRSTRLEN];
 698           inet_ntop (AF_INET, &nexthop->gate.ipv4.s_addr, gate_buf, INET_ADDRSTRLEN);
 699           inet_ntop (AF_INET, &nexthop->rgate.ipv4.s_addr, rgate_buf, INET_ADDRSTRLEN);
 700           inet_ntop (AF_INET, &qgate->sin.sin_addr.s_addr, qgate_buf, INET_ADDRSTRLEN);
 701           zlog_debug ("%s: qgate == %s, gate == %s, rgate == %s", __func__, qgate_buf, gate_buf, rgate_buf);
 702         }
 703         return ZEBRA_RIB_FOUND_NOGATE;
 704       }
 705     }
 706
 707   return ZEBRA_RIB_NOTFOUND;
 708 }
 709
 710 #ifdef HAVE_IPV6
 711 struct rib *
 712 rib_match_ipv6 (struct in6_addr *addr)
 713 {
 714   struct prefix_ipv6 p;
 715   struct route_table *table;
 716   struct route_node *rn;
 717   struct rib *match;
 718   struct nexthop *newhop;
 719
 720   /* Lookup table.  */
 721   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
 722   if (! table)
 723     return 0;
 724
 725   memset (&p, 0, sizeof (struct prefix_ipv6));
 726   p.family = AF_INET6;
 727   p.prefixlen = IPV6_MAX_PREFIXLEN;
 728   IPV6_ADDR_COPY (&p.prefix, addr);
 729
 730   rn = route_node_match (table, (struct prefix *) &p);
 731
 732   while (rn)
 733     {
 734       route_unlock_node (rn);
 735
 736       /* Pick up selected route. */
 737       for (match = rn->info; match; match = match->next)
 738         if (CHECK_FLAG (match->flags, ZEBRA_FLAG_SELECTED))
 739           break;
 740
 741       /* If there is no selected route or matched route is EGP, go up
 742          tree. */
 743       if (! match
 744           || match->type == ZEBRA_ROUTE_BGP)
 745         {
 746           do {
 747             rn = rn->parent;
 748           } while (rn && rn->info == NULL);
 749           if (rn)
 750             route_lock_node (rn);
 751         }
 752       else
 753         {
 754           if (match->type == ZEBRA_ROUTE_CONNECT)
 755             /* Directly point connected route. */
 756             return match;
 757           else
 758             {
 759               for (newhop = match->nexthop; newhop; newhop = newhop->next)
 760                 if (CHECK_FLAG (newhop->flags, NEXTHOP_FLAG_FIB))
 761                   return match;
 762               return NULL;
 763             }
 764         }
 765     }
 766   return NULL;
 767 }
 768 #endif /* HAVE_IPV6 */
 769
 770 #define RIB_SYSTEM_ROUTE(R) \
 771         ((R)->type == ZEBRA_ROUTE_KERNEL || (R)->type == ZEBRA_ROUTE_CONNECT)
 772
 773 /* This function verifies reachability of one given nexthop, which can be
 774  * numbered or unnumbered, IPv4 or IPv6. The result is unconditionally stored
 775  * in nexthop->flags field. If the 4th parameter, 'set', is non-zero,
 776  * nexthop->ifindex will be updated appropriately as well.
 777  * An existing route map can turn (otherwise active) nexthop into inactive, but
 778  * not vice versa.
 779  *
 780  * The return value is the final value of 'ACTIVE' flag.
 781  */
 782
 783 static int
 784 nexthop_active_check (struct route_node *rn, struct rib *rib,
 785                       struct nexthop *nexthop, int set)
 786 {
 787   struct interface *ifp;
 788   route_map_result_t ret = RMAP_MATCH;
 789   extern char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX+1];
 790   struct route_map *rmap;
 791   int family;
 792
 793   family = 0;
 794   switch (nexthop->type)
 795     {
 796     case NEXTHOP_TYPE_IFINDEX:
 797       ifp = if_lookup_by_index (nexthop->ifindex);
 798       if (ifp && if_is_up (ifp))
 799         SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 800       else
 801         UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 802       break;
 803     case NEXTHOP_TYPE_IPV6_IFNAME:
 804       family = AFI_IP6;
 805     case NEXTHOP_TYPE_IFNAME:
 806       ifp = if_lookup_by_name (nexthop->ifname);
 807       if (ifp && if_is_up (ifp))
 808         {
 809           if (set)
 810             nexthop->ifindex = ifp->ifindex;
 811           SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 812         }
 813       else
 814         {
 815           if (set)
 816             nexthop->ifindex = 0;
 817           UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 818         }
 819       break;
 820     case NEXTHOP_TYPE_IPV4:
 821     case NEXTHOP_TYPE_IPV4_IFINDEX:
 822       family = AFI_IP;
 823       if (nexthop_active_ipv4 (rib, nexthop, set, rn))
 824         SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 825       else
 826         UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 827       break;
 828 #ifdef HAVE_IPV6
 829     case NEXTHOP_TYPE_IPV6:
 830       family = AFI_IP6;
 831       if (nexthop_active_ipv6 (rib, nexthop, set, rn))
 832         SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 833       else
 834         UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 835       break;
 836     case NEXTHOP_TYPE_IPV6_IFINDEX:
 837       family = AFI_IP6;
 838       if (IN6_IS_ADDR_LINKLOCAL (&nexthop->gate.ipv6))
 839         {
 840           ifp = if_lookup_by_index (nexthop->ifindex);
 841           if (ifp && if_is_up (ifp))
 842             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 843           else
 844             UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 845         }
 846       else
 847         {
 848           if (nexthop_active_ipv6 (rib, nexthop, set, rn))
 849             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 850           else
 851             UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 852         }
 853       break;
 854 #endif /* HAVE_IPV6 */
 855     case NEXTHOP_TYPE_BLACKHOLE:
 856       SET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 857       break;
 858     default:
 859       break;
 860     }
 861   if (! CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 862     return 0;
 863
 864   if (RIB_SYSTEM_ROUTE(rib) ||
 865       (family == AFI_IP && rn->p.family != AF_INET) ||
 866       (family == AFI_IP6 && rn->p.family != AF_INET6))
 867     return CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 868
 869   rmap = 0;
 870   if (rib->type >= 0 && rib->type < ZEBRA_ROUTE_MAX &&
 871                 proto_rm[family][rib->type])
 872     rmap = route_map_lookup_by_name (proto_rm[family][rib->type]);
 873   if (!rmap && proto_rm[family][ZEBRA_ROUTE_MAX])
 874     rmap = route_map_lookup_by_name (proto_rm[family][ZEBRA_ROUTE_MAX]);
 875   if (rmap) {
 876       ret = route_map_apply(rmap, &rn->p, RMAP_ZEBRA, nexthop);
 877   }
 878
 879   if (ret == RMAP_DENYMATCH)
 880     UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 881   return CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 882 }
 883
 884 /* Iterate over all nexthops of the given RIB entry and refresh their
 885  * ACTIVE flag. rib->nexthop_active_num is updated accordingly. If any
 886  * nexthop is found to toggle the ACTIVE flag, the whole rib structure
 887  * is flagged with ZEBRA_FLAG_CHANGED. The 4th 'set' argument is
 888  * transparently passed to nexthop_active_check().
 889  *
 890  * Return value is the new number of active nexthops.
 891  */
 892
 893 static int
 894 nexthop_active_update (struct route_node *rn, struct rib *rib, int set)
 895 {
 896   struct nexthop *nexthop;
 897   int prev_active, new_active;
 898
 899   rib->nexthop_active_num = 0;
 900   UNSET_FLAG (rib->flags, ZEBRA_FLAG_CHANGED);
 901
 902   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 903   {
 904     prev_active = CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE);
 905     if ((new_active = nexthop_active_check (rn, rib, nexthop, set)))
 906       rib->nexthop_active_num++;
 907     if (prev_active != new_active)
 908       SET_FLAG (rib->flags, ZEBRA_FLAG_CHANGED);
 909   }
 910   return rib->nexthop_active_num;
 911 }
 912
 913 \f
 914
 915 static void
 916 rib_install_kernel (struct route_node *rn, struct rib *rib)
 917 {
 918   int ret = 0;
 919   struct nexthop *nexthop;
 920
 921   switch (PREFIX_FAMILY (&rn->p))
 922     {
 923     case AF_INET:
 924       ret = kernel_add_ipv4 (&rn->p, rib);
 925       break;
 926 #ifdef HAVE_IPV6
 927     case AF_INET6:
 928       ret = kernel_add_ipv6 (&rn->p, rib);
 929       break;
 930 #endif /* HAVE_IPV6 */
 931     }
 932
 933   /* This condition is never met, if we are using rt_socket.c */
 934   if (ret < 0)
 935     {
 936       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 937         UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 938     }
 939 }
 940
 941 /* Uninstall the route from kernel. */
 942 static int
 943 rib_uninstall_kernel (struct route_node *rn, struct rib *rib)
 944 {
 945   int ret = 0;
 946   struct nexthop *nexthop;
 947
 948   switch (PREFIX_FAMILY (&rn->p))
 949     {
 950     case AF_INET:
 951       ret = kernel_delete_ipv4 (&rn->p, rib);
 952       break;
 953 #ifdef HAVE_IPV6
 954     case AF_INET6:
 955       if (IS_ZEBRA_DEBUG_RIB)
 956         zlog_debug ("%s: calling kernel_delete_ipv4 (%p, %p)", __func__, rn, rib);
 957       ret = kernel_delete_ipv6 (&rn->p, rib);
 958       break;
 959 #endif /* HAVE_IPV6 */
 960     }
 961
 962   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 963     UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 964
 965   return ret;
 966 }
 967
 968 /* Uninstall the route from kernel. */
 969 static void
 970 rib_uninstall (struct route_node *rn, struct rib *rib)
 971 {
 972   if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
 973     {
 974       redistribute_delete (&rn->p, rib);
 975       if (! RIB_SYSTEM_ROUTE (rib))
 976         rib_uninstall_kernel (rn, rib);
 977       UNSET_FLAG (rib->flags, ZEBRA_FLAG_SELECTED);
 978     }
 979 }
 980
 981 static void rib_unlink (struct route_node *, struct rib *);
 982
 983 /* Core function for processing routing information base. */
 984 static wq_item_status
 985 rib_process (struct work_queue *wq, void *data)
 986 {
 987   struct rib *rib;
 988   struct rib *next;
 989   struct rib *fib = NULL;
 990   struct rib *select = NULL;
 991   struct rib *del = NULL;
 992   struct route_node *rn = data;
 993   int installed = 0;
 994   struct nexthop *nexthop = NULL;
 995   char buf[INET6_ADDRSTRLEN];
 996
 997   assert (rn);
 998
 999   if (IS_ZEBRA_DEBUG_RIB || IS_ZEBRA_DEBUG_RIB_Q)
1000     inet_ntop (rn->p.family, &rn->p.u.prefix, buf, INET6_ADDRSTRLEN);
1001
1002   for (rib = rn->info; rib; rib = next)
1003     {
1004       /* The next pointer is saved, because current pointer
1005        * may be passed to rib_unlink() in the middle of iteration.
1006        */
1007       next = rib->next;
1008
1009       /* Currently installed rib. */
1010       if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
1011         {
1012           assert (fib == NULL);
1013           fib = rib;
1014         }
1015
1016       /* Unlock removed routes, so they'll be freed, bar the FIB entry,
1017        * which we need to do do further work with below.
1018        */
1019       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1020         {
1021           if (rib != fib)
1022             {
1023               if (IS_ZEBRA_DEBUG_RIB)
1024                 zlog_debug ("%s: %s/%d: rn %p, removing rib %p", __func__,
1025                   buf, rn->p.prefixlen, rn, rib);
1026                 rib_unlink (rn, rib);
1027             }
1028           else
1029             del = rib;
1030
1031           continue;
1032         }
1033
1034       /* Skip unreachable nexthop. */
1035       if (! nexthop_active_update (rn, rib, 0))
1036         continue;
1037
1038       /* Infinit distance. */
1039       if (rib->distance == DISTANCE_INFINITY)
1040         continue;
1041
1042       /* Newly selected rib, the common case. */
1043       if (!select)
1044         {
1045           select = rib;
1046           continue;
1047         }
1048
1049       /* filter route selection in following order:
1050        * - connected beats other types
1051        * - lower distance beats higher
1052        * - lower metric beats higher for equal distance
1053        * - last, hence oldest, route wins tie break.
1054        */
1055
1056       /* Connected routes. Pick the last connected
1057        * route of the set of lowest metric connected routes.
1058        */
1059       if (rib->type == ZEBRA_ROUTE_CONNECT)
1060         {
1061           if (select->type != ZEBRA_ROUTE_CONNECT
1062               || rib->metric <= select->metric)
1063             select = rib;
1064           continue;
1065         }
1066       else if (select->type == ZEBRA_ROUTE_CONNECT)
1067         continue;
1068
1069       /* higher distance loses */
1070       if (rib->distance > select->distance)
1071         continue;
1072
1073       /* lower wins */
1074       if (rib->distance < select->distance)
1075         {
1076           select = rib;
1077           continue;
1078         }
1079
1080       /* metric tie-breaks equal distance */
1081       if (rib->metric <= select->metric)
1082         select = rib;
1083     } /* for (rib = rn->info; rib; rib = next) */
1084
1085   /* After the cycle is finished, the following pointers will be set:
1086    * select --- the winner RIB entry, if any was found, otherwise NULL
1087    * fib    --- the SELECTED RIB entry, if any, otherwise NULL
1088    * del    --- equal to fib, if fib is queued for deletion, NULL otherwise
1089    * rib    --- NULL
1090    */
1091
1092   /* Same RIB entry is selected. Update FIB and finish. */
1093   if (select && select == fib)
1094     {
1095       if (IS_ZEBRA_DEBUG_RIB)
1096         zlog_debug ("%s: %s/%d: Updating existing route, select %p, fib %p",
1097                      __func__, buf, rn->p.prefixlen, select, fib);
1098       if (CHECK_FLAG (select->flags, ZEBRA_FLAG_CHANGED))
1099         {
1100           redistribute_delete (&rn->p, select);
1101           if (! RIB_SYSTEM_ROUTE (select))
1102             rib_uninstall_kernel (rn, select);
1103
1104           /* Set real nexthop. */
1105           nexthop_active_update (rn, select, 1);
1106
1107           if (! RIB_SYSTEM_ROUTE (select))
1108             rib_install_kernel (rn, select);
1109           redistribute_add (&rn->p, select);
1110         }
1111       else if (! RIB_SYSTEM_ROUTE (select))
1112         {
1113           /* Housekeeping code to deal with
1114              race conditions in kernel with linux
1115              netlink reporting interface up before IPv4 or IPv6 protocol
1116              is ready to add routes.
1117              This makes sure the routes are IN the kernel.
1118            */
1119
1120           for (nexthop = select->nexthop; nexthop; nexthop = nexthop->next)
1121             if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
1122             {
1123               installed = 1;
1124               break;
1125             }
1126           if (! installed)
1127             rib_install_kernel (rn, select);
1128         }
1129       goto end;
1130     }
1131
1132   /* At this point we either haven't found the best RIB entry or it is
1133    * different from what we currently intend to flag with SELECTED. In both
1134    * cases, if a RIB block is present in FIB, it should be withdrawn.
1135    */
1136   if (fib)
1137     {
1138       if (IS_ZEBRA_DEBUG_RIB)
1139         zlog_debug ("%s: %s/%d: Removing existing route, fib %p", __func__,
1140           buf, rn->p.prefixlen, fib);
1141       redistribute_delete (&rn->p, fib);
1142       if (! RIB_SYSTEM_ROUTE (fib))
1143         rib_uninstall_kernel (rn, fib);
1144       UNSET_FLAG (fib->flags, ZEBRA_FLAG_SELECTED);
1145
1146       /* Set real nexthop. */
1147       nexthop_active_update (rn, fib, 1);
1148     }
1149
1150   /* Regardless of some RIB entry being SELECTED or not before, now we can
1151    * tell, that if a new winner exists, FIB is still not updated with this
1152    * data, but ready to be.
1153    */
1154   if (select)
1155     {
1156       if (IS_ZEBRA_DEBUG_RIB)
1157         zlog_debug ("%s: %s/%d: Adding route, select %p", __func__, buf,
1158           rn->p.prefixlen, select);
1159       /* Set real nexthop. */
1160       nexthop_active_update (rn, select, 1);
1161
1162       if (! RIB_SYSTEM_ROUTE (select))
1163         rib_install_kernel (rn, select);
1164       SET_FLAG (select->flags, ZEBRA_FLAG_SELECTED);
1165       redistribute_add (&rn->p, select);
1166     }
1167
1168   /* FIB route was removed, should be deleted */
1169   if (del)
1170     {
1171       if (IS_ZEBRA_DEBUG_RIB)
1172         zlog_debug ("%s: %s/%d: Deleting fib %p, rn %p", __func__, buf,
1173           rn->p.prefixlen, del, rn);
1174       rib_unlink (rn, del);
1175     }
1176
1177 end:
1178   if (IS_ZEBRA_DEBUG_RIB_Q)
1179     zlog_debug ("%s: %s/%d: rn %p dequeued", __func__, buf, rn->p.prefixlen, rn);
1180   if (rn->info)
1181     UNSET_FLAG (((struct rib *)rn->info)->rn_status, RIB_ROUTE_QUEUED);
1182   route_unlock_node (rn); /* rib queue lock */
1183   return WQ_SUCCESS;
1184 }
1185
1186 /* Add route_node to work queue and schedule processing */
1187 static void
1188 rib_queue_add (struct zebra_t *zebra, struct route_node *rn)
1189 {
1190   char buf[INET_ADDRSTRLEN];
1191   assert (zebra && rn);
1192
1193   if (IS_ZEBRA_DEBUG_RIB_Q)
1194     inet_ntop (AF_INET, &rn->p.u.prefix, buf, INET_ADDRSTRLEN);
1195
1196   /* Pointless to queue a route_node with no RIB entries to add or remove */
1197   if (!rn->info)
1198     {
1199       zlog_debug ("%s: called for route_node (%p, %d) with no ribs",
1200                   __func__, rn, rn->lock);
1201       zlog_backtrace(LOG_DEBUG);
1202       return;
1203     }
1204
1205   /* Route-table node already queued, so nothing to do */
1206   if (CHECK_FLAG (((struct rib *)rn->info)->rn_status, RIB_ROUTE_QUEUED))
1207     {
1208       if (IS_ZEBRA_DEBUG_RIB_Q)
1209         zlog_debug ("%s: %s/%d: rn %p already queued", __func__, buf,
1210           rn->p.prefixlen, rn);
1211       return;
1212     }
1213
1214   route_lock_node (rn); /* rib queue lock */
1215
1216   if (IS_ZEBRA_DEBUG_RIB_Q)
1217     zlog_info ("%s: %s/%d: work queue added", __func__, buf, rn->p.prefixlen);
1218
1219   assert (zebra);
1220
1221   if (zebra->ribq == NULL)
1222     {
1223       zlog_err ("%s: work_queue does not exist!", __func__);
1224       route_unlock_node (rn);
1225       return;
1226     }
1227
1228   work_queue_add (zebra->ribq, rn);
1229
1230   SET_FLAG (((struct rib *)rn->info)->rn_status, RIB_ROUTE_QUEUED);
1231
1232   if (IS_ZEBRA_DEBUG_RIB_Q)
1233     zlog_debug ("%s: %s/%d: rn %p queued", __func__, buf, rn->p.prefixlen, rn);
1234
1235   return;
1236 }
1237
1238 /* initialise zebra rib work queue */
1239 static void
1240 rib_queue_init (struct zebra_t *zebra)
1241 {
1242   assert (zebra);
1243
1244   if (! (zebra->ribq = work_queue_new (zebra->master,
1245                                        "route_node processing")))
1246     {
1247       zlog_err ("%s: could not initialise work queue!", __func__);
1248       return;
1249     }
1250
1251   /* fill in the work queue spec */
1252   zebra->ribq->spec.workfunc = &rib_process;
1253   zebra->ribq->spec.errorfunc = NULL;
1254   /* XXX: TODO: These should be runtime configurable via vty */
1255   zebra->ribq->spec.max_retries = 3;
1256   zebra->ribq->spec.hold = rib_process_hold_time;
1257
1258   return;
1259 }
1260
1261 /* RIB updates are processed via a queue of pointers to route_nodes.
1262  *
1263  * The queue length is bounded by the maximal size of the routing table,
1264  * as a route_node will not be requeued, if already queued.
1265  *
1266  * RIBs are submitted via rib_addnode or rib_delnode which set minimal
1267  * state, or static_install_ipv{4,6} (when an existing RIB is updated)
1268  * and then submit route_node to queue for best-path selection later.
1269  * Order of add/delete state changes are preserved for any given RIB.
1270  *
1271  * Deleted RIBs are reaped during best-path selection.
1272  *
1273  * rib_addnode
1274  * |-> rib_link or unset RIB_ENTRY_REMOVE        |->Update kernel with
1275  *       |-------->|                             |  best RIB, if required
1276  *                 |                             |
1277  * static_install->|->rib_addqueue...... -> rib_process
1278  *                 |                             |
1279  *       |-------->|                             |-> rib_unlink
1280  * |-> set RIB_ENTRY_REMOVE                           |
1281  * rib_delnode                                  (RIB freed)
1282  *
1283  *
1284  * Queueing state for a route_node is kept in the head RIB entry, this
1285  * state must be preserved as and when the head RIB entry of a
1286  * route_node is changed by rib_unlink / rib_link. A small complication,
1287  * but saves having to allocate a dedicated object for this.
1288  *
1289  * Refcounting (aka "locking" throughout the GNU Zebra and Quagga code):
1290  *
1291  * - route_nodes: refcounted by:
1292  *   - RIBs attached to route_node:
1293  *     - managed by: rib_link/unlink
1294  *   - route_node processing queue
1295  *     - managed by: rib_addqueue, rib_process.
1296  *
1297  */
1298
1299 /* Add RIB to head of the route node. */
1300 static void
1301 rib_link (struct route_node *rn, struct rib *rib)
1302 {
1303   struct rib *head;
1304   char buf[INET6_ADDRSTRLEN];
1305
1306   assert (rib && rn);
1307
1308   route_lock_node (rn); /* rn route table reference */
1309
1310   if (IS_ZEBRA_DEBUG_RIB)
1311   {
1312     inet_ntop (rn->p.family, &rn->p.u.prefix, buf, INET6_ADDRSTRLEN);
1313     zlog_debug ("%s: %s/%d: rn %p, rib %p", __func__,
1314       buf, rn->p.prefixlen, rn, rib);
1315   }
1316
1317   head = rn->info;
1318   if (head)
1319     {
1320       if (IS_ZEBRA_DEBUG_RIB)
1321         zlog_debug ("%s: %s/%d: new head, rn_status copied over", __func__,
1322           buf, rn->p.prefixlen);
1323       head->prev = rib;
1324       /* Transfer the rn status flags to the new head RIB */
1325       rib->rn_status = head->rn_status;
1326     }
1327   rib->next = head;
1328   rn->info = rib;
1329   rib_queue_add (&zebrad, rn);
1330 }
1331
1332 static void
1333 rib_addnode (struct route_node *rn, struct rib *rib)
1334 {
1335   /* RIB node has been un-removed before route-node is processed.
1336    * route_node must hence already be on the queue for processing..
1337    */
1338   if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1339     {
1340       if (IS_ZEBRA_DEBUG_RIB)
1341       {
1342         char buf[INET6_ADDRSTRLEN];
1343         inet_ntop (rn->p.family, &rn->p.u.prefix, buf, INET6_ADDRSTRLEN);
1344         zlog_debug ("%s: %s/%d: rn %p, un-removed rib %p",
1345                     __func__, buf, rn->p.prefixlen, rn, rib);
1346       }
1347       UNSET_FLAG (rib->status, RIB_ENTRY_REMOVED);
1348       return;
1349     }
1350   rib_link (rn, rib);
1351 }
1352
1353 static void
1354 rib_unlink (struct route_node *rn, struct rib *rib)
1355 {
1356   struct nexthop *nexthop, *next;
1357   char buf[INET6_ADDRSTRLEN];
1358
1359   assert (rn && rib);
1360
1361   if (IS_ZEBRA_DEBUG_RIB)
1362   {
1363     inet_ntop (rn->p.family, &rn->p.u.prefix, buf, INET6_ADDRSTRLEN);
1364     zlog_debug ("%s: %s/%d: rn %p, rib %p",
1365                 __func__, buf, rn->p.prefixlen, rn, rib);
1366   }
1367
1368   if (rib->next)
1369     rib->next->prev = rib->prev;
1370
1371   if (rib->prev)
1372     rib->prev->next = rib->next;
1373   else
1374     {
1375       rn->info = rib->next;
1376
1377       if (rn->info)
1378         {
1379           if (IS_ZEBRA_DEBUG_RIB)
1380             zlog_debug ("%s: %s/%d: rn %p, rib %p, new head copy",
1381                         __func__, buf, rn->p.prefixlen, rn, rib);
1382           rib->next->rn_status = rib->rn_status;
1383         }
1384     }
1385
1386   /* free RIB and nexthops */
1387   for (nexthop = rib->nexthop; nexthop; nexthop = next)
1388     {
1389       next = nexthop->next;
1390       nexthop_free (nexthop);
1391     }
1392   XFREE (MTYPE_RIB, rib);
1393
1394   route_unlock_node (rn); /* rn route table reference */
1395 }
1396
1397 static void
1398 rib_delnode (struct route_node *rn, struct rib *rib)
1399 {
1400   if (IS_ZEBRA_DEBUG_RIB)
1401   {
1402     char buf[INET6_ADDRSTRLEN];
1403     inet_ntop (rn->p.family, &rn->p.u.prefix, buf, INET6_ADDRSTRLEN);
1404     zlog_debug ("%s: %s/%d: rn %p, rib %p, removing", __func__,
1405       buf, rn->p.prefixlen, rn, rib);
1406   }
1407   SET_FLAG (rib->status, RIB_ENTRY_REMOVED);
1408   rib_queue_add (&zebrad, rn);
1409 }
1410
1411 int
1412 rib_add_ipv4 (int type, int flags, struct prefix_ipv4 *p,
1413               struct in_addr *gate, struct in_addr *src,
1414               unsigned int ifindex, u_int32_t vrf_id,
1415               u_int32_t metric, u_char distance)
1416 {
1417   struct rib *rib;
1418   struct rib *same = NULL;
1419   struct route_table *table;
1420   struct route_node *rn;
1421   struct nexthop *nexthop;
1422
1423   /* Lookup table.  */
1424   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1425   if (! table)
1426     return 0;
1427
1428   /* Make it sure prefixlen is applied to the prefix. */
1429   apply_mask_ipv4 (p);
1430
1431   /* Set default distance by route type. */
1432   if (distance == 0)
1433     {
1434       distance = route_info[type].distance;
1435
1436       /* iBGP distance is 200. */
1437       if (type == ZEBRA_ROUTE_BGP && CHECK_FLAG (flags, ZEBRA_FLAG_IBGP))
1438         distance = 200;
1439     }
1440
1441   /* Lookup route node.*/
1442   rn = route_node_get (table, (struct prefix *) p);
1443
1444   /* If same type of route are installed, treat it as a implicit
1445      withdraw. */
1446   for (rib = rn->info; rib; rib = rib->next)
1447     {
1448       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1449         continue;
1450
1451       if (rib->type != type)
1452         continue;
1453       if (rib->type != ZEBRA_ROUTE_CONNECT)
1454         {
1455           same = rib;
1456           break;
1457         }
1458       /* Duplicate connected route comes in. */
1459       else if ((nexthop = rib->nexthop) &&
1460                nexthop->type == NEXTHOP_TYPE_IFINDEX &&
1461                nexthop->ifindex == ifindex &&
1462                !CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1463         {
1464           rib->refcnt++;
1465           return 0 ;
1466         }
1467     }
1468
1469   /* Allocate new rib structure. */
1470   rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
1471   rib->type = type;
1472   rib->distance = distance;
1473   rib->flags = flags;
1474   rib->metric = metric;
1475   rib->table = vrf_id;
1476   rib->nexthop_num = 0;
1477   rib->uptime = time (NULL);
1478
1479   /* Nexthop settings. */
1480   if (gate)
1481     {
1482       if (ifindex)
1483         nexthop_ipv4_ifindex_add (rib, gate, src, ifindex);
1484       else
1485         nexthop_ipv4_add (rib, gate, src);
1486     }
1487   else
1488     nexthop_ifindex_add (rib, ifindex);
1489
1490   /* If this route is kernel route, set FIB flag to the route. */
1491   if (type == ZEBRA_ROUTE_KERNEL || type == ZEBRA_ROUTE_CONNECT)
1492     for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1493       SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1494
1495   /* Link new rib to node.*/
1496   if (IS_ZEBRA_DEBUG_RIB)
1497     zlog_debug ("%s: calling rib_addnode (%p, %p)", __func__, rn, rib);
1498   rib_addnode (rn, rib);
1499
1500   /* Free implicit route.*/
1501   if (same)
1502   {
1503     if (IS_ZEBRA_DEBUG_RIB)
1504       zlog_debug ("%s: calling rib_delnode (%p, %p)", __func__, rn, rib);
1505     rib_delnode (rn, same);
1506   }
1507
1508   route_unlock_node (rn);
1509   return 0;
1510 }
1511
1512 /* This function dumps the contents of a given RIB entry into
1513  * standard debug log. Calling function name and IP prefix in
1514  * question are passed as 1st and 2nd arguments.
1515  */
1516
1517 void rib_dump (const char * func, const struct prefix_ipv4 * p, const struct rib * rib)
1518 {
1519   char straddr1[INET_ADDRSTRLEN], straddr2[INET_ADDRSTRLEN];
1520   struct nexthop *nexthop;
1521
1522   inet_ntop (AF_INET, &p->prefix, straddr1, INET_ADDRSTRLEN);
1523   zlog_debug ("%s: dumping RIB entry %p for %s/%d", func, rib, straddr1, p->prefixlen);
1524   zlog_debug
1525   (
1526     "%s: refcnt == %lu, uptime == %u, type == %u, table == %d",
1527     func,
1528     rib->refcnt,
1529     rib->uptime,
1530     rib->type,
1531     rib->table
1532   );
1533   zlog_debug
1534   (
1535     "%s: metric == %u, distance == %u, flags == %u, status == %u",
1536     func,
1537     rib->metric,
1538     rib->distance,
1539     rib->flags,
1540     rib->status
1541   );
1542   zlog_debug
1543   (
1544     "%s: nexthop_num == %u, nexthop_active_num == %u, nexthop_fib_num == %u",
1545     func,
1546     rib->nexthop_num,
1547     rib->nexthop_active_num,
1548     rib->nexthop_fib_num
1549   );
1550   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1551   {
1552     inet_ntop (AF_INET, &nexthop->gate.ipv4.s_addr, straddr1, INET_ADDRSTRLEN);
1553     inet_ntop (AF_INET, &nexthop->rgate.ipv4.s_addr, straddr2, INET_ADDRSTRLEN);
1554     zlog_debug
1555     (
1556       "%s: NH %s (%s) with flags %s%s%s",
1557       func,
1558       straddr1,
1559       straddr2,
1560       (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE) ? "ACTIVE " : ""),
1561       (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB) ? "FIB " : ""),
1562       (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE) ? "RECURSIVE" : "")
1563     );
1564   }
1565   zlog_debug ("%s: dump complete", func);
1566 }
1567
1568 /* This is an exported helper to rtm_read() to dump the strange
1569  * RIB entry found by rib_lookup_ipv4_route()
1570  */
1571
1572 void rib_lookup_and_dump (struct prefix_ipv4 * p)
1573 {
1574   struct route_table *table;
1575   struct route_node *rn;
1576   struct rib *rib;
1577   char prefix_buf[INET_ADDRSTRLEN];
1578
1579   /* Lookup table.  */
1580   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1581   if (! table)
1582   {
1583     zlog_err ("%s: vrf_table() returned NULL", __func__);
1584     return;
1585   }
1586
1587   inet_ntop (AF_INET, &p->prefix.s_addr, prefix_buf, INET_ADDRSTRLEN);
1588   /* Scan the RIB table for exactly matching RIB entry. */
1589   rn = route_node_lookup (table, (struct prefix *) p);
1590
1591   /* No route for this prefix. */
1592   if (! rn)
1593   {
1594     zlog_debug ("%s: lookup failed for %s/%d", __func__, prefix_buf, p->prefixlen);
1595     return;
1596   }
1597
1598   /* Unlock node. */
1599   route_unlock_node (rn);
1600
1601   /* let's go */
1602   for (rib = rn->info; rib; rib = rib->next)
1603   {
1604     zlog_debug
1605     (
1606       "%s: rn %p, rib %p: %s, %s",
1607       __func__,
1608       rn,
1609       rib,
1610       (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED) ? "removed" : "NOT removed"),
1611       (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED) ? "selected" : "NOT selected")
1612     );
1613     rib_dump (__func__, p, rib);
1614   }
1615 }
1616
1617 int
1618 rib_add_ipv4_multipath (struct prefix_ipv4 *p, struct rib *rib)
1619 {
1620   struct route_table *table;
1621   struct route_node *rn;
1622   struct rib *same;
1623   struct nexthop *nexthop;
1624
1625   /* Lookup table.  */
1626   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1627   if (! table)
1628     return 0;
1629   /* Make it sure prefixlen is applied to the prefix. */
1630   apply_mask_ipv4 (p);
1631
1632   /* Set default distance by route type. */
1633   if (rib->distance == 0)
1634     {
1635       rib->distance = route_info[rib->type].distance;
1636
1637       /* iBGP distance is 200. */
1638       if (rib->type == ZEBRA_ROUTE_BGP
1639           && CHECK_FLAG (rib->flags, ZEBRA_FLAG_IBGP))
1640         rib->distance = 200;
1641     }
1642
1643   /* Lookup route node.*/
1644   rn = route_node_get (table, (struct prefix *) p);
1645
1646   /* If same type of route are installed, treat it as a implicit
1647      withdraw. */
1648   for (same = rn->info; same; same = same->next)
1649     {
1650       if (CHECK_FLAG (same->status, RIB_ENTRY_REMOVED))
1651         continue;
1652
1653       if (same->type == rib->type && same->table == rib->table
1654           && same->type != ZEBRA_ROUTE_CONNECT)
1655         break;
1656     }
1657
1658   /* If this route is kernel route, set FIB flag to the route. */
1659   if (rib->type == ZEBRA_ROUTE_KERNEL || rib->type == ZEBRA_ROUTE_CONNECT)
1660     for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1661       SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1662
1663   /* Link new rib to node.*/
1664   rib_addnode (rn, rib);
1665   if (IS_ZEBRA_DEBUG_RIB)
1666   {
1667     zlog_debug ("%s: called rib_addnode (%p, %p) on new RIB entry",
1668       __func__, rn, rib);
1669     rib_dump (__func__, p, rib);
1670   }
1671
1672   /* Free implicit route.*/
1673   if (same)
1674   {
1675     if (IS_ZEBRA_DEBUG_RIB)
1676     {
1677       zlog_debug ("%s: calling rib_delnode (%p, %p) on existing RIB entry",
1678         __func__, rn, same);
1679       rib_dump (__func__, p, same);
1680     }
1681     rib_delnode (rn, same);
1682   }
1683
1684   route_unlock_node (rn);
1685   return 0;
1686 }
1687
1688 /* XXX factor with rib_delete_ipv6 */
1689 int
1690 rib_delete_ipv4 (int type, int flags, struct prefix_ipv4 *p,
1691                  struct in_addr *gate, unsigned int ifindex, u_int32_t vrf_id)
1692 {
1693   struct route_table *table;
1694   struct route_node *rn;
1695   struct rib *rib;
1696   struct rib *fib = NULL;
1697   struct rib *same = NULL;
1698   struct nexthop *nexthop;
1699   char buf1[BUFSIZ];
1700   char buf2[BUFSIZ];
1701
1702   /* Lookup table.  */
1703   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1704   if (! table)
1705     return 0;
1706
1707   /* Apply mask. */
1708   apply_mask_ipv4 (p);
1709
1710   if (IS_ZEBRA_DEBUG_KERNEL && gate)
1711     zlog_debug ("rib_delete_ipv4(): route delete %s/%d via %s ifindex %d",
1712                        inet_ntop (AF_INET, &p->prefix, buf1, BUFSIZ),
1713                        p->prefixlen,
1714                        inet_ntoa (*gate),
1715                        ifindex);
1716
1717   /* Lookup route node. */
1718   rn = route_node_lookup (table, (struct prefix *) p);
1719   if (! rn)
1720     {
1721       if (IS_ZEBRA_DEBUG_KERNEL)
1722         {
1723           if (gate)
1724             zlog_debug ("route %s/%d via %s ifindex %d doesn't exist in rib",
1725                        inet_ntop (AF_INET, &p->prefix, buf1, BUFSIZ),
1726                        p->prefixlen,
1727                        inet_ntop (AF_INET, gate, buf2, BUFSIZ),
1728                        ifindex);
1729           else
1730             zlog_debug ("route %s/%d ifindex %d doesn't exist in rib",
1731                        inet_ntop (AF_INET, &p->prefix, buf1, BUFSIZ),
1732                        p->prefixlen,
1733                        ifindex);
1734         }
1735       return ZEBRA_ERR_RTNOEXIST;
1736     }
1737
1738   /* Lookup same type route. */
1739   for (rib = rn->info; rib; rib = rib->next)
1740     {
1741       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1742         continue;
1743
1744       if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
1745         fib = rib;
1746
1747       if (rib->type != type)
1748         continue;
1749       if (rib->type == ZEBRA_ROUTE_CONNECT && (nexthop = rib->nexthop) &&
1750           nexthop->type == NEXTHOP_TYPE_IFINDEX && nexthop->ifindex == ifindex)
1751         {
1752           if (rib->refcnt)
1753             {
1754               rib->refcnt--;
1755               route_unlock_node (rn);
1756               route_unlock_node (rn);
1757               return 0;
1758             }
1759           same = rib;
1760           break;
1761         }
1762       /* Make sure that the route found has the same gateway. */
1763       else if (gate == NULL ||
1764                ((nexthop = rib->nexthop) &&
1765                 (IPV4_ADDR_SAME (&nexthop->gate.ipv4, gate) ||
1766                  IPV4_ADDR_SAME (&nexthop->rgate.ipv4, gate))))
1767         {
1768           same = rib;
1769           break;
1770         }
1771     }
1772
1773   /* If same type of route can't be found and this message is from
1774      kernel. */
1775   if (! same)
1776     {
1777       if (fib && type == ZEBRA_ROUTE_KERNEL)
1778         {
1779           /* Unset flags. */
1780           for (nexthop = fib->nexthop; nexthop; nexthop = nexthop->next)
1781             UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1782
1783           UNSET_FLAG (fib->flags, ZEBRA_FLAG_SELECTED);
1784         }
1785       else
1786         {
1787           if (IS_ZEBRA_DEBUG_KERNEL)
1788             {
1789               if (gate)
1790                 zlog_debug ("route %s/%d via %s ifindex %d type %d doesn't exist in rib",
1791                            inet_ntop (AF_INET, &p->prefix, buf1, BUFSIZ),
1792                            p->prefixlen,
1793                            inet_ntop (AF_INET, gate, buf2, BUFSIZ),
1794                            ifindex,
1795                            type);
1796               else
1797                 zlog_debug ("route %s/%d ifindex %d type %d doesn't exist in rib",
1798                            inet_ntop (AF_INET, &p->prefix, buf1, BUFSIZ),
1799                            p->prefixlen,
1800                            ifindex,
1801                            type);
1802             }
1803           route_unlock_node (rn);
1804           return ZEBRA_ERR_RTNOEXIST;
1805         }
1806     }
1807
1808   if (same)
1809     rib_delnode (rn, same);
1810
1811   route_unlock_node (rn);
1812   return 0;
1813 }
1814 \f
1815 /* Install static route into rib. */
1816 static void
1817 static_install_ipv4 (struct prefix *p, struct static_ipv4 *si)
1818 {
1819   struct rib *rib;
1820   struct route_node *rn;
1821   struct route_table *table;
1822
1823   /* Lookup table.  */
1824   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1825   if (! table)
1826     return;
1827
1828   /* Lookup existing route */
1829   rn = route_node_get (table, p);
1830   for (rib = rn->info; rib; rib = rib->next)
1831     {
1832        if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1833          continue;
1834
1835        if (rib->type == ZEBRA_ROUTE_STATIC && rib->distance == si->distance)
1836          break;
1837     }
1838
1839   if (rib)
1840     {
1841       /* Same distance static route is there.  Update it with new
1842          nexthop. */
1843       route_unlock_node (rn);
1844       switch (si->type)
1845         {
1846           case STATIC_IPV4_GATEWAY:
1847             nexthop_ipv4_add (rib, &si->gate.ipv4, NULL);
1848             break;
1849           case STATIC_IPV4_IFNAME:
1850             nexthop_ifname_add (rib, si->gate.ifname);
1851             break;
1852           case STATIC_IPV4_BLACKHOLE:
1853             nexthop_blackhole_add (rib);
1854             break;
1855         }
1856       rib_queue_add (&zebrad, rn);
1857     }
1858   else
1859     {
1860       /* This is new static route. */
1861       rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
1862
1863       rib->type = ZEBRA_ROUTE_STATIC;
1864       rib->distance = si->distance;
1865       rib->metric = 0;
1866       rib->nexthop_num = 0;
1867
1868       switch (si->type)
1869         {
1870           case STATIC_IPV4_GATEWAY:
1871             nexthop_ipv4_add (rib, &si->gate.ipv4, NULL);
1872             break;
1873           case STATIC_IPV4_IFNAME:
1874             nexthop_ifname_add (rib, si->gate.ifname);
1875             break;
1876           case STATIC_IPV4_BLACKHOLE:
1877             nexthop_blackhole_add (rib);
1878             break;
1879         }
1880
1881       /* Save the flags of this static routes (reject, blackhole) */
1882       rib->flags = si->flags;
1883
1884       /* Link this rib to the tree. */
1885       rib_addnode (rn, rib);
1886     }
1887 }
1888
1889 static int
1890 static_ipv4_nexthop_same (struct nexthop *nexthop, struct static_ipv4 *si)
1891 {
1892   if (nexthop->type == NEXTHOP_TYPE_IPV4
1893       && si->type == STATIC_IPV4_GATEWAY
1894       && IPV4_ADDR_SAME (&nexthop->gate.ipv4, &si->gate.ipv4))
1895     return 1;
1896   if (nexthop->type == NEXTHOP_TYPE_IFNAME
1897       && si->type == STATIC_IPV4_IFNAME
1898       && strcmp (nexthop->ifname, si->gate.ifname) == 0)
1899     return 1;
1900   if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE
1901       && si->type == STATIC_IPV4_BLACKHOLE)
1902     return 1;
1903   return 0;
1904 }
1905
1906 /* Uninstall static route from RIB. */
1907 static void
1908 static_uninstall_ipv4 (struct prefix *p, struct static_ipv4 *si)
1909 {
1910   struct route_node *rn;
1911   struct rib *rib;
1912   struct nexthop *nexthop;
1913   struct route_table *table;
1914
1915   /* Lookup table.  */
1916   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
1917   if (! table)
1918     return;
1919
1920   /* Lookup existing route with type and distance. */
1921   rn = route_node_lookup (table, p);
1922   if (! rn)
1923     return;
1924
1925   for (rib = rn->info; rib; rib = rib->next)
1926     {
1927       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
1928         continue;
1929
1930       if (rib->type == ZEBRA_ROUTE_STATIC && rib->distance == si->distance)
1931         break;
1932     }
1933
1934   if (! rib)
1935     {
1936       route_unlock_node (rn);
1937       return;
1938     }
1939
1940   /* Lookup nexthop. */
1941   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1942     if (static_ipv4_nexthop_same (nexthop, si))
1943       break;
1944
1945   /* Can't find nexthop. */
1946   if (! nexthop)
1947     {
1948       route_unlock_node (rn);
1949       return;
1950     }
1951
1952   /* Check nexthop. */
1953   if (rib->nexthop_num == 1)
1954     rib_delnode (rn, rib);
1955   else
1956     {
1957       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
1958         rib_uninstall (rn, rib);
1959       nexthop_delete (rib, nexthop);
1960       nexthop_free (nexthop);
1961       rib_queue_add (&zebrad, rn);
1962     }
1963   /* Unlock node. */
1964   route_unlock_node (rn);
1965 }
1966
1967 /* Add static route into static route configuration. */
1968 int
1969 static_add_ipv4 (struct prefix *p, struct in_addr *gate, const char *ifname,
1970                  u_char flags, u_char distance, u_int32_t vrf_id)
1971 {
1972   u_char type = 0;
1973   struct route_node *rn;
1974   struct static_ipv4 *si;
1975   struct static_ipv4 *pp;
1976   struct static_ipv4 *cp;
1977   struct static_ipv4 *update = NULL;
1978   struct route_table *stable;
1979
1980   /* Lookup table.  */
1981   stable = vrf_static_table (AFI_IP, SAFI_UNICAST, vrf_id);
1982   if (! stable)
1983     return -1;
1984
1985   /* Lookup static route prefix. */
1986   rn = route_node_get (stable, p);
1987
1988   /* Make flags. */
1989   if (gate)
1990     type = STATIC_IPV4_GATEWAY;
1991   else if (ifname)
1992     type = STATIC_IPV4_IFNAME;
1993   else
1994     type = STATIC_IPV4_BLACKHOLE;
1995
1996   /* Do nothing if there is a same static route.  */
1997   for (si = rn->info; si; si = si->next)
1998     {
1999       if (type == si->type
2000           && (! gate || IPV4_ADDR_SAME (gate, &si->gate.ipv4))
2001           && (! ifname || strcmp (ifname, si->gate.ifname) == 0))
2002         {
2003           if (distance == si->distance)
2004             {
2005               route_unlock_node (rn);
2006               return 0;
2007             }
2008           else
2009             update = si;
2010         }
2011     }
2012
2013   /* Distance changed.  */
2014   if (update)
2015     static_delete_ipv4 (p, gate, ifname, update->distance, vrf_id);
2016
2017   /* Make new static route structure. */
2018   si = XMALLOC (MTYPE_STATIC_IPV4, sizeof (struct static_ipv4));
2019   memset (si, 0, sizeof (struct static_ipv4));
2020
2021   si->type = type;
2022   si->distance = distance;
2023   si->flags = flags;
2024
2025   if (gate)
2026     si->gate.ipv4 = *gate;
2027   if (ifname)
2028     si->gate.ifname = XSTRDUP (0, ifname);
2029
2030   /* Add new static route information to the tree with sort by
2031      distance value and gateway address. */
2032   for (pp = NULL, cp = rn->info; cp; pp = cp, cp = cp->next)
2033     {
2034       if (si->distance < cp->distance)
2035         break;
2036       if (si->distance > cp->distance)
2037         continue;
2038       if (si->type == STATIC_IPV4_GATEWAY && cp->type == STATIC_IPV4_GATEWAY)
2039         {
2040           if (ntohl (si->gate.ipv4.s_addr) < ntohl (cp->gate.ipv4.s_addr))
2041             break;
2042           if (ntohl (si->gate.ipv4.s_addr) > ntohl (cp->gate.ipv4.s_addr))
2043             continue;
2044         }
2045     }
2046
2047   /* Make linked list. */
2048   if (pp)
2049     pp->next = si;
2050   else
2051     rn->info = si;
2052   if (cp)
2053     cp->prev = si;
2054   si->prev = pp;
2055   si->next = cp;
2056
2057   /* Install into rib. */
2058   static_install_ipv4 (p, si);
2059
2060   return 1;
2061 }
2062
2063 /* Delete static route from static route configuration. */
2064 int
2065 static_delete_ipv4 (struct prefix *p, struct in_addr *gate, const char *ifname,
2066                     u_char distance, u_int32_t vrf_id)
2067 {
2068   u_char type = 0;
2069   struct route_node *rn;
2070   struct static_ipv4 *si;
2071   struct route_table *stable;
2072
2073   /* Lookup table.  */
2074   stable = vrf_static_table (AFI_IP, SAFI_UNICAST, vrf_id);
2075   if (! stable)
2076     return -1;
2077
2078   /* Lookup static route prefix. */
2079   rn = route_node_lookup (stable, p);
2080   if (! rn)
2081     return 0;
2082
2083   /* Make flags. */
2084   if (gate)
2085     type = STATIC_IPV4_GATEWAY;
2086   else if (ifname)
2087     type = STATIC_IPV4_IFNAME;
2088   else
2089     type = STATIC_IPV4_BLACKHOLE;
2090
2091   /* Find same static route is the tree */
2092   for (si = rn->info; si; si = si->next)
2093     if (type == si->type
2094         && (! gate || IPV4_ADDR_SAME (gate, &si->gate.ipv4))
2095         && (! ifname || strcmp (ifname, si->gate.ifname) == 0))
2096       break;
2097
2098   /* Can't find static route. */
2099   if (! si)
2100     {
2101       route_unlock_node (rn);
2102       return 0;
2103     }
2104
2105   /* Install into rib. */
2106   static_uninstall_ipv4 (p, si);
2107
2108   /* Unlink static route from linked list. */
2109   if (si->prev)
2110     si->prev->next = si->next;
2111   else
2112     rn->info = si->next;
2113   if (si->next)
2114     si->next->prev = si->prev;
2115   route_unlock_node (rn);
2116
2117   /* Free static route configuration. */
2118   if (ifname)
2119     XFREE (0, si->gate.ifname);
2120   XFREE (MTYPE_STATIC_IPV4, si);
2121
2122   route_unlock_node (rn);
2123
2124   return 1;
2125 }
2126
2127 \f
2128 #ifdef HAVE_IPV6
2129 static int
2130 rib_bogus_ipv6 (int type, struct prefix_ipv6 *p,
2131                 struct in6_addr *gate, unsigned int ifindex, int table)
2132 {
2133   if (type == ZEBRA_ROUTE_CONNECT && IN6_IS_ADDR_UNSPECIFIED (&p->prefix)) {
2134 #if defined (MUSICA) || defined (LINUX)
2135     /* IN6_IS_ADDR_V4COMPAT(&p->prefix) */
2136     if (p->prefixlen == 96)
2137       return 0;
2138 #endif /* MUSICA */
2139     return 1;
2140   }
2141   if (type == ZEBRA_ROUTE_KERNEL && IN6_IS_ADDR_UNSPECIFIED (&p->prefix)
2142       && p->prefixlen == 96 && gate && IN6_IS_ADDR_UNSPECIFIED (gate))
2143     {
2144       kernel_delete_ipv6_old (p, gate, ifindex, 0, table);
2145       return 1;
2146     }
2147   return 0;
2148 }
2149
2150 int
2151 rib_add_ipv6 (int type, int flags, struct prefix_ipv6 *p,
2152               struct in6_addr *gate, unsigned int ifindex, u_int32_t vrf_id,
2153               u_int32_t metric, u_char distance)
2154 {
2155   struct rib *rib;
2156   struct rib *same = NULL;
2157   struct route_table *table;
2158   struct route_node *rn;
2159   struct nexthop *nexthop;
2160
2161   /* Lookup table.  */
2162   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
2163   if (! table)
2164     return 0;
2165
2166   /* Make sure mask is applied. */
2167   apply_mask_ipv6 (p);
2168
2169   /* Set default distance by route type. */
2170   if (!distance)
2171     distance = route_info[type].distance;
2172
2173   if (type == ZEBRA_ROUTE_BGP && CHECK_FLAG (flags, ZEBRA_FLAG_IBGP))
2174     distance = 200;
2175
2176   /* Filter bogus route. */
2177   if (rib_bogus_ipv6 (type, p, gate, ifindex, 0))
2178     return 0;
2179
2180   /* Lookup route node.*/
2181   rn = route_node_get (table, (struct prefix *) p);
2182
2183   /* If same type of route are installed, treat it as a implicit
2184      withdraw. */
2185   for (rib = rn->info; rib; rib = rib->next)
2186     {
2187       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
2188         continue;
2189
2190       if (rib->type != type)
2191         continue;
2192       if (rib->type != ZEBRA_ROUTE_CONNECT)
2193         {
2194           same = rib;
2195           break;
2196         }
2197       else if ((nexthop = rib->nexthop) &&
2198                nexthop->type == NEXTHOP_TYPE_IFINDEX &&
2199                nexthop->ifindex == ifindex)
2200         {
2201           rib->refcnt++;
2202           return 0;
2203         }
2204     }
2205
2206   /* Allocate new rib structure. */
2207   rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
2208
2209   rib->type = type;
2210   rib->distance = distance;
2211   rib->flags = flags;
2212   rib->metric = metric;
2213   rib->table = vrf_id;
2214   rib->nexthop_num = 0;
2215   rib->uptime = time (NULL);
2216
2217   /* Nexthop settings. */
2218   if (gate)
2219     {
2220       if (ifindex)
2221         nexthop_ipv6_ifindex_add (rib, gate, ifindex);
2222       else
2223         nexthop_ipv6_add (rib, gate);
2224     }
2225   else
2226     nexthop_ifindex_add (rib, ifindex);
2227
2228   /* If this route is kernel route, set FIB flag to the route. */
2229   if (type == ZEBRA_ROUTE_KERNEL || type == ZEBRA_ROUTE_CONNECT)
2230     for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
2231       SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
2232
2233   /* Link new rib to node.*/
2234   rib_addnode (rn, rib);
2235
2236   /* Free implicit route.*/
2237   if (same)
2238     rib_delnode (rn, same);
2239
2240   route_unlock_node (rn);
2241   return 0;
2242 }
2243
2244 /* XXX factor with rib_delete_ipv6 */
2245 int
2246 rib_delete_ipv6 (int type, int flags, struct prefix_ipv6 *p,
2247                  struct in6_addr *gate, unsigned int ifindex, u_int32_t vrf_id)
2248 {
2249   struct route_table *table;
2250   struct route_node *rn;
2251   struct rib *rib;
2252   struct rib *fib = NULL;
2253   struct rib *same = NULL;
2254   struct nexthop *nexthop;
2255   char buf1[BUFSIZ];
2256   char buf2[BUFSIZ];
2257
2258   /* Apply mask. */
2259   apply_mask_ipv6 (p);
2260
2261   /* Lookup table.  */
2262   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
2263   if (! table)
2264     return 0;
2265
2266   /* Lookup route node. */
2267   rn = route_node_lookup (table, (struct prefix *) p);
2268   if (! rn)
2269     {
2270       if (IS_ZEBRA_DEBUG_KERNEL)
2271         {
2272           if (gate)
2273             zlog_debug ("route %s/%d via %s ifindex %d doesn't exist in rib",
2274                        inet_ntop (AF_INET6, &p->prefix, buf1, BUFSIZ),
2275                        p->prefixlen,
2276                        inet_ntop (AF_INET6, gate, buf2, BUFSIZ),
2277                        ifindex);
2278           else
2279             zlog_debug ("route %s/%d ifindex %d doesn't exist in rib",
2280                        inet_ntop (AF_INET6, &p->prefix, buf1, BUFSIZ),
2281                        p->prefixlen,
2282                        ifindex);
2283         }
2284       return ZEBRA_ERR_RTNOEXIST;
2285     }
2286
2287   /* Lookup same type route. */
2288   for (rib = rn->info; rib; rib = rib->next)
2289     {
2290       if (CHECK_FLAG(rib->status, RIB_ENTRY_REMOVED))
2291         continue;
2292
2293       if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
2294         fib = rib;
2295
2296       if (rib->type != type)
2297         continue;
2298       if (rib->type == ZEBRA_ROUTE_CONNECT && (nexthop = rib->nexthop) &&
2299           nexthop->type == NEXTHOP_TYPE_IFINDEX && nexthop->ifindex == ifindex)
2300         {
2301           if (rib->refcnt)
2302             {
2303               rib->refcnt--;
2304               route_unlock_node (rn);
2305               route_unlock_node (rn);
2306               return 0;
2307             }
2308           same = rib;
2309           break;
2310         }
2311       /* Make sure that the route found has the same gateway. */
2312       else if (gate == NULL ||
2313                ((nexthop = rib->nexthop) &&
2314                 (IPV6_ADDR_SAME (&nexthop->gate.ipv6, gate) ||
2315                  IPV6_ADDR_SAME (&nexthop->rgate.ipv6, gate))))
2316         {
2317           same = rib;
2318           break;
2319         }
2320     }
2321
2322   /* If same type of route can't be found and this message is from
2323      kernel. */
2324   if (! same)
2325     {
2326       if (fib && type == ZEBRA_ROUTE_KERNEL)
2327         {
2328           /* Unset flags. */
2329           for (nexthop = fib->nexthop; nexthop; nexthop = nexthop->next)
2330             UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
2331
2332           UNSET_FLAG (fib->flags, ZEBRA_FLAG_SELECTED);
2333         }
2334       else
2335         {
2336           if (IS_ZEBRA_DEBUG_KERNEL)
2337             {
2338               if (gate)
2339                 zlog_debug ("route %s/%d via %s ifindex %d type %d doesn't exist in rib",
2340                            inet_ntop (AF_INET6, &p->prefix, buf1, BUFSIZ),
2341                            p->prefixlen,
2342                            inet_ntop (AF_INET6, gate, buf2, BUFSIZ),
2343                            ifindex,
2344                            type);
2345               else
2346                 zlog_debug ("route %s/%d ifindex %d type %d doesn't exist in rib",
2347                            inet_ntop (AF_INET6, &p->prefix, buf1, BUFSIZ),
2348                            p->prefixlen,
2349                            ifindex,
2350                            type);
2351             }
2352           route_unlock_node (rn);
2353           return ZEBRA_ERR_RTNOEXIST;
2354         }
2355     }
2356
2357   if (same)
2358     rib_delnode (rn, same);
2359
2360   route_unlock_node (rn);
2361   return 0;
2362 }
2363 \f
2364 /* Install static route into rib. */
2365 static void
2366 static_install_ipv6 (struct prefix *p, struct static_ipv6 *si)
2367 {
2368   struct rib *rib;
2369   struct route_table *table;
2370   struct route_node *rn;
2371
2372   /* Lookup table.  */
2373   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
2374   if (! table)
2375     return;
2376
2377   /* Lookup existing route */
2378   rn = route_node_get (table, p);
2379   for (rib = rn->info; rib; rib = rib->next)
2380     {
2381       if (CHECK_FLAG(rib->status, RIB_ENTRY_REMOVED))
2382         continue;
2383
2384       if (rib->type == ZEBRA_ROUTE_STATIC && rib->distance == si->distance)
2385         break;
2386     }
2387
2388   if (rib)
2389     {
2390       /* Same distance static route is there.  Update it with new
2391          nexthop. */
2392       route_unlock_node (rn);
2393
2394       switch (si->type)
2395         {
2396         case STATIC_IPV6_GATEWAY:
2397           nexthop_ipv6_add (rib, &si->ipv6);
2398           break;
2399         case STATIC_IPV6_IFNAME:
2400           nexthop_ifname_add (rib, si->ifname);
2401           break;
2402         case STATIC_IPV6_GATEWAY_IFNAME:
2403           nexthop_ipv6_ifname_add (rib, &si->ipv6, si->ifname);
2404           break;
2405         }
2406       rib_queue_add (&zebrad, rn);
2407     }
2408   else
2409     {
2410       /* This is new static route. */
2411       rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
2412
2413       rib->type = ZEBRA_ROUTE_STATIC;
2414       rib->distance = si->distance;
2415       rib->metric = 0;
2416       rib->nexthop_num = 0;
2417
2418       switch (si->type)
2419         {
2420         case STATIC_IPV6_GATEWAY:
2421           nexthop_ipv6_add (rib, &si->ipv6);
2422           break;
2423         case STATIC_IPV6_IFNAME:
2424           nexthop_ifname_add (rib, si->ifname);
2425           break;
2426         case STATIC_IPV6_GATEWAY_IFNAME:
2427           nexthop_ipv6_ifname_add (rib, &si->ipv6, si->ifname);
2428           break;
2429         }
2430
2431       /* Save the flags of this static routes (reject, blackhole) */
2432       rib->flags = si->flags;
2433
2434       /* Link this rib to the tree. */
2435       rib_addnode (rn, rib);
2436     }
2437 }
2438
2439 static int
2440 static_ipv6_nexthop_same (struct nexthop *nexthop, struct static_ipv6 *si)
2441 {
2442   if (nexthop->type == NEXTHOP_TYPE_IPV6
2443       && si->type == STATIC_IPV6_GATEWAY
2444       && IPV6_ADDR_SAME (&nexthop->gate.ipv6, &si->ipv6))
2445     return 1;
2446   if (nexthop->type == NEXTHOP_TYPE_IFNAME
2447       && si->type == STATIC_IPV6_IFNAME
2448       && strcmp (nexthop->ifname, si->ifname) == 0)
2449     return 1;
2450   if (nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
2451       && si->type == STATIC_IPV6_GATEWAY_IFNAME
2452       && IPV6_ADDR_SAME (&nexthop->gate.ipv6, &si->ipv6)
2453       && strcmp (nexthop->ifname, si->ifname) == 0)
2454     return 1;
2455   return 0;
2456 }
2457
2458 static void
2459 static_uninstall_ipv6 (struct prefix *p, struct static_ipv6 *si)
2460 {
2461   struct route_table *table;
2462   struct route_node *rn;
2463   struct rib *rib;
2464   struct nexthop *nexthop;
2465
2466   /* Lookup table.  */
2467   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
2468   if (! table)
2469     return;
2470
2471   /* Lookup existing route with type and distance. */
2472   rn = route_node_lookup (table, (struct prefix *) p);
2473   if (! rn)
2474     return;
2475
2476   for (rib = rn->info; rib; rib = rib->next)
2477     {
2478       if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
2479         continue;
2480
2481       if (rib->type == ZEBRA_ROUTE_STATIC && rib->distance == si->distance)
2482         break;
2483     }
2484
2485   if (! rib)
2486     {
2487       route_unlock_node (rn);
2488       return;
2489     }
2490
2491   /* Lookup nexthop. */
2492   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
2493     if (static_ipv6_nexthop_same (nexthop, si))
2494       break;
2495
2496   /* Can't find nexthop. */
2497   if (! nexthop)
2498     {
2499       route_unlock_node (rn);
2500       return;
2501     }
2502
2503   /* Check nexthop. */
2504   if (rib->nexthop_num == 1)
2505     {
2506       rib_delnode (rn, rib);
2507     }
2508   else
2509     {
2510       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
2511         rib_uninstall (rn, rib);
2512       nexthop_delete (rib, nexthop);
2513       nexthop_free (nexthop);
2514       rib_queue_add (&zebrad, rn);
2515     }
2516   /* Unlock node. */
2517   route_unlock_node (rn);
2518 }
2519
2520 /* Add static route into static route configuration. */
2521 int
2522 static_add_ipv6 (struct prefix *p, u_char type, struct in6_addr *gate,
2523                  const char *ifname, u_char flags, u_char distance,
2524                  u_int32_t vrf_id)
2525 {
2526   struct route_node *rn;
2527   struct static_ipv6 *si;
2528   struct static_ipv6 *pp;
2529   struct static_ipv6 *cp;
2530   struct route_table *stable;
2531
2532   /* Lookup table.  */
2533   stable = vrf_static_table (AFI_IP6, SAFI_UNICAST, vrf_id);
2534   if (! stable)
2535     return -1;
2536
2537   if (!gate &&
2538       (type == STATIC_IPV6_GATEWAY || type == STATIC_IPV6_GATEWAY_IFNAME))
2539     return -1;
2540
2541   if (!ifname &&
2542       (type == STATIC_IPV6_GATEWAY_IFNAME || type == STATIC_IPV6_IFNAME))
2543     return -1;
2544
2545   /* Lookup static route prefix. */
2546   rn = route_node_get (stable, p);
2547
2548   /* Do nothing if there is a same static route.  */
2549   for (si = rn->info; si; si = si->next)
2550     {
2551       if (distance == si->distance
2552           && type == si->type
2553           && (! gate || IPV6_ADDR_SAME (gate, &si->ipv6))
2554           && (! ifname || strcmp (ifname, si->ifname) == 0))
2555         {
2556           route_unlock_node (rn);
2557           return 0;
2558         }
2559     }
2560
2561   /* Make new static route structure. */
2562   si = XMALLOC (MTYPE_STATIC_IPV6, sizeof (struct static_ipv6));
2563   memset (si, 0, sizeof (struct static_ipv6));
2564
2565   si->type = type;
2566   si->distance = distance;
2567   si->flags = flags;
2568
2569   switch (type)
2570     {
2571     case STATIC_IPV6_GATEWAY:
2572       si->ipv6 = *gate;
2573       break;
2574     case STATIC_IPV6_IFNAME:
2575       si->ifname = XSTRDUP (0, ifname);
2576       break;
2577     case STATIC_IPV6_GATEWAY_IFNAME:
2578       si->ipv6 = *gate;
2579       si->ifname = XSTRDUP (0, ifname);
2580       break;
2581     }
2582
2583   /* Add new static route information to the tree with sort by
2584      distance value and gateway address. */
2585   for (pp = NULL, cp = rn->info; cp; pp = cp, cp = cp->next)
2586     {
2587       if (si->distance < cp->distance)
2588         break;
2589       if (si->distance > cp->distance)
2590         continue;
2591     }
2592
2593   /* Make linked list. */
2594   if (pp)
2595     pp->next = si;
2596   else
2597     rn->info = si;
2598   if (cp)
2599     cp->prev = si;
2600   si->prev = pp;
2601   si->next = cp;
2602
2603   /* Install into rib. */
2604   static_install_ipv6 (p, si);
2605
2606   return 1;
2607 }
2608
2609 /* Delete static route from static route configuration. */
2610 int
2611 static_delete_ipv6 (struct prefix *p, u_char type, struct in6_addr *gate,
2612                     const char *ifname, u_char distance, u_int32_t vrf_id)
2613 {
2614   struct route_node *rn;
2615   struct static_ipv6 *si;
2616   struct route_table *stable;
2617
2618   /* Lookup table.  */
2619   stable = vrf_static_table (AFI_IP6, SAFI_UNICAST, vrf_id);
2620   if (! stable)
2621     return -1;
2622
2623   /* Lookup static route prefix. */
2624   rn = route_node_lookup (stable, p);
2625   if (! rn)
2626     return 0;
2627
2628   /* Find same static route is the tree */
2629   for (si = rn->info; si; si = si->next)
2630     if (distance == si->distance
2631         && type == si->type
2632         && (! gate || IPV6_ADDR_SAME (gate, &si->ipv6))
2633         && (! ifname || strcmp (ifname, si->ifname) == 0))
2634       break;
2635
2636   /* Can't find static route. */
2637   if (! si)
2638     {
2639       route_unlock_node (rn);
2640       return 0;
2641     }
2642
2643   /* Install into rib. */
2644   static_uninstall_ipv6 (p, si);
2645
2646   /* Unlink static route from linked list. */
2647   if (si->prev)
2648     si->prev->next = si->next;
2649   else
2650     rn->info = si->next;
2651   if (si->next)
2652     si->next->prev = si->prev;
2653
2654   /* Free static route configuration. */
2655   if (ifname)
2656     XFREE (0, si->ifname);
2657   XFREE (MTYPE_STATIC_IPV6, si);
2658
2659   return 1;
2660 }
2661 #endif /* HAVE_IPV6 */
2662 \f
2663 /* RIB update function. */
2664 void
2665 rib_update (void)
2666 {
2667   struct route_node *rn;
2668   struct route_table *table;
2669
2670   table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
2671   if (table)
2672     for (rn = route_top (table); rn; rn = route_next (rn))
2673       if (rn->info)
2674         rib_queue_add (&zebrad, rn);
2675
2676   table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
2677   if (table)
2678     for (rn = route_top (table); rn; rn = route_next (rn))
2679       if (rn->info)
2680         rib_queue_add (&zebrad, rn);
2681 }
2682
2683 /* Interface goes up. */
2684 static void
2685 rib_if_up (struct interface *ifp)
2686 {
2687   rib_update ();
2688 }
2689
2690 /* Interface goes down. */
2691 static void
2692 rib_if_down (struct interface *ifp)
2693 {
2694   rib_update ();
2695 }
2696 \f
2697 /* Remove all routes which comes from non main table.  */
2698 static void
2699 rib_weed_table (struct route_table *table)
2700 {
2701   struct route_node *rn;
2702   struct rib *rib;
2703   struct rib *next;
2704
2705   if (table)
2706     for (rn = route_top (table); rn; rn = route_next (rn))
2707       for (rib = rn->info; rib; rib = next)
2708         {
2709           next = rib->next;
2710
2711           if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
2712             continue;
2713
2714           if (rib->table != zebrad.rtm_table_default &&
2715               rib->table != RT_TABLE_MAIN)
2716             rib_delnode (rn, rib);
2717         }
2718 }
2719
2720 /* Delete all routes from non main table. */
2721 void
2722 rib_weed_tables (void)
2723 {
2724   rib_weed_table (vrf_table (AFI_IP, SAFI_UNICAST, 0));
2725   rib_weed_table (vrf_table (AFI_IP6, SAFI_UNICAST, 0));
2726 }
2727 \f
2728 /* Delete self installed routes after zebra is relaunched.  */
2729 static void
2730 rib_sweep_table (struct route_table *table)
2731 {
2732   struct route_node *rn;
2733   struct rib *rib;
2734   struct rib *next;
2735   int ret = 0;
2736
2737   if (table)
2738     for (rn = route_top (table); rn; rn = route_next (rn))
2739       for (rib = rn->info; rib; rib = next)
2740         {
2741           next = rib->next;
2742
2743           if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
2744             continue;
2745
2746           if (rib->type == ZEBRA_ROUTE_KERNEL &&
2747               CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELFROUTE))
2748             {
2749               ret = rib_uninstall_kernel (rn, rib);
2750               if (! ret)
2751                 rib_delnode (rn, rib);
2752             }
2753         }
2754 }
2755
2756 /* Sweep all RIB tables.  */
2757 void
2758 rib_sweep_route (void)
2759 {
2760   rib_sweep_table (vrf_table (AFI_IP, SAFI_UNICAST, 0));
2761   rib_sweep_table (vrf_table (AFI_IP6, SAFI_UNICAST, 0));
2762 }
2763 \f
2764 /* Close RIB and clean up kernel routes. */
2765 static void
2766 rib_close_table (struct route_table *table)
2767 {
2768   struct route_node *rn;
2769   struct rib *rib;
2770
2771   if (table)
2772     for (rn = route_top (table); rn; rn = route_next (rn))
2773       for (rib = rn->info; rib; rib = rib->next)
2774         {
2775           if (! RIB_SYSTEM_ROUTE (rib)
2776               && CHECK_FLAG (rib->flags, ZEBRA_FLAG_SELECTED))
2777             rib_uninstall_kernel (rn, rib);
2778         }
2779 }
2780
2781 /* Close all RIB tables.  */
2782 void
2783 rib_close (void)
2784 {
2785   rib_close_table (vrf_table (AFI_IP, SAFI_UNICAST, 0));
2786   rib_close_table (vrf_table (AFI_IP6, SAFI_UNICAST, 0));
2787 }
2788 \f
2789 /* Routing information base initialize. */
2790 void
2791 rib_init (void)
2792 {
2793   rib_queue_init (&zebrad);
2794   /* VRF initialization.  */
2795   vrf_init ();
2796 }