]>
git.proxmox.com Git - mirror_frr.git/blob - ospfd/ospf_ase.c
2 * OSPF AS external route calculation.
3 * Copyright (C) 1999, 2000 Alex Zinin, Toshiaki Takada
5 * This file is part of GNU Zebra.
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
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.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "ospfd/ospfd.h"
35 #include "ospfd/ospf_interface.h"
36 #include "ospfd/ospf_ism.h"
37 #include "ospfd/ospf_asbr.h"
38 #include "ospfd/ospf_lsa.h"
39 #include "ospfd/ospf_lsdb.h"
40 #include "ospfd/ospf_neighbor.h"
41 #include "ospfd/ospf_nsm.h"
42 #include "ospfd/ospf_spf.h"
43 #include "ospfd/ospf_route.h"
44 #include "ospfd/ospf_ase.h"
45 #include "ospfd/ospf_zebra.h"
46 #include "ospfd/ospf_dump.h"
48 struct ospf_route
*ospf_find_asbr_route(struct ospf
*ospf
,
49 struct route_table
*rtrs
,
50 struct prefix_ipv4
*asbr
)
52 struct route_node
*rn
;
53 struct ospf_route
* or, *best
= NULL
;
54 struct listnode
*node
;
61 rn
= route_node_lookup(rtrs
, (struct prefix
*)asbr
);
65 route_unlock_node(rn
);
69 /* First try to find intra-area non-bb paths. */
70 if (!CHECK_FLAG(ospf
->config
, OSPF_RFC1583_COMPATIBLE
))
71 for (ALL_LIST_ELEMENTS_RO((struct list
*)rn
->info
, node
, or))
72 if (or->cost
< OSPF_LS_INFINITY
)
73 if (!OSPF_IS_AREA_ID_BACKBONE(or->u
.std
.area_id
)
75 or->path_type
== OSPF_PATH_INTRA_AREA
)
76 listnode_add(chosen
, or);
78 /* If none is found -- look through all. */
79 if (listcount(chosen
) == 0) {
84 /* Now find the route with least cost. */
85 for (ALL_LIST_ELEMENTS_RO(chosen
, node
, or))
86 if (or->cost
< OSPF_LS_INFINITY
) {
89 else if (best
->cost
> or->cost
)
91 else if (best
->cost
==
100 if (chosen
!= rn
->info
)
101 list_delete(&chosen
);
106 struct ospf_route
*ospf_find_asbr_route_through_area(struct route_table
*rtrs
,
107 struct prefix_ipv4
*asbr
,
108 struct ospf_area
*area
)
110 struct route_node
*rn
;
116 rn
= route_node_lookup(rtrs
, (struct prefix
*)asbr
);
119 struct listnode
*node
;
120 struct ospf_route
* or ;
122 route_unlock_node(rn
);
124 for (ALL_LIST_ELEMENTS_RO((struct list
*)rn
->info
, node
, or))
125 if (IPV4_ADDR_SAME(& or->u
.std
.area_id
, &area
->area_id
))
132 static void ospf_ase_complete_direct_routes(struct ospf_route
*ro
,
133 struct in_addr nexthop
)
135 struct listnode
*node
;
136 struct ospf_path
*op
;
138 for (ALL_LIST_ELEMENTS_RO(ro
->paths
, node
, op
))
139 if (op
->nexthop
.s_addr
== INADDR_ANY
)
140 op
->nexthop
.s_addr
= nexthop
.s_addr
;
143 static int ospf_ase_forward_address_check(struct ospf
*ospf
,
144 struct in_addr fwd_addr
)
146 struct listnode
*ifn
;
147 struct ospf_interface
*oi
;
149 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, ifn
, oi
))
150 if (if_is_operative(oi
->ifp
))
151 if (oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
)
152 if (IPV4_ADDR_SAME(&oi
->address
->u
.prefix4
,
159 static struct ospf_route
*
160 ospf_ase_calculate_new_route(struct ospf_lsa
*lsa
,
161 struct ospf_route
*asbr_route
, uint32_t metric
)
163 struct as_external_lsa
*al
;
164 struct ospf_route
*new;
166 al
= (struct as_external_lsa
*)lsa
->data
;
168 new = ospf_route_new();
170 /* Set redistributed type -- does make sense? */
171 /* new->type = type; */
172 new->id
= al
->header
.id
;
173 new->mask
= al
->mask
;
175 if (!IS_EXTERNAL_METRIC(al
->e
[0].tos
)) {
176 if (IS_DEBUG_OSPF(lsa
, LSA
))
177 zlog_debug("Route[External]: type-1 created.");
178 new->path_type
= OSPF_PATH_TYPE1_EXTERNAL
;
179 new->cost
= asbr_route
->cost
+ metric
; /* X + Y */
181 if (IS_DEBUG_OSPF(lsa
, LSA
))
182 zlog_debug("Route[External]: type-2 created.");
183 new->path_type
= OSPF_PATH_TYPE2_EXTERNAL
;
184 new->cost
= asbr_route
->cost
; /* X */
185 new->u
.ext
.type2_cost
= metric
; /* Y */
188 new->type
= OSPF_DESTINATION_NETWORK
;
189 new->u
.ext
.origin
= lsa
;
190 new->u
.ext
.tag
= ntohl(al
->e
[0].route_tag
);
191 new->u
.ext
.asbr
= asbr_route
;
193 assert(new != asbr_route
);
198 #define OSPF_ASE_CALC_INTERVAL 1
200 int ospf_ase_calculate_route(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
203 struct as_external_lsa
*al
;
204 struct ospf_route
*asbr_route
;
205 struct prefix_ipv4 asbr
, p
;
206 struct route_node
*rn
;
207 struct ospf_route
*new, * or ;
211 al
= (struct as_external_lsa
*)lsa
->data
;
213 if (lsa
->data
->type
== OSPF_AS_NSSA_LSA
)
214 if (IS_DEBUG_OSPF_NSSA
)
215 zlog_debug("ospf_ase_calc(): Processing Type-7");
217 /* Stay away from any Local Translated Type-7 LSAs */
218 if (CHECK_FLAG(lsa
->flags
, OSPF_LSA_LOCAL_XLT
)) {
219 if (IS_DEBUG_OSPF_NSSA
)
220 zlog_debug("ospf_ase_calc(): Rejecting Local Xlt'd");
224 if (IS_DEBUG_OSPF(lsa
, LSA
)) {
226 "Route[External]: Calculate AS-external-LSA to %pI4/%d adv_router %pI4",
227 &al
->header
.id
, ip_masklen(al
->mask
),
228 &al
->header
.adv_router
);
231 /* (1) If the cost specified by the LSA is LSInfinity, or if the
232 LSA's LS age is equal to MaxAge, then examine the next LSA. */
233 if ((metric
= GET_METRIC(al
->e
[0].metric
)) >= OSPF_LS_INFINITY
) {
234 if (IS_DEBUG_OSPF(lsa
, LSA
))
236 "Route[External]: Metric is OSPF_LS_INFINITY");
239 if (IS_LSA_MAXAGE(lsa
)) {
240 if (IS_DEBUG_OSPF(lsa
, LSA
))
242 "Route[External]: AS-external-LSA is MAXAGE");
246 /* (2) If the LSA was originated by the calculating router itself,
247 examine the next LSA. */
248 if (IS_LSA_SELF(lsa
)) {
249 if (IS_DEBUG_OSPF(lsa
, LSA
))
251 "Route[External]: AS-external-LSA is self originated");
255 /* (3) Call the destination described by the LSA N. N's address is
256 obtained by masking the LSA's Link State ID with the
257 network/subnet mask contained in the body of the LSA. Look
258 up the routing table entries (potentially one per attached
259 area) for the AS boundary router (ASBR) that originated the
260 LSA. If no entries exist for router ASBR (i.e., ASBR is
261 unreachable), do nothing with this LSA and consider the next
264 asbr
.family
= AF_INET
;
265 asbr
.prefix
= al
->header
.adv_router
;
266 asbr
.prefixlen
= IPV4_MAX_BITLEN
;
267 apply_mask_ipv4(&asbr
);
269 asbr_route
= ospf_find_asbr_route(ospf
, ospf
->new_rtrs
, &asbr
);
270 if (asbr_route
== NULL
) {
271 if (IS_DEBUG_OSPF(lsa
, LSA
))
273 "Route[External]: Can't find originating ASBR route");
276 if (!(asbr_route
->u
.std
.flags
& ROUTER_LSA_EXTERNAL
)) {
277 if (IS_DEBUG_OSPF(lsa
, LSA
))
279 "Route[External]: Originating router is not an ASBR");
283 /* Else, this LSA describes an AS external path to destination
284 N. Examine the forwarding address specified in the AS-
285 external-LSA. This indicates the IP address to which
286 packets for the destination should be forwarded. */
288 if (al
->e
[0].fwd_addr
.s_addr
== INADDR_ANY
) {
289 /* If the forwarding address is set to 0.0.0.0, packets should
290 be sent to the ASBR itself. Among the multiple routing table
291 entries for the ASBR, select the preferred entry as follows.
292 If RFC1583Compatibility is set to "disabled", prune the set
293 of routing table entries for the ASBR as described in
294 Section 16.4.1. In any case, among the remaining routing
295 table entries, select the routing table entry with the least
296 cost; when there are multiple least cost routing table
297 entries the entry whose associated area has the largest OSPF
298 Area ID (when considered as an unsigned 32-bit integer) is
301 /* asbr_route already contains the requested route */
303 /* If the forwarding address is non-zero, look up the
304 forwarding address in the routing table.[24] The matching
305 routing table entry must specify an intra-area or inter-area
306 path; if no such path exists, do nothing with the LSA and
307 consider the next in the list. */
308 if (!ospf_ase_forward_address_check(ospf
, al
->e
[0].fwd_addr
)) {
309 if (IS_DEBUG_OSPF(lsa
, LSA
))
311 "Route[External]: Forwarding address is our router address");
315 asbr
.family
= AF_INET
;
316 asbr
.prefix
= al
->e
[0].fwd_addr
;
317 asbr
.prefixlen
= IPV4_MAX_BITLEN
;
319 rn
= route_node_match(ospf
->new_table
, (struct prefix
*)&asbr
);
321 if (rn
== NULL
|| (asbr_route
= rn
->info
) == NULL
) {
322 if (IS_DEBUG_OSPF(lsa
, LSA
))
324 "Route[External]: Can't find route to forwarding address");
326 route_unlock_node(rn
);
330 route_unlock_node(rn
);
333 /* (4) Let X be the cost specified by the preferred routing table
334 entry for the ASBR/forwarding address, and Y the cost
335 specified in the LSA. X is in terms of the link state
336 metric, and Y is a type 1 or 2 external metric. */
339 /* (5) Look up the routing table entry for the destination N. If
340 no entry exists for N, install the AS external path to N,
341 with next hop equal to the list of next hops to the
342 forwarding address, and advertising router equal to ASBR.
343 If the external metric type is 1, then the path-type is set
344 to type 1 external and the cost is equal to X+Y. If the
345 external metric type is 2, the path-type is set to type 2
346 external, the link state component of the route's cost is X,
347 and the type 2 cost is Y. */
348 new = ospf_ase_calculate_new_route(lsa
, asbr_route
, metric
);
350 /* (6) Compare the AS external path described by the LSA with the
351 existing paths in N's routing table entry, as follows. If
352 the new path is preferred, it replaces the present paths in
353 N's routing table entry. If the new path is of equal
354 preference, it is added to N's routing table entry's list of
359 p
.prefix
= al
->header
.id
;
360 p
.prefixlen
= ip_masklen(al
->mask
);
362 /* if there is a Intra/Inter area route to the N
363 do not install external route */
364 if ((rn
= route_node_lookup(ospf
->new_table
, (struct prefix
*)&p
))) {
365 route_unlock_node(rn
);
366 if (rn
->info
== NULL
)
367 zlog_info("Route[External]: rn->info NULL");
369 ospf_route_free(new);
372 /* Find a route to the same dest */
373 /* If there is no route, create new one. */
374 if ((rn
= route_node_lookup(ospf
->new_external_route
,
375 (struct prefix
*)&p
)))
376 route_unlock_node(rn
);
378 if (!rn
|| (or = rn
->info
) == NULL
) {
379 if (IS_DEBUG_OSPF(lsa
, LSA
))
380 zlog_debug("Route[External]: Adding a new route %pFX with paths %u",
381 &p
, listcount(asbr_route
->paths
));
383 ospf_route_add(ospf
->new_external_route
, &p
, new, asbr_route
);
385 if (al
->e
[0].fwd_addr
.s_addr
!= INADDR_ANY
)
386 ospf_ase_complete_direct_routes(new, al
->e
[0].fwd_addr
);
389 /* (a) Intra-area and inter-area paths are always preferred
390 over AS external paths.
392 (b) Type 1 external paths are always preferred over type 2
393 external paths. When all paths are type 2 external
394 paths, the paths with the smallest advertised type 2
395 metric are always preferred. */
396 ret
= ospf_route_cmp(ospf
, new, or);
398 /* (c) If the new AS external path is still
400 from the current paths in the N's routing table
402 and RFC1583Compatibility is set to "disabled", select
403 the preferred paths based on the intra-AS paths to
405 ASBR/forwarding addresses, as specified in Section
408 (d) If the new AS external path is still
410 from the current paths in the N's routing table
412 select the preferred path based on a least cost
413 comparison. Type 1 external paths are compared by
414 looking at the sum of the distance to the forwarding
415 address and the advertised type 1 metric (X+Y). Type
417 external paths advertising equal type 2 metrics are
418 compared by looking at the distance to the forwarding
421 /* New route is better */
423 if (IS_DEBUG_OSPF(lsa
, LSA
))
425 "Route[External]: New route is better");
426 ospf_route_subst(rn
, new, asbr_route
);
427 if (al
->e
[0].fwd_addr
.s_addr
!= INADDR_ANY
)
428 ospf_ase_complete_direct_routes(
429 new, al
->e
[0].fwd_addr
);
433 /* Old route is better */
435 if (IS_DEBUG_OSPF(lsa
, LSA
))
437 "Route[External]: Old route is better");
440 /* Routes are equal */
442 if (IS_DEBUG_OSPF(lsa
, LSA
))
443 zlog_debug("Route[External]: Routes are equal");
444 ospf_route_copy_nexthops(or, asbr_route
->paths
);
445 if (al
->e
[0].fwd_addr
.s_addr
!= INADDR_ANY
)
446 ospf_ase_complete_direct_routes(
447 or, al
->e
[0].fwd_addr
);
450 /* Make sure setting newly calculated ASBR route.*/
451 or->u
.ext
.asbr
= asbr_route
;
453 ospf_route_free(new);
459 static int ospf_ase_route_match_same(struct route_table
*rt
,
460 struct prefix
*prefix
,
461 struct ospf_route
*newor
)
463 struct route_node
*rn
;
464 struct ospf_route
*or;
465 struct ospf_path
*op
;
466 struct ospf_path
*newop
;
473 rn
= route_node_lookup(rt
, prefix
);
477 route_unlock_node(rn
);
483 if (or->path_type
!= newor
->path_type
)
486 switch (or->path_type
) {
487 case OSPF_PATH_TYPE1_EXTERNAL
:
488 if (or->cost
!= newor
->cost
)
491 case OSPF_PATH_TYPE2_EXTERNAL
:
492 if ((or->cost
!= newor
->cost
)
493 || (or->u
.ext
.type2_cost
!= newor
->u
.ext
.type2_cost
))
503 if (or->paths
->count
!= newor
->paths
->count
)
506 /* Check each path. */
507 for (n1
= listhead(or->paths
), n2
= listhead(newor
->paths
); n1
&& n2
;
508 n1
= listnextnode_unchecked(n1
), n2
= listnextnode_unchecked(n2
)) {
509 op
= listgetdata(n1
);
510 newop
= listgetdata(n2
);
512 if (!IPV4_ADDR_SAME(&op
->nexthop
, &newop
->nexthop
))
514 if (op
->ifindex
!= newop
->ifindex
)
518 if (or->u
.ext
.tag
!= newor
->u
.ext
.tag
)
524 static int ospf_ase_compare_tables(struct ospf
*ospf
,
525 struct route_table
*new_external_route
,
526 struct route_table
*old_external_route
)
528 struct route_node
*rn
, *new_rn
;
529 struct ospf_route
* or ;
531 /* Remove deleted routes */
532 for (rn
= route_top(old_external_route
); rn
; rn
= route_next(rn
))
533 if ((or = rn
->info
)) {
534 if (!(new_rn
= route_node_lookup(new_external_route
,
537 ospf
, (struct prefix_ipv4
*)&rn
->p
, or);
539 route_unlock_node(new_rn
);
543 /* Install new routes */
544 for (rn
= route_top(new_external_route
); rn
; rn
= route_next(rn
))
545 if ((or = rn
->info
) != NULL
)
546 if (!ospf_ase_route_match_same(old_external_route
,
549 ospf
, (struct prefix_ipv4
*)&rn
->p
, or);
554 static int ospf_ase_calculate_timer(struct thread
*t
)
557 struct ospf_lsa
*lsa
;
558 struct route_node
*rn
;
559 struct listnode
*node
;
560 struct ospf_area
*area
;
561 struct timeval start_time
, stop_time
;
563 ospf
= THREAD_ARG(t
);
564 ospf
->t_ase_calc
= NULL
;
566 if (ospf
->ase_calc
) {
569 monotime(&start_time
);
571 /* Calculate external route for each AS-external-LSA */
572 LSDB_LOOP (EXTERNAL_LSDB(ospf
), rn
, lsa
)
573 ospf_ase_calculate_route(ospf
, lsa
);
575 /* This version simple adds to the table all NSSA areas */
577 for (ALL_LIST_ELEMENTS_RO(ospf
->areas
, node
, area
)) {
578 if (IS_DEBUG_OSPF_NSSA
)
580 "ospf_ase_calculate_timer(): looking at area %pI4",
583 if (area
->external_routing
== OSPF_AREA_NSSA
)
584 LSDB_LOOP (NSSA_LSDB(area
), rn
, lsa
)
585 ospf_ase_calculate_route(ospf
,
588 /* kevinm: And add the NSSA routes in ospf_top */
589 LSDB_LOOP (NSSA_LSDB(ospf
), rn
, lsa
)
590 ospf_ase_calculate_route(ospf
, lsa
);
592 /* Compare old and new external routing table and install the
593 difference info zebra/kernel */
594 ospf_ase_compare_tables(ospf
, ospf
->new_external_route
,
595 ospf
->old_external_route
);
597 /* Delete old external routing table */
598 ospf_route_table_free(ospf
->old_external_route
);
599 ospf
->old_external_route
= ospf
->new_external_route
;
600 ospf
->new_external_route
= route_table_init();
602 monotime(&stop_time
);
604 if (IS_DEBUG_OSPF_EVENT
)
606 "SPF Processing Time(usecs): External Routes: %lld",
607 (stop_time
.tv_sec
- start_time
.tv_sec
)
610 - start_time
.tv_usec
));
614 * Uninstall remnant routes that were installed before the restart, but
615 * that are no longer valid.
617 if (ospf
->gr_info
.finishing_restart
) {
618 ospf_zebra_gr_disable(ospf
);
619 ospf
->gr_info
.finishing_restart
= false;
625 void ospf_ase_calculate_schedule(struct ospf
*ospf
)
633 void ospf_ase_calculate_timer_add(struct ospf
*ospf
)
638 thread_add_timer(master
, ospf_ase_calculate_timer
, ospf
,
639 OSPF_ASE_CALC_INTERVAL
, &ospf
->t_ase_calc
);
642 void ospf_ase_register_external_lsa(struct ospf_lsa
*lsa
, struct ospf
*top
)
644 struct route_node
*rn
;
645 struct prefix_ipv4 p
;
647 struct as_external_lsa
*al
;
649 al
= (struct as_external_lsa
*)lsa
->data
;
651 p
.prefix
= lsa
->data
->id
;
652 p
.prefixlen
= ip_masklen(al
->mask
);
655 rn
= route_node_get(top
->external_lsas
, (struct prefix
*)&p
);
656 if ((lst
= rn
->info
) == NULL
)
657 rn
->info
= lst
= list_new();
659 route_unlock_node(rn
);
661 /* We assume that if LSA is deleted from DB
662 is is also deleted from this RT */
663 listnode_add(lst
, ospf_lsa_lock(lsa
)); /* external_lsas lst */
666 void ospf_ase_unregister_external_lsa(struct ospf_lsa
*lsa
, struct ospf
*top
)
668 struct route_node
*rn
;
669 struct prefix_ipv4 p
;
671 struct as_external_lsa
*al
;
673 al
= (struct as_external_lsa
*)lsa
->data
;
675 p
.prefix
= lsa
->data
->id
;
676 p
.prefixlen
= ip_masklen(al
->mask
);
679 rn
= route_node_lookup(top
->external_lsas
, (struct prefix
*)&p
);
683 struct listnode
*node
= listnode_lookup(lst
, lsa
);
684 /* Unlock lsa only if node is present in the list */
686 listnode_delete(lst
, lsa
);
687 ospf_lsa_unlock(&lsa
); /* external_lsas list */
690 route_unlock_node(rn
);
694 void ospf_ase_external_lsas_finish(struct route_table
*rt
)
696 struct route_node
*rn
;
697 struct ospf_lsa
*lsa
;
699 struct listnode
*node
, *nnode
;
701 for (rn
= route_top(rt
); rn
; rn
= route_next(rn
))
702 if ((lst
= rn
->info
) != NULL
) {
703 for (ALL_LIST_ELEMENTS(lst
, node
, nnode
, lsa
))
704 ospf_lsa_unlock(&lsa
); /* external_lsas lst */
708 route_table_finish(rt
);
711 void ospf_ase_incremental_update(struct ospf
*ospf
, struct ospf_lsa
*lsa
)
714 struct listnode
*node
;
715 struct route_node
*rn
, *rn2
;
716 struct prefix_ipv4 p
;
717 struct route_table
*tmp_old
;
718 struct as_external_lsa
*al
;
720 al
= (struct as_external_lsa
*)lsa
->data
;
722 p
.prefix
= lsa
->data
->id
;
723 p
.prefixlen
= ip_masklen(al
->mask
);
726 /* if new_table is NULL, there was no spf calculation, thus
727 incremental update is unneeded */
728 if (!ospf
->new_table
)
731 /* If there is already an intra-area or inter-area route
732 to the destination, no recalculation is necessary
733 (internal routes take precedence). */
735 rn
= route_node_lookup(ospf
->new_table
, (struct prefix
*)&p
);
737 route_unlock_node(rn
);
742 rn
= route_node_lookup(ospf
->external_lsas
, (struct prefix
*)&p
);
746 route_unlock_node(rn
);
748 for (ALL_LIST_ELEMENTS_RO(lsas
, node
, lsa
))
749 ospf_ase_calculate_route(ospf
, lsa
);
751 /* prepare temporary old routing table for compare */
752 tmp_old
= route_table_init();
753 rn
= route_node_lookup(ospf
->old_external_route
, (struct prefix
*)&p
);
754 if (rn
&& rn
->info
) {
755 rn2
= route_node_get(tmp_old
, (struct prefix
*)&p
);
756 rn2
->info
= rn
->info
;
757 route_unlock_node(rn
);
760 /* install changes to zebra */
761 ospf_ase_compare_tables(ospf
, ospf
->new_external_route
, tmp_old
);
763 /* update ospf->old_external_route table */
765 ospf_route_free((struct ospf_route
*)rn
->info
);
767 rn2
= route_node_lookup(ospf
->new_external_route
, (struct prefix
*)&p
);
768 /* if new route exists, install it to ospf->old_external_route */
769 if (rn2
&& rn2
->info
) {
771 rn
= route_node_get(ospf
->old_external_route
,
772 (struct prefix
*)&p
);
773 rn
->info
= rn2
->info
;
775 /* remove route node from ospf->old_external_route */
778 route_unlock_node(rn
);
783 /* rn2->info is stored in route node of ospf->old_external_route
786 route_unlock_node(rn2
);
787 route_unlock_node(rn2
);
790 route_table_finish(tmp_old
);