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