Annotation of embedaddon/quagga/ospfd/ospf_ase.c, revision 1.1
1.1 ! misho 1: /*
! 2: * OSPF AS external route calculation.
! 3: * Copyright (C) 1999, 2000 Alex Zinin, Toshiaki Takada
! 4: *
! 5: * This file is part of GNU Zebra.
! 6: *
! 7: * GNU Zebra is free software; you can redistribute it and/or modify it
! 8: * under the terms of the GNU General Public License as published by the
! 9: * Free Software Foundation; either version 2, or (at your option) any
! 10: * later version.
! 11: *
! 12: * GNU Zebra is distributed in the hope that it will be useful, but
! 13: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 15: * General Public License for more details.
! 16: *
! 17: * You should have received a copy of the GNU General Public License
! 18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 20: * 02111-1307, USA.
! 21: */
! 22:
! 23: #include <zebra.h>
! 24:
! 25: #include "thread.h"
! 26: #include "memory.h"
! 27: #include "hash.h"
! 28: #include "linklist.h"
! 29: #include "prefix.h"
! 30: #include "if.h"
! 31: #include "table.h"
! 32: #include "vty.h"
! 33: #include "log.h"
! 34:
! 35: #include "ospfd/ospfd.h"
! 36: #include "ospfd/ospf_interface.h"
! 37: #include "ospfd/ospf_ism.h"
! 38: #include "ospfd/ospf_asbr.h"
! 39: #include "ospfd/ospf_lsa.h"
! 40: #include "ospfd/ospf_lsdb.h"
! 41: #include "ospfd/ospf_neighbor.h"
! 42: #include "ospfd/ospf_nsm.h"
! 43: #include "ospfd/ospf_spf.h"
! 44: #include "ospfd/ospf_route.h"
! 45: #include "ospfd/ospf_ase.h"
! 46: #include "ospfd/ospf_zebra.h"
! 47: #include "ospfd/ospf_dump.h"
! 48:
! 49: struct ospf_route *
! 50: ospf_find_asbr_route (struct ospf *ospf,
! 51: struct route_table *rtrs, struct prefix_ipv4 *asbr)
! 52: {
! 53: struct route_node *rn;
! 54: struct ospf_route *or, *best = NULL;
! 55: struct listnode *node;
! 56: struct list *chosen;
! 57:
! 58: /* Sanity check. */
! 59: if (rtrs == NULL)
! 60: return NULL;
! 61:
! 62: rn = route_node_lookup (rtrs, (struct prefix *) asbr);
! 63: if (! rn)
! 64: return NULL;
! 65:
! 66: route_unlock_node (rn);
! 67:
! 68: chosen = list_new ();
! 69:
! 70: /* First try to find intra-area non-bb paths. */
! 71: if (!CHECK_FLAG (ospf->config, OSPF_RFC1583_COMPATIBLE))
! 72: for (ALL_LIST_ELEMENTS_RO ((struct list *) rn->info, node, or))
! 73: if (or->cost < OSPF_LS_INFINITY)
! 74: if (!OSPF_IS_AREA_ID_BACKBONE (or->u.std.area_id) &&
! 75: or->path_type == OSPF_PATH_INTRA_AREA)
! 76: listnode_add (chosen, or);
! 77:
! 78: /* If none is found -- look through all. */
! 79: if (listcount (chosen) == 0)
! 80: {
! 81: list_free (chosen);
! 82: chosen = rn->info;
! 83: }
! 84:
! 85: /* Now find the route with least cost. */
! 86: for (ALL_LIST_ELEMENTS_RO (chosen, node, or))
! 87: if (or->cost < OSPF_LS_INFINITY)
! 88: {
! 89: if (best == NULL)
! 90: best = or;
! 91: else if (best->cost > or->cost)
! 92: best = or;
! 93: else if (best->cost == or->cost &&
! 94: IPV4_ADDR_CMP (&best->u.std.area_id,
! 95: &or->u.std.area_id) < 0)
! 96: best = or;
! 97: }
! 98:
! 99: if (chosen != rn->info)
! 100: list_delete (chosen);
! 101:
! 102: return best;
! 103: }
! 104:
! 105: struct ospf_route *
! 106: ospf_find_asbr_route_through_area (struct route_table *rtrs,
! 107: struct prefix_ipv4 *asbr,
! 108: struct ospf_area *area)
! 109: {
! 110: struct route_node *rn;
! 111:
! 112: /* Sanity check. */
! 113: if (rtrs == NULL)
! 114: return NULL;
! 115:
! 116: rn = route_node_lookup (rtrs, (struct prefix *) asbr);
! 117:
! 118: if (rn)
! 119: {
! 120: struct listnode *node;
! 121: struct ospf_route *or;
! 122:
! 123: route_unlock_node (rn);
! 124:
! 125: for (ALL_LIST_ELEMENTS_RO ((struct list *) rn->info, node, or))
! 126: if (IPV4_ADDR_SAME (&or->u.std.area_id, &area->area_id))
! 127: return or;
! 128: }
! 129:
! 130: return NULL;
! 131: }
! 132:
! 133: static void
! 134: ospf_ase_complete_direct_routes (struct ospf_route *ro, struct in_addr nexthop)
! 135: {
! 136: struct listnode *node;
! 137: struct ospf_path *op;
! 138: struct interface *ifp;
! 139:
! 140: for (ALL_LIST_ELEMENTS_RO (ro->paths, node, op))
! 141: if (op->nexthop.s_addr == 0)
! 142: op->nexthop.s_addr = nexthop.s_addr;
! 143: }
! 144:
! 145: static int
! 146: ospf_ase_forward_address_check (struct ospf *ospf, struct in_addr fwd_addr)
! 147: {
! 148: struct listnode *ifn;
! 149: struct ospf_interface *oi;
! 150:
! 151: for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, ifn, oi))
! 152: if (if_is_operative (oi->ifp))
! 153: if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
! 154: if (IPV4_ADDR_SAME (&oi->address->u.prefix4, &fwd_addr))
! 155: return 0;
! 156:
! 157: return 1;
! 158: }
! 159:
! 160: #if 0
! 161: /* Calculate ASBR route. */
! 162: static struct ospf_route *
! 163: ospf_ase_calculate_asbr_route (struct ospf *ospf,
! 164: struct route_table *rt_network,
! 165: struct route_table *rt_router,
! 166: struct as_external_lsa *al)
! 167: {
! 168: struct prefix_ipv4 asbr;
! 169: struct ospf_route *asbr_route;
! 170: struct route_node *rn;
! 171:
! 172: /* Find ASBR route from Router routing table. */
! 173: asbr.family = AF_INET;
! 174: asbr.prefix = al->header.adv_router;
! 175: asbr.prefixlen = IPV4_MAX_BITLEN;
! 176: apply_mask_ipv4 (&asbr);
! 177:
! 178: asbr_route = ospf_find_asbr_route (ospf, rt_router, &asbr);
! 179:
! 180: if (asbr_route == NULL)
! 181: {
! 182: if (IS_DEBUG_OSPF (lsa, LSA))
! 183: zlog_debug ("ospf_ase_calculate(): Route to ASBR %s not found",
! 184: inet_ntoa (asbr.prefix));
! 185: return NULL;
! 186: }
! 187:
! 188: if (!(asbr_route->u.std.flags & ROUTER_LSA_EXTERNAL))
! 189: {
! 190: if (IS_DEBUG_OSPF (lsa, LSA))
! 191: zlog_debug ("ospf_ase_calculate(): Originating router is not an ASBR");
! 192: return NULL;
! 193: }
! 194:
! 195: if (al->e[0].fwd_addr.s_addr != 0)
! 196: {
! 197: if (IS_DEBUG_OSPF (lsa, LSA))
! 198: zlog_debug ("ospf_ase_calculate(): "
! 199: "Forwarding address is not 0.0.0.0.");
! 200:
! 201: if (! ospf_ase_forward_address_check (ospf, al->e[0].fwd_addr))
! 202: {
! 203: if (IS_DEBUG_OSPF (lsa, LSA))
! 204: zlog_debug ("ospf_ase_calculate(): "
! 205: "Forwarding address is one of our addresses, Ignore.");
! 206: return NULL;
! 207: }
! 208:
! 209: if (IS_DEBUG_OSPF (lsa, LSA))
! 210: zlog_debug ("ospf_ase_calculate(): "
! 211: "Looking up in the Network Routing Table.");
! 212:
! 213: /* Looking up the path to the fwd_addr from Network route. */
! 214: asbr.family = AF_INET;
! 215: asbr.prefix = al->e[0].fwd_addr;
! 216: asbr.prefixlen = IPV4_MAX_BITLEN;
! 217:
! 218: rn = route_node_match (rt_network, (struct prefix *) &asbr);
! 219:
! 220: if (rn == NULL)
! 221: {
! 222: if (IS_DEBUG_OSPF (lsa, LSA))
! 223: zlog_debug ("ospf_ase_calculate(): "
! 224: "Couldn't find a route to the forwarding address.");
! 225: return NULL;
! 226: }
! 227:
! 228: route_unlock_node (rn);
! 229:
! 230: if ((asbr_route = rn->info) == NULL)
! 231: {
! 232: if (IS_DEBUG_OSPF (lsa, LSA))
! 233: zlog_debug ("ospf_ase_calculate(): "
! 234: "Somehow OSPF route to ASBR is lost");
! 235: return NULL;
! 236: }
! 237: }
! 238:
! 239: return asbr_route;
! 240: }
! 241: #endif
! 242:
! 243: static struct ospf_route *
! 244: ospf_ase_calculate_new_route (struct ospf_lsa *lsa,
! 245: struct ospf_route *asbr_route, u_int32_t metric)
! 246: {
! 247: struct as_external_lsa *al;
! 248: struct ospf_route *new;
! 249:
! 250: al = (struct as_external_lsa *) lsa->data;
! 251:
! 252: new = ospf_route_new ();
! 253:
! 254: /* Set redistributed type -- does make sense? */
! 255: /* new->type = type; */
! 256: new->id = al->header.id;
! 257: new->mask = al->mask;
! 258:
! 259: if (!IS_EXTERNAL_METRIC (al->e[0].tos))
! 260: {
! 261: if (IS_DEBUG_OSPF (lsa, LSA))
! 262: zlog_debug ("Route[External]: type-1 created.");
! 263: new->path_type = OSPF_PATH_TYPE1_EXTERNAL;
! 264: new->cost = asbr_route->cost + metric; /* X + Y */
! 265: }
! 266: else
! 267: {
! 268: if (IS_DEBUG_OSPF (lsa, LSA))
! 269: zlog_debug ("Route[External]: type-2 created.");
! 270: new->path_type = OSPF_PATH_TYPE2_EXTERNAL;
! 271: new->cost = asbr_route->cost; /* X */
! 272: new->u.ext.type2_cost = metric; /* Y */
! 273: }
! 274:
! 275: new->type = OSPF_DESTINATION_NETWORK;
! 276: new->u.ext.origin = lsa;
! 277: new->u.ext.tag = ntohl (al->e[0].route_tag);
! 278: new->u.ext.asbr = asbr_route;
! 279:
! 280: assert (new != asbr_route);
! 281:
! 282: return new;
! 283: }
! 284:
! 285: #define OSPF_ASE_CALC_INTERVAL 1
! 286:
! 287: int
! 288: ospf_ase_calculate_route (struct ospf *ospf, struct ospf_lsa * lsa)
! 289: {
! 290: u_int32_t metric;
! 291: struct as_external_lsa *al;
! 292: struct ospf_route *asbr_route;
! 293: struct prefix_ipv4 asbr, p;
! 294: struct route_node *rn;
! 295: struct ospf_route *new, *or;
! 296: int ret;
! 297:
! 298: assert (lsa);
! 299: al = (struct as_external_lsa *) lsa->data;
! 300:
! 301: if (lsa->data->type == OSPF_AS_NSSA_LSA)
! 302: if (IS_DEBUG_OSPF_NSSA)
! 303: zlog_debug ("ospf_ase_calc(): Processing Type-7");
! 304:
! 305: /* Stay away from any Local Translated Type-7 LSAs */
! 306: if (CHECK_FLAG (lsa->flags, OSPF_LSA_LOCAL_XLT))
! 307: {
! 308: if (IS_DEBUG_OSPF_NSSA)
! 309: zlog_debug ("ospf_ase_calc(): Rejecting Local Xlt'd");
! 310: return 0;
! 311: }
! 312:
! 313: if (IS_DEBUG_OSPF (lsa, LSA))
! 314: zlog_debug ("Route[External]: Calculate AS-external-LSA to %s/%d",
! 315: inet_ntoa (al->header.id), ip_masklen (al->mask));
! 316: /* (1) If the cost specified by the LSA is LSInfinity, or if the
! 317: LSA's LS age is equal to MaxAge, then examine the next LSA. */
! 318: if ((metric = GET_METRIC (al->e[0].metric)) >= OSPF_LS_INFINITY)
! 319: {
! 320: if (IS_DEBUG_OSPF (lsa, LSA))
! 321: zlog_debug ("Route[External]: Metric is OSPF_LS_INFINITY");
! 322: return 0;
! 323: }
! 324: if (IS_LSA_MAXAGE (lsa))
! 325: {
! 326: if (IS_DEBUG_OSPF (lsa, LSA))
! 327: zlog_debug ("Route[External]: AS-external-LSA is MAXAGE");
! 328: return 0;
! 329: }
! 330:
! 331: /* (2) If the LSA was originated by the calculating router itself,
! 332: examine the next LSA. */
! 333: if (IS_LSA_SELF (lsa))
! 334: {
! 335: if (IS_DEBUG_OSPF (lsa, LSA))
! 336: zlog_debug ("Route[External]: AS-external-LSA is self originated");
! 337: return 0;
! 338: }
! 339:
! 340: /* (3) Call the destination described by the LSA N. N's address is
! 341: obtained by masking the LSA's Link State ID with the
! 342: network/subnet mask contained in the body of the LSA. Look
! 343: up the routing table entries (potentially one per attached
! 344: area) for the AS boundary router (ASBR) that originated the
! 345: LSA. If no entries exist for router ASBR (i.e., ASBR is
! 346: unreachable), do nothing with this LSA and consider the next
! 347: in the list. */
! 348:
! 349: asbr.family = AF_INET;
! 350: asbr.prefix = al->header.adv_router;
! 351: asbr.prefixlen = IPV4_MAX_BITLEN;
! 352: apply_mask_ipv4 (&asbr);
! 353:
! 354: asbr_route = ospf_find_asbr_route (ospf, ospf->new_rtrs, &asbr);
! 355: if (asbr_route == NULL)
! 356: {
! 357: if (IS_DEBUG_OSPF (lsa, LSA))
! 358: zlog_debug ("Route[External]: Can't find originating ASBR route");
! 359: return 0;
! 360: }
! 361: if (!(asbr_route->u.std.flags & ROUTER_LSA_EXTERNAL))
! 362: {
! 363: if (IS_DEBUG_OSPF (lsa, LSA))
! 364: zlog_debug ("Route[External]: Originating router is not an ASBR");
! 365: return 0;
! 366: }
! 367:
! 368: /* Else, this LSA describes an AS external path to destination
! 369: N. Examine the forwarding address specified in the AS-
! 370: external-LSA. This indicates the IP address to which
! 371: packets for the destination should be forwarded. */
! 372:
! 373: if (al->e[0].fwd_addr.s_addr == 0)
! 374: {
! 375: /* If the forwarding address is set to 0.0.0.0, packets should
! 376: be sent to the ASBR itself. Among the multiple routing table
! 377: entries for the ASBR, select the preferred entry as follows.
! 378: If RFC1583Compatibility is set to "disabled", prune the set
! 379: of routing table entries for the ASBR as described in
! 380: Section 16.4.1. In any case, among the remaining routing
! 381: table entries, select the routing table entry with the least
! 382: cost; when there are multiple least cost routing table
! 383: entries the entry whose associated area has the largest OSPF
! 384: Area ID (when considered as an unsigned 32-bit integer) is
! 385: chosen. */
! 386:
! 387: /* asbr_route already contains the requested route */
! 388: }
! 389: else
! 390: {
! 391: /* If the forwarding address is non-zero, look up the
! 392: forwarding address in the routing table.[24] The matching
! 393: routing table entry must specify an intra-area or inter-area
! 394: path; if no such path exists, do nothing with the LSA and
! 395: consider the next in the list. */
! 396: if (! ospf_ase_forward_address_check (ospf, al->e[0].fwd_addr))
! 397: {
! 398: if (IS_DEBUG_OSPF (lsa, LSA))
! 399: zlog_debug ("Route[External]: Forwarding address is our router "
! 400: "address");
! 401: return 0;
! 402: }
! 403:
! 404: asbr.family = AF_INET;
! 405: asbr.prefix = al->e[0].fwd_addr;
! 406: asbr.prefixlen = IPV4_MAX_BITLEN;
! 407:
! 408: rn = route_node_match (ospf->new_table, (struct prefix *) &asbr);
! 409:
! 410: if (rn == NULL || (asbr_route = rn->info) == NULL)
! 411: {
! 412: if (IS_DEBUG_OSPF (lsa, LSA))
! 413: zlog_debug ("Route[External]: Can't find route to forwarding "
! 414: "address");
! 415: if (rn)
! 416: route_unlock_node (rn);
! 417: return 0;
! 418: }
! 419:
! 420: route_unlock_node (rn);
! 421: }
! 422:
! 423: /* (4) Let X be the cost specified by the preferred routing table
! 424: entry for the ASBR/forwarding address, and Y the cost
! 425: specified in the LSA. X is in terms of the link state
! 426: metric, and Y is a type 1 or 2 external metric. */
! 427:
! 428:
! 429: /* (5) Look up the routing table entry for the destination N. If
! 430: no entry exists for N, install the AS external path to N,
! 431: with next hop equal to the list of next hops to the
! 432: forwarding address, and advertising router equal to ASBR.
! 433: If the external metric type is 1, then the path-type is set
! 434: to type 1 external and the cost is equal to X+Y. If the
! 435: external metric type is 2, the path-type is set to type 2
! 436: external, the link state component of the route's cost is X,
! 437: and the type 2 cost is Y. */
! 438: new = ospf_ase_calculate_new_route (lsa, asbr_route, metric);
! 439:
! 440: /* (6) Compare the AS external path described by the LSA with the
! 441: existing paths in N's routing table entry, as follows. If
! 442: the new path is preferred, it replaces the present paths in
! 443: N's routing table entry. If the new path is of equal
! 444: preference, it is added to N's routing table entry's list of
! 445: paths. */
! 446:
! 447: /* Set prefix. */
! 448: p.family = AF_INET;
! 449: p.prefix = al->header.id;
! 450: p.prefixlen = ip_masklen (al->mask);
! 451:
! 452: /* if there is a Intra/Inter area route to the N
! 453: do not install external route */
! 454: if ((rn = route_node_lookup (ospf->new_table,
! 455: (struct prefix *) &p)))
! 456: {
! 457: route_unlock_node(rn);
! 458: if (rn->info == NULL)
! 459: zlog_info ("Route[External]: rn->info NULL");
! 460: if (new)
! 461: ospf_route_free (new);
! 462: return 0;
! 463: }
! 464: /* Find a route to the same dest */
! 465: /* If there is no route, create new one. */
! 466: if ((rn = route_node_lookup (ospf->new_external_route,
! 467: (struct prefix *) &p)))
! 468: route_unlock_node(rn);
! 469:
! 470: if (!rn || (or = rn->info) == NULL)
! 471: {
! 472: if (IS_DEBUG_OSPF (lsa, LSA))
! 473: zlog_debug ("Route[External]: Adding a new route %s/%d",
! 474: inet_ntoa (p.prefix), p.prefixlen);
! 475:
! 476: ospf_route_add (ospf->new_external_route, &p, new, asbr_route);
! 477:
! 478: if (al->e[0].fwd_addr.s_addr)
! 479: ospf_ase_complete_direct_routes (new, al->e[0].fwd_addr);
! 480: return 0;
! 481: }
! 482: else
! 483: {
! 484: /* (a) Intra-area and inter-area paths are always preferred
! 485: over AS external paths.
! 486:
! 487: (b) Type 1 external paths are always preferred over type 2
! 488: external paths. When all paths are type 2 external
! 489: paths, the paths with the smallest advertised type 2
! 490: metric are always preferred. */
! 491: ret = ospf_route_cmp (ospf, new, or);
! 492:
! 493: /* (c) If the new AS external path is still indistinguishable
! 494: from the current paths in the N's routing table entry,
! 495: and RFC1583Compatibility is set to "disabled", select
! 496: the preferred paths based on the intra-AS paths to the
! 497: ASBR/forwarding addresses, as specified in Section
! 498: 16.4.1.
! 499:
! 500: (d) If the new AS external path is still indistinguishable
! 501: from the current paths in the N's routing table entry,
! 502: select the preferred path based on a least cost
! 503: comparison. Type 1 external paths are compared by
! 504: looking at the sum of the distance to the forwarding
! 505: address and the advertised type 1 metric (X+Y). Type 2
! 506: external paths advertising equal type 2 metrics are
! 507: compared by looking at the distance to the forwarding
! 508: addresses.
! 509: */
! 510: /* New route is better */
! 511: if (ret < 0)
! 512: {
! 513: if (IS_DEBUG_OSPF (lsa, LSA))
! 514: zlog_debug ("Route[External]: New route is better");
! 515: ospf_route_subst (rn, new, asbr_route);
! 516: if (al->e[0].fwd_addr.s_addr)
! 517: ospf_ase_complete_direct_routes (new, al->e[0].fwd_addr);
! 518: or = new;
! 519: new = NULL;
! 520: }
! 521: /* Old route is better */
! 522: else if (ret > 0)
! 523: {
! 524: if (IS_DEBUG_OSPF (lsa, LSA))
! 525: zlog_debug ("Route[External]: Old route is better");
! 526: /* do nothing */
! 527: }
! 528: /* Routes are equal */
! 529: else
! 530: {
! 531: if (IS_DEBUG_OSPF (lsa, LSA))
! 532: zlog_debug ("Route[External]: Routes are equal");
! 533: ospf_route_copy_nexthops (or, asbr_route->paths);
! 534: if (al->e[0].fwd_addr.s_addr)
! 535: ospf_ase_complete_direct_routes (or, al->e[0].fwd_addr);
! 536: }
! 537: }
! 538: /* Make sure setting newly calculated ASBR route.*/
! 539: or->u.ext.asbr = asbr_route;
! 540: if (new)
! 541: ospf_route_free (new);
! 542:
! 543: lsa->route = or;
! 544: return 0;
! 545: }
! 546:
! 547: static int
! 548: ospf_ase_route_match_same (struct route_table *rt, struct prefix *prefix,
! 549: struct ospf_route *newor)
! 550: {
! 551: struct route_node *rn;
! 552: struct ospf_route *or;
! 553: struct ospf_path *op;
! 554: struct ospf_path *newop;
! 555: struct listnode *n1;
! 556: struct listnode *n2;
! 557:
! 558: if (! rt || ! prefix)
! 559: return 0;
! 560:
! 561: rn = route_node_lookup (rt, prefix);
! 562: if (! rn)
! 563: return 0;
! 564:
! 565: route_unlock_node (rn);
! 566:
! 567: or = rn->info;
! 568: if (or->path_type != newor->path_type)
! 569: return 0;
! 570:
! 571: switch (or->path_type)
! 572: {
! 573: case OSPF_PATH_TYPE1_EXTERNAL:
! 574: if (or->cost != newor->cost)
! 575: return 0;
! 576: break;
! 577: case OSPF_PATH_TYPE2_EXTERNAL:
! 578: if ((or->cost != newor->cost) ||
! 579: (or->u.ext.type2_cost != newor->u.ext.type2_cost))
! 580: return 0;
! 581: break;
! 582: default:
! 583: assert (0);
! 584: return 0;
! 585: }
! 586:
! 587: if (or->paths->count != newor->paths->count)
! 588: return 0;
! 589:
! 590: /* Check each path. */
! 591: for (n1 = listhead (or->paths), n2 = listhead (newor->paths);
! 592: n1 && n2; n1 = listnextnode (n1), n2 = listnextnode (n2))
! 593: {
! 594: op = listgetdata (n1);
! 595: newop = listgetdata (n2);
! 596:
! 597: if (! IPV4_ADDR_SAME (&op->nexthop, &newop->nexthop))
! 598: return 0;
! 599: if (op->ifindex != newop->ifindex)
! 600: return 0;
! 601: }
! 602: return 1;
! 603: }
! 604:
! 605: static int
! 606: ospf_ase_compare_tables (struct route_table *new_external_route,
! 607: struct route_table *old_external_route)
! 608: {
! 609: struct route_node *rn, *new_rn;
! 610: struct ospf_route *or;
! 611:
! 612: /* Remove deleted routes */
! 613: for (rn = route_top (old_external_route); rn; rn = route_next (rn))
! 614: if ((or = rn->info))
! 615: {
! 616: if (! (new_rn = route_node_lookup (new_external_route, &rn->p)))
! 617: ospf_zebra_delete ((struct prefix_ipv4 *) &rn->p, or);
! 618: else
! 619: route_unlock_node (new_rn);
! 620: }
! 621:
! 622:
! 623: /* Install new routes */
! 624: for (rn = route_top (new_external_route); rn; rn = route_next (rn))
! 625: if ((or = rn->info) != NULL)
! 626: if (! ospf_ase_route_match_same (old_external_route, &rn->p, or))
! 627: ospf_zebra_add ((struct prefix_ipv4 *) &rn->p, or);
! 628:
! 629: return 0;
! 630: }
! 631:
! 632: static int
! 633: ospf_ase_calculate_timer (struct thread *t)
! 634: {
! 635: struct ospf *ospf;
! 636: struct ospf_lsa *lsa;
! 637: struct route_node *rn;
! 638: struct listnode *node;
! 639: struct ospf_area *area;
! 640:
! 641: ospf = THREAD_ARG (t);
! 642: ospf->t_ase_calc = NULL;
! 643:
! 644: if (ospf->ase_calc)
! 645: {
! 646: ospf->ase_calc = 0;
! 647:
! 648: /* Calculate external route for each AS-external-LSA */
! 649: LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
! 650: ospf_ase_calculate_route (ospf, lsa);
! 651:
! 652: /* This version simple adds to the table all NSSA areas */
! 653: if (ospf->anyNSSA)
! 654: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
! 655: {
! 656: if (IS_DEBUG_OSPF_NSSA)
! 657: zlog_debug ("ospf_ase_calculate_timer(): looking at area %s",
! 658: inet_ntoa (area->area_id));
! 659:
! 660: if (area->external_routing == OSPF_AREA_NSSA)
! 661: LSDB_LOOP (NSSA_LSDB (area), rn, lsa)
! 662: ospf_ase_calculate_route (ospf, lsa);
! 663: }
! 664: /* kevinm: And add the NSSA routes in ospf_top */
! 665: LSDB_LOOP (NSSA_LSDB (ospf),rn,lsa)
! 666: ospf_ase_calculate_route(ospf,lsa);
! 667:
! 668: /* Compare old and new external routing table and install the
! 669: difference info zebra/kernel */
! 670: ospf_ase_compare_tables (ospf->new_external_route,
! 671: ospf->old_external_route);
! 672:
! 673: /* Delete old external routing table */
! 674: ospf_route_table_free (ospf->old_external_route);
! 675: ospf->old_external_route = ospf->new_external_route;
! 676: ospf->new_external_route = route_table_init ();
! 677: }
! 678: return 0;
! 679: }
! 680:
! 681: void
! 682: ospf_ase_calculate_schedule (struct ospf *ospf)
! 683: {
! 684: if (ospf == NULL)
! 685: return;
! 686:
! 687: ospf->ase_calc = 1;
! 688: }
! 689:
! 690: void
! 691: ospf_ase_calculate_timer_add (struct ospf *ospf)
! 692: {
! 693: if (ospf == NULL)
! 694: return;
! 695:
! 696: if (! ospf->t_ase_calc)
! 697: ospf->t_ase_calc = thread_add_timer (master, ospf_ase_calculate_timer,
! 698: ospf, OSPF_ASE_CALC_INTERVAL);
! 699: }
! 700:
! 701: void
! 702: ospf_ase_register_external_lsa (struct ospf_lsa *lsa, struct ospf *top)
! 703: {
! 704: struct route_node *rn;
! 705: struct prefix_ipv4 p;
! 706: struct list *lst;
! 707: struct as_external_lsa *al;
! 708:
! 709: al = (struct as_external_lsa *) lsa->data;
! 710: p.family = AF_INET;
! 711: p.prefix = lsa->data->id;
! 712: p.prefixlen = ip_masklen (al->mask);
! 713: apply_mask_ipv4 (&p);
! 714:
! 715: rn = route_node_get (top->external_lsas, (struct prefix *) &p);
! 716: if ((lst = rn->info) == NULL)
! 717: rn->info = lst = list_new();
! 718:
! 719: /* We assume that if LSA is deleted from DB
! 720: is is also deleted from this RT */
! 721: listnode_add (lst, ospf_lsa_lock (lsa)); /* external_lsas lst */
! 722: }
! 723:
! 724: void
! 725: ospf_ase_unregister_external_lsa (struct ospf_lsa *lsa, struct ospf *top)
! 726: {
! 727: struct route_node *rn;
! 728: struct prefix_ipv4 p;
! 729: struct list *lst;
! 730: struct as_external_lsa *al;
! 731:
! 732: al = (struct as_external_lsa *) lsa->data;
! 733: p.family = AF_INET;
! 734: p.prefix = lsa->data->id;
! 735: p.prefixlen = ip_masklen (al->mask);
! 736: apply_mask_ipv4 (&p);
! 737:
! 738: rn = route_node_get (top->external_lsas, (struct prefix *) &p);
! 739: lst = rn->info;
! 740:
! 741: /* XXX lst can be NULL */
! 742: if (lst) {
! 743: listnode_delete (lst, lsa);
! 744: ospf_lsa_unlock (&lsa); /* external_lsas list */
! 745: }
! 746: }
! 747:
! 748: void
! 749: ospf_ase_external_lsas_finish (struct route_table *rt)
! 750: {
! 751: struct route_node *rn;
! 752: struct ospf_lsa *lsa;
! 753: struct list *lst;
! 754: struct listnode *node, *nnode;
! 755:
! 756: for (rn = route_top (rt); rn; rn = route_next (rn))
! 757: if ((lst = rn->info) != NULL)
! 758: {
! 759: for (ALL_LIST_ELEMENTS (lst, node, nnode, lsa))
! 760: ospf_lsa_unlock (&lsa); /* external_lsas lst */
! 761: list_delete (lst);
! 762: }
! 763:
! 764: route_table_finish (rt);
! 765: }
! 766:
! 767: void
! 768: ospf_ase_incremental_update (struct ospf *ospf, struct ospf_lsa *lsa)
! 769: {
! 770: struct list *lsas;
! 771: struct listnode *node;
! 772: struct route_node *rn, *rn2;
! 773: struct prefix_ipv4 p;
! 774: struct route_table *tmp_old;
! 775: struct as_external_lsa *al;
! 776:
! 777: al = (struct as_external_lsa *) lsa->data;
! 778: p.family = AF_INET;
! 779: p.prefix = lsa->data->id;
! 780: p.prefixlen = ip_masklen (al->mask);
! 781: apply_mask_ipv4 (&p);
! 782:
! 783: /* if new_table is NULL, there was no spf calculation, thus
! 784: incremental update is unneeded */
! 785: if (!ospf->new_table)
! 786: return;
! 787:
! 788: /* If there is already an intra-area or inter-area route
! 789: to the destination, no recalculation is necessary
! 790: (internal routes take precedence). */
! 791:
! 792: rn = route_node_lookup (ospf->new_table, (struct prefix *) &p);
! 793: if (rn)
! 794: {
! 795: route_unlock_node (rn);
! 796: if (rn->info)
! 797: return;
! 798: }
! 799:
! 800: rn = route_node_lookup (ospf->external_lsas, (struct prefix *) &p);
! 801: assert (rn);
! 802: assert (rn->info);
! 803: lsas = rn->info;
! 804: route_unlock_node (rn);
! 805:
! 806: for (ALL_LIST_ELEMENTS_RO (lsas, node, lsa))
! 807: ospf_ase_calculate_route (ospf, lsa);
! 808:
! 809: /* prepare temporary old routing table for compare */
! 810: tmp_old = route_table_init ();
! 811: rn = route_node_lookup (ospf->old_external_route, (struct prefix *) &p);
! 812: if (rn && rn->info)
! 813: {
! 814: rn2 = route_node_get (tmp_old, (struct prefix *) &p);
! 815: rn2->info = rn->info;
! 816: }
! 817:
! 818: /* install changes to zebra */
! 819: ospf_ase_compare_tables (ospf->new_external_route, tmp_old);
! 820:
! 821: /* update ospf->old_external_route table */
! 822: if (rn && rn->info)
! 823: ospf_route_free ((struct ospf_route *) rn->info);
! 824:
! 825: rn2 = route_node_lookup (ospf->new_external_route, (struct prefix *) &p);
! 826: /* if new route exists, install it to ospf->old_external_route */
! 827: if (rn2 && rn2->info)
! 828: {
! 829: if (!rn)
! 830: rn = route_node_get (ospf->old_external_route, (struct prefix *) &p);
! 831: rn->info = rn2->info;
! 832: }
! 833: else
! 834: {
! 835: /* remove route node from ospf->old_external_route */
! 836: if (rn)
! 837: {
! 838: rn->info = NULL;
! 839: route_unlock_node (rn);
! 840: route_unlock_node (rn);
! 841: }
! 842: }
! 843:
! 844: if (rn2)
! 845: {
! 846: /* rn2->info is stored in route node of ospf->old_external_route */
! 847: rn2->info = NULL;
! 848: route_unlock_node (rn2);
! 849: route_unlock_node (rn2);
! 850: }
! 851:
! 852: route_table_finish (tmp_old);
! 853: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_ase.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 / ospfd