Annotation of embedaddon/quagga/ospfd/ospf_ase.c, revision 1.1.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