]> git.proxmox.com Git - mirror_frr.git/blob - ospf6d/ospf6_asbr.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #5280 from qlyoung/doc-clean-topotest-json
[mirror_frr.git] / ospf6d / ospf6_asbr.c
1 /*
2 * Copyright (C) 2003 Yasuhiro Ohara
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 along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "log.h"
24 #include "memory.h"
25 #include "prefix.h"
26 #include "command.h"
27 #include "vty.h"
28 #include "routemap.h"
29 #include "table.h"
30 #include "plist.h"
31 #include "thread.h"
32 #include "linklist.h"
33
34 #include "ospf6_proto.h"
35 #include "ospf6_lsa.h"
36 #include "ospf6_lsdb.h"
37 #include "ospf6_route.h"
38 #include "ospf6_zebra.h"
39 #include "ospf6_message.h"
40
41 #include "ospf6_top.h"
42 #include "ospf6_area.h"
43 #include "ospf6_interface.h"
44 #include "ospf6_neighbor.h"
45 #include "ospf6_asbr.h"
46 #include "ospf6_intra.h"
47 #include "ospf6_flood.h"
48 #include "ospf6d.h"
49
50 unsigned char conf_debug_ospf6_asbr = 0;
51
52 #define ZROUTE_NAME(x) zebra_route_string(x)
53
54 /* AS External LSA origination */
55 static void ospf6_as_external_lsa_originate(struct ospf6_route *route)
56 {
57 char buffer[OSPF6_MAX_LSASIZE];
58 struct ospf6_lsa_header *lsa_header;
59 struct ospf6_lsa *lsa;
60 struct ospf6_external_info *info = route->route_option;
61
62 struct ospf6_as_external_lsa *as_external_lsa;
63 char buf[PREFIX2STR_BUFFER];
64 caddr_t p;
65
66 if (IS_OSPF6_DEBUG_ASBR || IS_OSPF6_DEBUG_ORIGINATE(AS_EXTERNAL)) {
67 prefix2str(&route->prefix, buf, sizeof(buf));
68 zlog_debug("Originate AS-External-LSA for %s", buf);
69 }
70
71 /* prepare buffer */
72 memset(buffer, 0, sizeof(buffer));
73 lsa_header = (struct ospf6_lsa_header *)buffer;
74 as_external_lsa = (struct ospf6_as_external_lsa
75 *)((caddr_t)lsa_header
76 + sizeof(struct ospf6_lsa_header));
77 p = (caddr_t)((caddr_t)as_external_lsa
78 + sizeof(struct ospf6_as_external_lsa));
79
80 /* Fill AS-External-LSA */
81 /* Metric type */
82 if (route->path.metric_type == 2)
83 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
84 else
85 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
86
87 /* forwarding address */
88 if (!IN6_IS_ADDR_UNSPECIFIED(&info->forwarding))
89 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
90 else
91 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
92
93 /* external route tag */
94 if (info->tag)
95 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
96 else
97 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
98
99 /* Set metric */
100 OSPF6_ASBR_METRIC_SET(as_external_lsa, route->path.cost);
101
102 /* prefixlen */
103 as_external_lsa->prefix.prefix_length = route->prefix.prefixlen;
104
105 /* PrefixOptions */
106 as_external_lsa->prefix.prefix_options = route->path.prefix_options;
107
108 /* don't use refer LS-type */
109 as_external_lsa->prefix.prefix_refer_lstype = htons(0);
110
111 /* set Prefix */
112 memcpy(p, &route->prefix.u.prefix6,
113 OSPF6_PREFIX_SPACE(route->prefix.prefixlen));
114 ospf6_prefix_apply_mask(&as_external_lsa->prefix);
115 p += OSPF6_PREFIX_SPACE(route->prefix.prefixlen);
116
117 /* Forwarding address */
118 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F)) {
119 memcpy(p, &info->forwarding, sizeof(struct in6_addr));
120 p += sizeof(struct in6_addr);
121 }
122
123 /* External Route Tag */
124 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T)) {
125 route_tag_t network_order = htonl(info->tag);
126
127 memcpy(p, &network_order, sizeof(network_order));
128 p += sizeof(network_order);
129 }
130
131 /* Fill LSA Header */
132 lsa_header->age = 0;
133 lsa_header->type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
134 lsa_header->id = route->path.origin.id;
135 lsa_header->adv_router = ospf6->router_id;
136 lsa_header->seqnum =
137 ospf6_new_ls_seqnum(lsa_header->type, lsa_header->id,
138 lsa_header->adv_router, ospf6->lsdb);
139 lsa_header->length = htons((caddr_t)p - (caddr_t)lsa_header);
140
141 /* LSA checksum */
142 ospf6_lsa_checksum(lsa_header);
143
144 /* create LSA */
145 lsa = ospf6_lsa_create(lsa_header);
146
147 /* Originate */
148 ospf6_lsa_originate_process(lsa, ospf6);
149 }
150
151 int ospf6_orig_as_external_lsa(struct thread *thread)
152 {
153 struct ospf6_interface *oi;
154 struct ospf6_lsa *lsa;
155 uint32_t type, adv_router;
156
157 oi = (struct ospf6_interface *)THREAD_ARG(thread);
158 oi->thread_as_extern_lsa = NULL;
159
160 if (oi->state == OSPF6_INTERFACE_DOWN)
161 return 0;
162
163 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
164 adv_router = oi->area->ospf6->router_id;
165 for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, adv_router, lsa)) {
166 if (IS_OSPF6_DEBUG_ASBR)
167 zlog_debug(
168 "%s: Send update of AS-External LSA %s seq 0x%x",
169 __PRETTY_FUNCTION__, lsa->name,
170 ntohl(lsa->header->seqnum));
171
172 ospf6_flood_interface(NULL, lsa, oi);
173 }
174
175 return 0;
176 }
177
178 static route_tag_t ospf6_as_external_lsa_get_tag(struct ospf6_lsa *lsa)
179 {
180 struct ospf6_as_external_lsa *external;
181 ptrdiff_t tag_offset;
182 route_tag_t network_order;
183
184 if (!lsa)
185 return 0;
186
187 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
188 lsa->header);
189
190 if (!CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T))
191 return 0;
192
193 tag_offset = sizeof(*external)
194 + OSPF6_PREFIX_SPACE(external->prefix.prefix_length);
195 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F))
196 tag_offset += sizeof(struct in6_addr);
197
198 memcpy(&network_order, (caddr_t)external + tag_offset,
199 sizeof(network_order));
200 return ntohl(network_order);
201 }
202
203 void ospf6_asbr_update_route_ecmp_path(struct ospf6_route *old,
204 struct ospf6_route *route)
205 {
206 struct ospf6_route *old_route;
207 struct ospf6_path *ecmp_path, *o_path = NULL;
208 struct listnode *anode, *anext;
209 struct listnode *nnode, *rnode, *rnext;
210 struct ospf6_nexthop *nh, *rnh;
211 char buf[PREFIX2STR_BUFFER];
212 bool route_found = false;
213
214 /* check for old entry match with new route origin,
215 * delete old entry.
216 */
217 for (old_route = old; old_route; old_route = old_route->next) {
218 bool route_updated = false;
219
220 if (!ospf6_route_is_same(old_route, route)
221 || (old_route->path.type != route->path.type))
222 continue;
223
224 /* Current and New route has same origin,
225 * delete old entry.
226 */
227 for (ALL_LIST_ELEMENTS(old_route->paths, anode, anext,
228 o_path)) {
229 /* Check old route path and route has same
230 * origin.
231 */
232 if (o_path->area_id != route->path.area_id
233 || (memcmp(&(o_path)->origin, &(route)->path.origin,
234 sizeof(struct ospf6_ls_origin))
235 != 0))
236 continue;
237
238 /* Cost is not same then delete current path */
239 if ((o_path->cost == route->path.cost)
240 && (o_path->u.cost_e2 == route->path.u.cost_e2))
241 continue;
242
243 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
244 prefix2str(&old_route->prefix, buf,
245 sizeof(buf));
246 zlog_debug(
247 "%s: route %s cost old %u new %u is not same, replace route",
248 __PRETTY_FUNCTION__, buf, o_path->cost,
249 route->path.cost);
250 }
251
252 /* Remove selected current rout path's nh from
253 * effective nh list.
254 */
255 for (ALL_LIST_ELEMENTS_RO(o_path->nh_list, nnode, nh)) {
256 for (ALL_LIST_ELEMENTS(old_route->nh_list,
257 rnode, rnext, rnh)) {
258 if (!ospf6_nexthop_is_same(rnh, nh))
259 continue;
260 listnode_delete(old_route->nh_list,
261 rnh);
262 ospf6_nexthop_delete(rnh);
263 }
264 }
265
266 listnode_delete(old_route->paths, o_path);
267 ospf6_path_free(o_path);
268 route_updated = true;
269
270 /* Current route's path (adv_router info) is similar
271 * to route being added.
272 * Replace current route's path with paths list head.
273 * Update FIB with effective NHs.
274 */
275 if (listcount(old_route->paths)) {
276 for (ALL_LIST_ELEMENTS(old_route->paths,
277 anode, anext, o_path)) {
278 ospf6_merge_nexthops(
279 old_route->nh_list,
280 o_path->nh_list);
281 }
282 /* Update RIB/FIB with effective
283 * nh_list
284 */
285 if (ospf6->route_table->hook_add)
286 (*ospf6->route_table->hook_add)
287 (old_route);
288
289 if (old_route->path.origin.id
290 == route->path.origin.id
291 && old_route->path.origin.adv_router
292 == route->path.origin
293 .adv_router) {
294 struct ospf6_path *h_path;
295
296 h_path = (struct ospf6_path *)
297 listgetdata(listhead(
298 old_route->paths));
299 old_route->path.origin.type =
300 h_path->origin.type;
301 old_route->path.origin.id =
302 h_path->origin.id;
303 old_route->path.origin.adv_router =
304 h_path->origin.adv_router;
305 }
306 } else {
307 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
308 prefix2str(&old_route->prefix, buf,
309 sizeof(buf));
310 zlog_debug(
311 "%s: route %s old cost %u new cost %u, delete old entry.",
312 __PRETTY_FUNCTION__, buf,
313 old_route->path.cost,
314 route->path.cost);
315 }
316 ospf6_route_remove(old_route,
317 ospf6->route_table);
318 }
319 }
320 if (route_updated)
321 break;
322 }
323
324 /* Add new route */
325 for (old_route = old; old_route; old_route = old_route->next) {
326
327 /* Current and New Route prefix or route type
328 * is not same skip this current node.
329 */
330 if (!ospf6_route_is_same(old_route, route)
331 || (old_route->path.type != route->path.type))
332 continue;
333
334 /* Old Route and New Route have Equal Cost, Merge NHs */
335 if ((old_route->path.cost == route->path.cost)
336 && (old_route->path.u.cost_e2 == route->path.u.cost_e2)) {
337
338 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
339 prefix2str(&old_route->prefix, buf,
340 sizeof(buf));
341 zlog_debug(
342 "%s: old route %s path cost %u e2 %u",
343 __PRETTY_FUNCTION__, buf,
344 old_route->path.cost,
345 old_route->path.u.cost_e2);
346 }
347 route_found = true;
348 /* check if this path exists already in
349 * route->paths list, if so, replace nh_list
350 * from asbr_entry.
351 */
352 for (ALL_LIST_ELEMENTS_RO(old_route->paths, anode,
353 o_path)) {
354 if (o_path->area_id == route->path.area_id
355 && (memcmp(&(o_path)->origin,
356 &(route)->path.origin,
357 sizeof(struct ospf6_ls_origin))
358 == 0))
359 break;
360 }
361 /* If path is not found in old_route paths's list,
362 * add a new path to route paths list and merge
363 * nexthops in route->path->nh_list.
364 * Otherwise replace existing path's nh_list.
365 */
366 if (o_path == NULL) {
367 ecmp_path = ospf6_path_dup(&route->path);
368
369 /* Add a nh_list to new ecmp path */
370 ospf6_copy_nexthops(ecmp_path->nh_list,
371 route->nh_list);
372
373 /* Add the new path to route's path list */
374 listnode_add_sort(old_route->paths, ecmp_path);
375
376 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
377 prefix2str(&route->prefix, buf,
378 sizeof(buf));
379 zlog_debug(
380 "%s: route %s another path added with nh %u, effective paths %u nh %u",
381 __PRETTY_FUNCTION__, buf,
382 listcount(ecmp_path->nh_list),
383 old_route->paths
384 ? listcount(
385 old_route
386 ->paths)
387 : 0,
388 listcount(old_route->nh_list));
389 }
390 } else {
391 list_delete_all_node(o_path->nh_list);
392 ospf6_copy_nexthops(o_path->nh_list,
393 route->nh_list);
394 }
395
396 /* Reset nexthop lists, rebuild from brouter table
397 * for each adv. router.
398 */
399 list_delete_all_node(old_route->nh_list);
400
401 for (ALL_LIST_ELEMENTS_RO(old_route->paths, anode,
402 o_path)) {
403 struct ospf6_route *asbr_entry;
404
405 asbr_entry = ospf6_route_lookup(
406 &o_path->ls_prefix,
407 ospf6->brouter_table);
408 if (asbr_entry == NULL) {
409 if (IS_OSPF6_DEBUG_EXAMIN(
410 AS_EXTERNAL)) {
411 prefix2str(&old_route->prefix,
412 buf, sizeof(buf));
413 zlog_debug("%s: ls_prfix %s asbr_entry not found.",
414 __PRETTY_FUNCTION__,
415 buf);
416 }
417 continue;
418 }
419 ospf6_route_merge_nexthops(old_route,
420 asbr_entry);
421 }
422
423 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
424 prefix2str(&route->prefix, buf, sizeof(buf));
425 zlog_debug("%s: route %s with effective paths %u nh %u",
426 __PRETTY_FUNCTION__, buf,
427 old_route->paths ?
428 listcount(old_route->paths) : 0,
429 old_route->nh_list ?
430 listcount(old_route->nh_list) : 0);
431 }
432
433 /* Update RIB/FIB */
434 if (ospf6->route_table->hook_add)
435 (*ospf6->route_table->hook_add)(old_route);
436
437 /* Delete the new route its info added to existing
438 * route.
439 */
440 ospf6_route_delete(route);
441
442 break;
443 }
444 }
445
446 if (!route_found) {
447 /* Add new route to existing node in ospf6 route table. */
448 ospf6_route_add(route, ospf6->route_table);
449 }
450 }
451
452 void ospf6_asbr_lsa_add(struct ospf6_lsa *lsa)
453 {
454 struct ospf6_as_external_lsa *external;
455 struct prefix asbr_id;
456 struct ospf6_route *asbr_entry, *route, *old;
457 struct ospf6_path *path;
458 char buf[PREFIX2STR_BUFFER];
459
460 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
461 lsa->header);
462
463 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
464 zlog_debug("Calculate AS-External route for %s", lsa->name);
465
466 if (lsa->header->adv_router == ospf6->router_id) {
467 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
468 zlog_debug("Ignore self-originated AS-External-LSA");
469 return;
470 }
471
472 if (OSPF6_ASBR_METRIC(external) == OSPF_LS_INFINITY) {
473 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
474 zlog_debug("Ignore LSA with LSInfinity Metric");
475 return;
476 }
477
478 if (CHECK_FLAG(external->prefix.prefix_options,
479 OSPF6_PREFIX_OPTION_NU)) {
480 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
481 zlog_debug("Ignore LSA with NU bit set Metric");
482 return;
483 }
484
485 ospf6_linkstate_prefix(lsa->header->adv_router, htonl(0), &asbr_id);
486 asbr_entry = ospf6_route_lookup(&asbr_id, ospf6->brouter_table);
487 if (asbr_entry == NULL
488 || !CHECK_FLAG(asbr_entry->path.router_bits, OSPF6_ROUTER_BIT_E)) {
489 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
490 prefix2str(&asbr_id, buf, sizeof(buf));
491 zlog_debug("ASBR entry not found: %s", buf);
492 }
493 return;
494 }
495
496 route = ospf6_route_create();
497 route->type = OSPF6_DEST_TYPE_NETWORK;
498 route->prefix.family = AF_INET6;
499 route->prefix.prefixlen = external->prefix.prefix_length;
500 ospf6_prefix_in6_addr(&route->prefix.u.prefix6, external,
501 &external->prefix);
502
503 route->path.area_id = asbr_entry->path.area_id;
504 route->path.origin.type = lsa->header->type;
505 route->path.origin.id = lsa->header->id;
506 route->path.origin.adv_router = lsa->header->adv_router;
507 route->path.prefix_options = external->prefix.prefix_options;
508 memcpy(&route->path.ls_prefix, &asbr_id, sizeof(struct prefix));
509
510 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E)) {
511 route->path.type = OSPF6_PATH_TYPE_EXTERNAL2;
512 route->path.metric_type = 2;
513 route->path.cost = asbr_entry->path.cost;
514 route->path.u.cost_e2 = OSPF6_ASBR_METRIC(external);
515 } else {
516 route->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
517 route->path.metric_type = 1;
518 route->path.cost =
519 asbr_entry->path.cost + OSPF6_ASBR_METRIC(external);
520 route->path.u.cost_e2 = 0;
521 }
522
523 route->path.tag = ospf6_as_external_lsa_get_tag(lsa);
524
525 ospf6_route_copy_nexthops(route, asbr_entry);
526
527 path = ospf6_path_dup(&route->path);
528 ospf6_copy_nexthops(path->nh_list, asbr_entry->nh_list);
529 listnode_add_sort(route->paths, path);
530
531
532 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
533 prefix2str(&route->prefix, buf, sizeof(buf));
534 zlog_debug("%s: AS-External %u route add %s cost %u(%u) nh %u",
535 __PRETTY_FUNCTION__,
536 (route->path.type == OSPF6_PATH_TYPE_EXTERNAL1) ? 1
537 : 2,
538 buf, route->path.cost, route->path.u.cost_e2,
539 listcount(route->nh_list));
540 }
541
542 old = ospf6_route_lookup(&route->prefix, ospf6->route_table);
543 if (!old) {
544 /* Add the new route to ospf6 instance route table. */
545 ospf6_route_add(route, ospf6->route_table);
546 } else {
547 /* RFC 2328 16.4 (6)
548 * ECMP: Keep new equal preference path in current
549 * route's path list, update zebra with new effective
550 * list along with addition of ECMP path.
551 */
552 ospf6_asbr_update_route_ecmp_path(old, route);
553 }
554 }
555
556 void ospf6_asbr_lsa_remove(struct ospf6_lsa *lsa,
557 struct ospf6_route *asbr_entry)
558 {
559 struct ospf6_as_external_lsa *external;
560 struct prefix prefix;
561 struct ospf6_route *route, *nroute, *route_to_del;
562 char buf[PREFIX2STR_BUFFER];
563
564 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
565 lsa->header);
566
567 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
568 zlog_debug("Withdraw AS-External route for %s", lsa->name);
569
570 if (lsa->header->adv_router == ospf6->router_id) {
571 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
572 zlog_debug("Ignore self-originated AS-External-LSA");
573 return;
574 }
575
576 route_to_del = ospf6_route_create();
577 route_to_del->type = OSPF6_DEST_TYPE_NETWORK;
578 route_to_del->prefix.family = AF_INET6;
579 route_to_del->prefix.prefixlen = external->prefix.prefix_length;
580 ospf6_prefix_in6_addr(&route_to_del->prefix.u.prefix6, external,
581 &external->prefix);
582
583 route_to_del->path.origin.type = lsa->header->type;
584 route_to_del->path.origin.id = lsa->header->id;
585 route_to_del->path.origin.adv_router = lsa->header->adv_router;
586
587 if (asbr_entry) {
588 route_to_del->path.area_id = asbr_entry->path.area_id;
589 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E)) {
590 route_to_del->path.type = OSPF6_PATH_TYPE_EXTERNAL2;
591 route_to_del->path.metric_type = 2;
592 route_to_del->path.cost = asbr_entry->path.cost;
593 route_to_del->path.u.cost_e2 =
594 OSPF6_ASBR_METRIC(external);
595 } else {
596 route_to_del->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
597 route_to_del->path.metric_type = 1;
598 route_to_del->path.cost = asbr_entry->path.cost
599 + OSPF6_ASBR_METRIC(external);
600 route_to_del->path.u.cost_e2 = 0;
601 }
602 }
603
604 memset(&prefix, 0, sizeof(struct prefix));
605 prefix.family = AF_INET6;
606 prefix.prefixlen = external->prefix.prefix_length;
607 ospf6_prefix_in6_addr(&prefix.u.prefix6, external, &external->prefix);
608
609 route = ospf6_route_lookup(&prefix, ospf6->route_table);
610 if (route == NULL) {
611 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
612 prefix2str(&prefix, buf, sizeof(buf));
613 zlog_debug("AS-External route %s not found", buf);
614 }
615
616 ospf6_route_delete(route_to_del);
617 return;
618 }
619
620 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
621 prefix2str(&prefix, buf, sizeof(buf));
622 zlog_debug(
623 "%s: Current route %s cost %u e2 %u, route to del cost %u e2 %u",
624 __PRETTY_FUNCTION__, buf, route->path.cost,
625 route->path.u.cost_e2, route_to_del->path.cost,
626 route_to_del->path.u.cost_e2);
627 }
628
629 for (ospf6_route_lock(route);
630 route && ospf6_route_is_prefix(&prefix, route); route = nroute) {
631 nroute = ospf6_route_next(route);
632
633 if (route->type != OSPF6_DEST_TYPE_NETWORK)
634 continue;
635
636 /* Route has multiple ECMP paths, remove matching
637 * path. Update current route's effective nh list
638 * after removal of one of the path.
639 */
640 if (listcount(route->paths) > 1) {
641 struct listnode *anode, *anext;
642 struct listnode *nnode, *rnode, *rnext;
643 struct ospf6_nexthop *nh, *rnh;
644 struct ospf6_path *o_path;
645 bool nh_updated = false;
646
647 /* Iterate all paths of route to find maching with LSA
648 * remove from route path list. If route->path is same,
649 * replace from paths list.
650 */
651 for (ALL_LIST_ELEMENTS(route->paths, anode, anext,
652 o_path)) {
653 if ((o_path->origin.type != lsa->header->type)
654 || (o_path->origin.adv_router
655 != lsa->header->adv_router)
656 || (o_path->origin.id != lsa->header->id))
657 continue;
658
659 /* Compare LSA cost with current
660 * route info.
661 */
662 if (!asbr_entry
663 && (o_path->cost != route_to_del->path.cost
664 || o_path->u.cost_e2
665 != route_to_del->path.u
666 .cost_e2)) {
667 if (IS_OSPF6_DEBUG_EXAMIN(
668 AS_EXTERNAL)) {
669 prefix2str(&prefix, buf,
670 sizeof(buf));
671 zlog_debug(
672 "%s: route %s to delete is not same, cost %u del cost %u. skip",
673 __PRETTY_FUNCTION__,
674 buf, route->path.cost,
675 route_to_del->path
676 .cost);
677 }
678 continue;
679 }
680
681 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
682 prefix2str(&prefix, buf, sizeof(buf));
683 zlog_debug(
684 "%s: route %s path found with cost %u nh %u to remove.",
685 __PRETTY_FUNCTION__, buf,
686 route->path.cost,
687 listcount(o_path->nh_list));
688 }
689
690 /* Remove found path's nh_list from
691 * the route's nh_list.
692 */
693 for (ALL_LIST_ELEMENTS_RO(o_path->nh_list,
694 nnode, nh)) {
695 for (ALL_LIST_ELEMENTS(route->nh_list,
696 rnode, rnext,
697 rnh)) {
698 if (!ospf6_nexthop_is_same(rnh,
699 nh))
700 continue;
701 listnode_delete(route->nh_list,
702 rnh);
703 ospf6_nexthop_delete(rnh);
704 }
705 }
706 /* Delete the path from route's path list */
707 listnode_delete(route->paths, o_path);
708 ospf6_path_free(o_path);
709 nh_updated = true;
710 }
711
712 if (nh_updated) {
713 /* Iterate all paths and merge nexthop,
714 * unlesss any of the nexthop similar to
715 * ones deleted as part of path deletion.
716 */
717
718 for (ALL_LIST_ELEMENTS(route->paths, anode,
719 anext, o_path)) {
720 ospf6_merge_nexthops(route->nh_list,
721 o_path->nh_list);
722 }
723
724 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
725 prefix2str(&route->prefix, buf,
726 sizeof(buf));
727 zlog_debug(
728 "%s: AS-External %u route %s update paths %u nh %u",
729 __PRETTY_FUNCTION__,
730 (route->path.type
731 == OSPF6_PATH_TYPE_EXTERNAL1)
732 ? 1
733 : 2,
734 buf, listcount(route->paths),
735 route->nh_list ?
736 listcount(route->nh_list) : 0);
737 }
738
739 if (listcount(route->paths)) {
740 /* Update RIB/FIB with effective
741 * nh_list
742 */
743 if (ospf6->route_table->hook_add)
744 (*ospf6->route_table->hook_add)
745 (route);
746
747 /* route's primary path is similar
748 * to LSA, replace route's primary
749 * path with route's paths list head.
750 */
751 if ((route->path.origin.id ==
752 lsa->header->id) &&
753 (route->path.origin.adv_router
754 == lsa->header->adv_router)) {
755 struct ospf6_path *h_path;
756
757 h_path = (struct ospf6_path *)
758 listgetdata(
759 listhead(route->paths));
760 route->path.origin.type =
761 h_path->origin.type;
762 route->path.origin.id =
763 h_path->origin.id;
764 route->path.origin.adv_router =
765 h_path->origin.adv_router;
766 }
767 } else {
768 ospf6_route_remove(route,
769 ospf6->route_table);
770 }
771 }
772 continue;
773
774 } else {
775 /* Compare LSA origin and cost with current route info.
776 * if any check fails skip del this route node.
777 */
778 if (asbr_entry
779 && (!ospf6_route_is_same_origin(route, route_to_del)
780 || (route->path.type != route_to_del->path.type)
781 || (route->path.cost != route_to_del->path.cost)
782 || (route->path.u.cost_e2
783 != route_to_del->path.u.cost_e2))) {
784 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
785 prefix2str(&prefix, buf, sizeof(buf));
786 zlog_debug(
787 "%s: route %s to delete is not same, cost %u del cost %u. skip",
788 __PRETTY_FUNCTION__, buf,
789 route->path.cost,
790 route_to_del->path.cost);
791 }
792 continue;
793 }
794
795 if ((route->path.origin.type != lsa->header->type)
796 || (route->path.origin.adv_router
797 != lsa->header->adv_router)
798 || (route->path.origin.id != lsa->header->id))
799 continue;
800 }
801 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
802 prefix2str(&route->prefix, buf, sizeof(buf));
803 zlog_debug(
804 "%s: AS-External %u route remove %s cost %u(%u) nh %u",
805 __PRETTY_FUNCTION__,
806 route->path.type == OSPF6_PATH_TYPE_EXTERNAL1
807 ? 1
808 : 2,
809 buf, route->path.cost, route->path.u.cost_e2,
810 listcount(route->nh_list));
811 }
812 ospf6_route_remove(route, ospf6->route_table);
813 }
814 if (route != NULL)
815 ospf6_route_unlock(route);
816
817 ospf6_route_delete(route_to_del);
818 }
819
820 void ospf6_asbr_lsentry_add(struct ospf6_route *asbr_entry)
821 {
822 struct ospf6_lsa *lsa;
823 uint16_t type;
824 uint32_t router;
825
826 if (!CHECK_FLAG(asbr_entry->flag, OSPF6_ROUTE_BEST)) {
827 char buf[16];
828 inet_ntop(AF_INET, &ADV_ROUTER_IN_PREFIX(&asbr_entry->prefix),
829 buf, sizeof(buf));
830 zlog_info("ignore non-best path: lsentry %s add", buf);
831 return;
832 }
833
834 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
835 router = ospf6_linkstate_prefix_adv_router(&asbr_entry->prefix);
836 for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, router, lsa)) {
837 if (!OSPF6_LSA_IS_MAXAGE(lsa))
838 ospf6_asbr_lsa_add(lsa);
839 }
840 }
841
842 void ospf6_asbr_lsentry_remove(struct ospf6_route *asbr_entry)
843 {
844 struct ospf6_lsa *lsa;
845 uint16_t type;
846 uint32_t router;
847
848 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
849 router = ospf6_linkstate_prefix_adv_router(&asbr_entry->prefix);
850 for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, router, lsa))
851 ospf6_asbr_lsa_remove(lsa, asbr_entry);
852 }
853
854
855 /* redistribute function */
856
857 static void ospf6_asbr_routemap_set(int type, const char *mapname)
858 {
859 if (ospf6->rmap[type].name) {
860 route_map_counter_decrement(ospf6->rmap[type].map);
861 free(ospf6->rmap[type].name);
862 }
863 ospf6->rmap[type].name = strdup(mapname);
864 ospf6->rmap[type].map = route_map_lookup_by_name(mapname);
865 route_map_counter_increment(ospf6->rmap[type].map);
866 }
867
868 static void ospf6_asbr_routemap_unset(int type)
869 {
870 if (ospf6->rmap[type].name)
871 free(ospf6->rmap[type].name);
872
873 route_map_counter_decrement(ospf6->rmap[type].map);
874
875 ospf6->rmap[type].name = NULL;
876 ospf6->rmap[type].map = NULL;
877 }
878
879 static int ospf6_asbr_routemap_update_timer(struct thread *thread)
880 {
881 void **arg;
882 int arg_type;
883
884 arg = THREAD_ARG(thread);
885 arg_type = (int)(intptr_t)arg[1];
886
887 ospf6->t_distribute_update = NULL;
888
889 if (ospf6->rmap[arg_type].name)
890 ospf6->rmap[arg_type].map =
891 route_map_lookup_by_name(ospf6->rmap[arg_type].name);
892 if (ospf6->rmap[arg_type].map) {
893 if (IS_OSPF6_DEBUG_ASBR)
894 zlog_debug("%s: route-map %s update, reset redist %s",
895 __PRETTY_FUNCTION__,
896 ospf6->rmap[arg_type].name,
897 ZROUTE_NAME(arg_type));
898
899 ospf6_zebra_no_redistribute(arg_type);
900 ospf6_zebra_redistribute(arg_type);
901 }
902
903 XFREE(MTYPE_OSPF6_DIST_ARGS, arg);
904 return 0;
905 }
906
907 void ospf6_asbr_distribute_list_update(int type)
908 {
909 void **args = NULL;
910
911 if (ospf6->t_distribute_update)
912 return;
913
914 args = XCALLOC(MTYPE_OSPF6_DIST_ARGS, sizeof(void *) * 2);
915
916 args[0] = ospf6;
917 args[1] = (void *)((ptrdiff_t)type);
918
919 if (IS_OSPF6_DEBUG_ASBR)
920 zlog_debug("%s: trigger redistribute %s reset thread",
921 __PRETTY_FUNCTION__, ZROUTE_NAME(type));
922
923 ospf6->t_distribute_update = NULL;
924 thread_add_timer_msec(master, ospf6_asbr_routemap_update_timer,
925 (void **)args, OSPF_MIN_LS_INTERVAL,
926 &ospf6->t_distribute_update);
927 }
928
929 static void ospf6_asbr_routemap_update(const char *mapname)
930 {
931 int type;
932
933 if (ospf6 == NULL)
934 return;
935
936 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
937 if (ospf6->rmap[type].name) {
938 ospf6->rmap[type].map = route_map_lookup_by_name(
939 ospf6->rmap[type].name);
940
941 if (mapname && ospf6->rmap[type].map
942 && (strcmp(ospf6->rmap[type].name, mapname) == 0)) {
943 if (IS_OSPF6_DEBUG_ASBR)
944 zlog_debug(
945 "%s: route-map %s update, reset redist %s",
946 __PRETTY_FUNCTION__, mapname,
947 ZROUTE_NAME(type));
948
949 route_map_counter_increment(
950 ospf6->rmap[type].map);
951
952 ospf6_asbr_distribute_list_update(type);
953 }
954 } else
955 ospf6->rmap[type].map = NULL;
956 }
957 }
958
959 static void ospf6_asbr_routemap_event(const char *name)
960 {
961 int type;
962
963 if (ospf6 == NULL)
964 return;
965 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
966 if ((ospf6->rmap[type].name)
967 && (strcmp(ospf6->rmap[type].name, name) == 0)) {
968 ospf6_asbr_distribute_list_update(type);
969 }
970 }
971 }
972
973 int ospf6_asbr_is_asbr(struct ospf6 *o)
974 {
975 return o->external_table->count;
976 }
977
978 static void ospf6_asbr_redistribute_set(int type)
979 {
980 ospf6_zebra_redistribute(type);
981 }
982
983 static void ospf6_asbr_redistribute_unset(int type)
984 {
985 struct ospf6_route *route;
986 struct ospf6_external_info *info;
987
988 ospf6_zebra_no_redistribute(type);
989
990 for (route = ospf6_route_head(ospf6->external_table); route;
991 route = ospf6_route_next(route)) {
992 info = route->route_option;
993 if (info->type != type)
994 continue;
995
996 ospf6_asbr_redistribute_remove(info->type, 0, &route->prefix);
997 }
998
999 ospf6_asbr_routemap_unset(type);
1000 }
1001
1002 /* When an area is unstubified, flood all the external LSAs in the area */
1003 void ospf6_asbr_send_externals_to_area(struct ospf6_area *oa)
1004 {
1005 struct ospf6_lsa *lsa;
1006
1007 for (ALL_LSDB(oa->ospf6->lsdb, lsa)) {
1008 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_AS_EXTERNAL) {
1009 zlog_debug("%s: Flooding AS-External LSA %s",
1010 __func__, lsa->name);
1011 ospf6_flood_area(NULL, lsa, oa);
1012 }
1013 }
1014 }
1015
1016 void ospf6_asbr_redistribute_add(int type, ifindex_t ifindex,
1017 struct prefix *prefix,
1018 unsigned int nexthop_num,
1019 struct in6_addr *nexthop, route_tag_t tag)
1020 {
1021 route_map_result_t ret;
1022 struct ospf6_route troute;
1023 struct ospf6_external_info tinfo;
1024 struct ospf6_route *route, *match;
1025 struct ospf6_external_info *info;
1026 struct prefix prefix_id;
1027 struct route_node *node;
1028 char pbuf[PREFIX2STR_BUFFER], ibuf[16];
1029 struct listnode *lnode, *lnnode;
1030 struct ospf6_area *oa;
1031
1032 if (!ospf6_zebra_is_redistribute(type))
1033 return;
1034
1035 memset(&troute, 0, sizeof(troute));
1036 memset(&tinfo, 0, sizeof(tinfo));
1037
1038 if (IS_OSPF6_DEBUG_ASBR) {
1039 prefix2str(prefix, pbuf, sizeof(pbuf));
1040 zlog_debug("Redistribute %s (%s)", pbuf, ZROUTE_NAME(type));
1041 }
1042
1043 /* if route-map was specified but not found, do not advertise */
1044 if (ospf6->rmap[type].name) {
1045 if (ospf6->rmap[type].map == NULL)
1046 ospf6_asbr_routemap_update(NULL);
1047 if (ospf6->rmap[type].map == NULL) {
1048 zlog_warn(
1049 "route-map \"%s\" not found, suppress redistributing",
1050 ospf6->rmap[type].name);
1051 return;
1052 }
1053 }
1054
1055 /* apply route-map */
1056 if (ospf6->rmap[type].map) {
1057 troute.route_option = &tinfo;
1058 tinfo.ifindex = ifindex;
1059 tinfo.tag = tag;
1060
1061 ret = route_map_apply(ospf6->rmap[type].map, prefix, RMAP_OSPF6,
1062 &troute);
1063 if (ret == RMAP_DENYMATCH) {
1064 if (IS_OSPF6_DEBUG_ASBR)
1065 zlog_debug("Denied by route-map \"%s\"",
1066 ospf6->rmap[type].name);
1067 return;
1068 }
1069 }
1070
1071 match = ospf6_route_lookup(prefix, ospf6->external_table);
1072 if (match) {
1073 info = match->route_option;
1074 /* copy result of route-map */
1075 if (ospf6->rmap[type].map) {
1076 if (troute.path.metric_type)
1077 match->path.metric_type =
1078 troute.path.metric_type;
1079 if (troute.path.cost)
1080 match->path.cost = troute.path.cost;
1081 if (!IN6_IS_ADDR_UNSPECIFIED(&tinfo.forwarding))
1082 memcpy(&info->forwarding, &tinfo.forwarding,
1083 sizeof(struct in6_addr));
1084 info->tag = tinfo.tag;
1085 } else {
1086 /* If there is no route-map, simply update the tag */
1087 info->tag = tag;
1088 }
1089
1090 info->type = type;
1091
1092 if (nexthop_num && nexthop)
1093 ospf6_route_add_nexthop(match, ifindex, nexthop);
1094 else
1095 ospf6_route_add_nexthop(match, ifindex, NULL);
1096
1097 /* create/update binding in external_id_table */
1098 prefix_id.family = AF_INET;
1099 prefix_id.prefixlen = 32;
1100 prefix_id.u.prefix4.s_addr = htonl(info->id);
1101 node = route_node_get(ospf6->external_id_table, &prefix_id);
1102 node->info = match;
1103
1104 if (IS_OSPF6_DEBUG_ASBR) {
1105 inet_ntop(AF_INET, &prefix_id.u.prefix4, ibuf,
1106 sizeof(ibuf));
1107 prefix2str(prefix, pbuf, sizeof(pbuf));
1108 zlog_debug(
1109 "Advertise as AS-External Id:%s prefix %s metric %u",
1110 ibuf, pbuf, match->path.metric_type);
1111 }
1112
1113 match->path.origin.id = htonl(info->id);
1114 ospf6_as_external_lsa_originate(match);
1115 return;
1116 }
1117
1118 /* create new entry */
1119 route = ospf6_route_create();
1120 route->type = OSPF6_DEST_TYPE_NETWORK;
1121 memcpy(&route->prefix, prefix, sizeof(struct prefix));
1122
1123 info = (struct ospf6_external_info *)XCALLOC(
1124 MTYPE_OSPF6_EXTERNAL_INFO, sizeof(struct ospf6_external_info));
1125 route->route_option = info;
1126 info->id = ospf6->external_id++;
1127
1128 /* copy result of route-map */
1129 if (ospf6->rmap[type].map) {
1130 if (troute.path.metric_type)
1131 route->path.metric_type = troute.path.metric_type;
1132 if (troute.path.cost)
1133 route->path.cost = troute.path.cost;
1134 if (!IN6_IS_ADDR_UNSPECIFIED(&tinfo.forwarding))
1135 memcpy(&info->forwarding, &tinfo.forwarding,
1136 sizeof(struct in6_addr));
1137 info->tag = tinfo.tag;
1138 } else {
1139 /* If there is no route-map, simply set the tag */
1140 info->tag = tag;
1141 }
1142
1143 info->type = type;
1144 if (nexthop_num && nexthop)
1145 ospf6_route_add_nexthop(route, ifindex, nexthop);
1146 else
1147 ospf6_route_add_nexthop(route, ifindex, NULL);
1148
1149 /* create/update binding in external_id_table */
1150 prefix_id.family = AF_INET;
1151 prefix_id.prefixlen = 32;
1152 prefix_id.u.prefix4.s_addr = htonl(info->id);
1153 node = route_node_get(ospf6->external_id_table, &prefix_id);
1154 node->info = route;
1155
1156 route = ospf6_route_add(route, ospf6->external_table);
1157 route->route_option = info;
1158
1159 if (IS_OSPF6_DEBUG_ASBR) {
1160 inet_ntop(AF_INET, &prefix_id.u.prefix4, ibuf, sizeof(ibuf));
1161 prefix2str(prefix, pbuf, sizeof(pbuf));
1162 zlog_debug("Advertise as AS-External Id:%s prefix %s metric %u",
1163 ibuf, pbuf, route->path.metric_type);
1164 }
1165
1166 route->path.origin.id = htonl(info->id);
1167 ospf6_as_external_lsa_originate(route);
1168
1169 /* Router-Bit (ASBR Flag) may have to be updated */
1170 for (ALL_LIST_ELEMENTS(ospf6->area_list, lnode, lnnode, oa))
1171 OSPF6_ROUTER_LSA_SCHEDULE(oa);
1172 }
1173
1174 void ospf6_asbr_redistribute_remove(int type, ifindex_t ifindex,
1175 struct prefix *prefix)
1176 {
1177 struct ospf6_route *match;
1178 struct ospf6_external_info *info = NULL;
1179 struct route_node *node;
1180 struct ospf6_lsa *lsa;
1181 struct prefix prefix_id;
1182 char pbuf[PREFIX2STR_BUFFER], ibuf[16];
1183 struct listnode *lnode, *lnnode;
1184 struct ospf6_area *oa;
1185
1186 match = ospf6_route_lookup(prefix, ospf6->external_table);
1187 if (match == NULL) {
1188 if (IS_OSPF6_DEBUG_ASBR) {
1189 prefix2str(prefix, pbuf, sizeof(pbuf));
1190 zlog_debug("No such route %s to withdraw", pbuf);
1191 }
1192 return;
1193 }
1194
1195 info = match->route_option;
1196 assert(info);
1197
1198 if (info->type != type) {
1199 if (IS_OSPF6_DEBUG_ASBR) {
1200 prefix2str(prefix, pbuf, sizeof(pbuf));
1201 zlog_debug("Original protocol mismatch: %s", pbuf);
1202 }
1203 return;
1204 }
1205
1206 if (IS_OSPF6_DEBUG_ASBR) {
1207 prefix2str(prefix, pbuf, sizeof(pbuf));
1208 inet_ntop(AF_INET, &prefix_id.u.prefix4, ibuf, sizeof(ibuf));
1209 zlog_debug("Withdraw %s (AS-External Id:%s)", pbuf, ibuf);
1210 }
1211
1212 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
1213 htonl(info->id), ospf6->router_id, ospf6->lsdb);
1214 if (lsa)
1215 ospf6_lsa_purge(lsa);
1216
1217 /* remove binding in external_id_table */
1218 prefix_id.family = AF_INET;
1219 prefix_id.prefixlen = 32;
1220 prefix_id.u.prefix4.s_addr = htonl(info->id);
1221 node = route_node_lookup(ospf6->external_id_table, &prefix_id);
1222 assert(node);
1223 node->info = NULL;
1224 route_unlock_node(node); /* to free the lookup lock */
1225 route_unlock_node(node); /* to free the original lock */
1226
1227 ospf6_route_remove(match, ospf6->external_table);
1228 XFREE(MTYPE_OSPF6_EXTERNAL_INFO, info);
1229
1230 /* Router-Bit (ASBR Flag) may have to be updated */
1231 for (ALL_LIST_ELEMENTS(ospf6->area_list, lnode, lnnode, oa))
1232 OSPF6_ROUTER_LSA_SCHEDULE(oa);
1233 }
1234
1235 DEFUN (ospf6_redistribute,
1236 ospf6_redistribute_cmd,
1237 "redistribute " FRR_REDIST_STR_OSPF6D,
1238 "Redistribute\n"
1239 FRR_REDIST_HELP_STR_OSPF6D)
1240 {
1241 int type;
1242
1243 char *proto = argv[argc - 1]->text;
1244 type = proto_redistnum(AFI_IP6, proto);
1245 if (type < 0)
1246 return CMD_WARNING_CONFIG_FAILED;
1247
1248 ospf6_asbr_redistribute_unset(type);
1249 ospf6_asbr_redistribute_set(type);
1250 return CMD_SUCCESS;
1251 }
1252
1253 DEFUN (ospf6_redistribute_routemap,
1254 ospf6_redistribute_routemap_cmd,
1255 "redistribute " FRR_REDIST_STR_OSPF6D " route-map WORD",
1256 "Redistribute\n"
1257 FRR_REDIST_HELP_STR_OSPF6D
1258 "Route map reference\n"
1259 "Route map name\n")
1260 {
1261 int idx_protocol = 1;
1262 int idx_word = 3;
1263 int type;
1264
1265 char *proto = argv[idx_protocol]->text;
1266 type = proto_redistnum(AFI_IP6, proto);
1267 if (type < 0)
1268 return CMD_WARNING_CONFIG_FAILED;
1269
1270 ospf6_asbr_redistribute_unset(type);
1271 ospf6_asbr_routemap_set(type, argv[idx_word]->arg);
1272 ospf6_asbr_redistribute_set(type);
1273 return CMD_SUCCESS;
1274 }
1275
1276 DEFUN (no_ospf6_redistribute,
1277 no_ospf6_redistribute_cmd,
1278 "no redistribute " FRR_REDIST_STR_OSPF6D " [route-map WORD]",
1279 NO_STR
1280 "Redistribute\n"
1281 FRR_REDIST_HELP_STR_OSPF6D
1282 "Route map reference\n"
1283 "Route map name\n")
1284 {
1285 int idx_protocol = 2;
1286 int type;
1287
1288 char *proto = argv[idx_protocol]->text;
1289 type = proto_redistnum(AFI_IP6, proto);
1290 if (type < 0)
1291 return CMD_WARNING_CONFIG_FAILED;
1292
1293 ospf6_asbr_redistribute_unset(type);
1294
1295 return CMD_SUCCESS;
1296 }
1297
1298 int ospf6_redistribute_config_write(struct vty *vty)
1299 {
1300 int type;
1301
1302 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1303 if (type == ZEBRA_ROUTE_OSPF6)
1304 continue;
1305 if (!ospf6_zebra_is_redistribute(type))
1306 continue;
1307
1308 if (ospf6->rmap[type].name)
1309 vty_out(vty, " redistribute %s route-map %s\n",
1310 ZROUTE_NAME(type), ospf6->rmap[type].name);
1311 else
1312 vty_out(vty, " redistribute %s\n", ZROUTE_NAME(type));
1313 }
1314
1315 return 0;
1316 }
1317
1318 static void ospf6_redistribute_show_config(struct vty *vty)
1319 {
1320 int type;
1321 int nroute[ZEBRA_ROUTE_MAX];
1322 int total;
1323 struct ospf6_route *route;
1324 struct ospf6_external_info *info;
1325
1326 total = 0;
1327 for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
1328 nroute[type] = 0;
1329 for (route = ospf6_route_head(ospf6->external_table); route;
1330 route = ospf6_route_next(route)) {
1331 info = route->route_option;
1332 nroute[info->type]++;
1333 total++;
1334 }
1335
1336 vty_out(vty, "Redistributing External Routes from:\n");
1337 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1338 if (type == ZEBRA_ROUTE_OSPF6)
1339 continue;
1340 if (!ospf6_zebra_is_redistribute(type))
1341 continue;
1342
1343 if (ospf6->rmap[type].name)
1344 vty_out(vty, " %d: %s with route-map \"%s\"%s\n",
1345 nroute[type], ZROUTE_NAME(type),
1346 ospf6->rmap[type].name,
1347 (ospf6->rmap[type].map ? ""
1348 : " (not found !)"));
1349 else
1350 vty_out(vty, " %d: %s\n", nroute[type],
1351 ZROUTE_NAME(type));
1352 }
1353 vty_out(vty, "Total %d routes\n", total);
1354 }
1355
1356
1357 /* Routemap Functions */
1358 static enum route_map_cmd_result_t
1359 ospf6_routemap_rule_match_address_prefixlist(void *rule,
1360 const struct prefix *prefix,
1361 route_map_object_t type,
1362 void *object)
1363 {
1364 struct prefix_list *plist;
1365
1366 if (type != RMAP_OSPF6)
1367 return RMAP_NOMATCH;
1368
1369 plist = prefix_list_lookup(AFI_IP6, (char *)rule);
1370 if (plist == NULL)
1371 return RMAP_NOMATCH;
1372
1373 return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
1374 : RMAP_MATCH);
1375 }
1376
1377 static void *
1378 ospf6_routemap_rule_match_address_prefixlist_compile(const char *arg)
1379 {
1380 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1381 }
1382
1383 static void ospf6_routemap_rule_match_address_prefixlist_free(void *rule)
1384 {
1385 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1386 }
1387
1388 struct route_map_rule_cmd ospf6_routemap_rule_match_address_prefixlist_cmd = {
1389 "ipv6 address prefix-list",
1390 ospf6_routemap_rule_match_address_prefixlist,
1391 ospf6_routemap_rule_match_address_prefixlist_compile,
1392 ospf6_routemap_rule_match_address_prefixlist_free,
1393 };
1394
1395 /* `match interface IFNAME' */
1396 /* Match function should return 1 if match is success else return
1397 zero. */
1398 static enum route_map_cmd_result_t
1399 ospf6_routemap_rule_match_interface(void *rule, const struct prefix *prefix,
1400 route_map_object_t type, void *object)
1401 {
1402 struct interface *ifp;
1403 struct ospf6_external_info *ei;
1404
1405 if (type == RMAP_OSPF6) {
1406 ei = ((struct ospf6_route *)object)->route_option;
1407 ifp = if_lookup_by_name((char *)rule, VRF_DEFAULT);
1408
1409 if (ifp != NULL && ei->ifindex == ifp->ifindex)
1410 return RMAP_MATCH;
1411 }
1412
1413 return RMAP_NOMATCH;
1414 }
1415
1416 /* Route map `interface' match statement. `arg' should be
1417 interface name. */
1418 static void *ospf6_routemap_rule_match_interface_compile(const char *arg)
1419 {
1420 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1421 }
1422
1423 /* Free route map's compiled `interface' value. */
1424 static void ospf6_routemap_rule_match_interface_free(void *rule)
1425 {
1426 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1427 }
1428
1429 /* Route map commands for interface matching. */
1430 struct route_map_rule_cmd ospf6_routemap_rule_match_interface_cmd = {
1431 "interface", ospf6_routemap_rule_match_interface,
1432 ospf6_routemap_rule_match_interface_compile,
1433 ospf6_routemap_rule_match_interface_free};
1434
1435 /* Match function for matching route tags */
1436 static enum route_map_cmd_result_t
1437 ospf6_routemap_rule_match_tag(void *rule, const struct prefix *p,
1438 route_map_object_t type, void *object)
1439 {
1440 route_tag_t *tag = rule;
1441 struct ospf6_route *route = object;
1442 struct ospf6_external_info *info = route->route_option;
1443
1444 if (type == RMAP_OSPF6 && info->tag == *tag)
1445 return RMAP_MATCH;
1446
1447 return RMAP_NOMATCH;
1448 }
1449
1450 static struct route_map_rule_cmd ospf6_routemap_rule_match_tag_cmd = {
1451 "tag", ospf6_routemap_rule_match_tag, route_map_rule_tag_compile,
1452 route_map_rule_tag_free,
1453 };
1454
1455 static enum route_map_cmd_result_t
1456 ospf6_routemap_rule_set_metric_type(void *rule, const struct prefix *prefix,
1457 route_map_object_t type, void *object)
1458 {
1459 char *metric_type = rule;
1460 struct ospf6_route *route = object;
1461
1462 if (type != RMAP_OSPF6)
1463 return RMAP_OKAY;
1464
1465 if (strcmp(metric_type, "type-2") == 0)
1466 route->path.metric_type = 2;
1467 else
1468 route->path.metric_type = 1;
1469
1470 return RMAP_OKAY;
1471 }
1472
1473 static void *ospf6_routemap_rule_set_metric_type_compile(const char *arg)
1474 {
1475 if (strcmp(arg, "type-2") && strcmp(arg, "type-1"))
1476 return NULL;
1477 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1478 }
1479
1480 static void ospf6_routemap_rule_set_metric_type_free(void *rule)
1481 {
1482 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1483 }
1484
1485 struct route_map_rule_cmd ospf6_routemap_rule_set_metric_type_cmd = {
1486 "metric-type", ospf6_routemap_rule_set_metric_type,
1487 ospf6_routemap_rule_set_metric_type_compile,
1488 ospf6_routemap_rule_set_metric_type_free,
1489 };
1490
1491 static enum route_map_cmd_result_t
1492 ospf6_routemap_rule_set_metric(void *rule, const struct prefix *prefix,
1493 route_map_object_t type, void *object)
1494 {
1495 char *metric = rule;
1496 struct ospf6_route *route = object;
1497
1498 if (type != RMAP_OSPF6)
1499 return RMAP_OKAY;
1500
1501 route->path.cost = atoi(metric);
1502 return RMAP_OKAY;
1503 }
1504
1505 static void *ospf6_routemap_rule_set_metric_compile(const char *arg)
1506 {
1507 uint32_t metric;
1508 char *endp;
1509 metric = strtoul(arg, &endp, 0);
1510 if (metric > OSPF_LS_INFINITY || *endp != '\0')
1511 return NULL;
1512 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1513 }
1514
1515 static void ospf6_routemap_rule_set_metric_free(void *rule)
1516 {
1517 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1518 }
1519
1520 struct route_map_rule_cmd ospf6_routemap_rule_set_metric_cmd = {
1521 "metric", ospf6_routemap_rule_set_metric,
1522 ospf6_routemap_rule_set_metric_compile,
1523 ospf6_routemap_rule_set_metric_free,
1524 };
1525
1526 static enum route_map_cmd_result_t
1527 ospf6_routemap_rule_set_forwarding(void *rule, const struct prefix *prefix,
1528 route_map_object_t type, void *object)
1529 {
1530 char *forwarding = rule;
1531 struct ospf6_route *route = object;
1532 struct ospf6_external_info *info = route->route_option;
1533
1534 if (type != RMAP_OSPF6)
1535 return RMAP_OKAY;
1536
1537 if (inet_pton(AF_INET6, forwarding, &info->forwarding) != 1) {
1538 memset(&info->forwarding, 0, sizeof(struct in6_addr));
1539 return RMAP_ERROR;
1540 }
1541
1542 return RMAP_OKAY;
1543 }
1544
1545 static void *ospf6_routemap_rule_set_forwarding_compile(const char *arg)
1546 {
1547 struct in6_addr a;
1548 if (inet_pton(AF_INET6, arg, &a) != 1)
1549 return NULL;
1550 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1551 }
1552
1553 static void ospf6_routemap_rule_set_forwarding_free(void *rule)
1554 {
1555 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1556 }
1557
1558 struct route_map_rule_cmd ospf6_routemap_rule_set_forwarding_cmd = {
1559 "forwarding-address", ospf6_routemap_rule_set_forwarding,
1560 ospf6_routemap_rule_set_forwarding_compile,
1561 ospf6_routemap_rule_set_forwarding_free,
1562 };
1563
1564 static enum route_map_cmd_result_t
1565 ospf6_routemap_rule_set_tag(void *rule, const struct prefix *p,
1566 route_map_object_t type, void *object)
1567 {
1568 route_tag_t *tag = rule;
1569 struct ospf6_route *route = object;
1570 struct ospf6_external_info *info = route->route_option;
1571
1572 if (type != RMAP_OSPF6)
1573 return RMAP_OKAY;
1574
1575 info->tag = *tag;
1576 return RMAP_OKAY;
1577 }
1578
1579 static struct route_map_rule_cmd ospf6_routemap_rule_set_tag_cmd = {
1580 "tag", ospf6_routemap_rule_set_tag, route_map_rule_tag_compile,
1581 route_map_rule_tag_free,
1582 };
1583
1584 static int route_map_command_status(struct vty *vty, enum rmap_compile_rets ret)
1585 {
1586 switch (ret) {
1587 case RMAP_RULE_MISSING:
1588 vty_out(vty, "OSPF6 Can't find rule.\n");
1589 return CMD_WARNING_CONFIG_FAILED;
1590 break;
1591 case RMAP_COMPILE_ERROR:
1592 vty_out(vty, "OSPF6 Argument is malformed.\n");
1593 return CMD_WARNING_CONFIG_FAILED;
1594 break;
1595 case RMAP_COMPILE_SUCCESS:
1596 break;
1597 }
1598
1599 return CMD_SUCCESS;
1600 }
1601
1602 /* add "set metric-type" */
1603 DEFUN (ospf6_routemap_set_metric_type,
1604 ospf6_routemap_set_metric_type_cmd,
1605 "set metric-type <type-1|type-2>",
1606 "Set value\n"
1607 "Type of metric\n"
1608 "OSPF6 external type 1 metric\n"
1609 "OSPF6 external type 2 metric\n")
1610 {
1611 VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1612 int idx_external = 2;
1613 enum rmap_compile_rets ret = route_map_add_set(route_map_index,
1614 "metric-type",
1615 argv[idx_external]->arg);
1616
1617 return route_map_command_status(vty, ret);
1618 }
1619
1620 /* delete "set metric-type" */
1621 DEFUN (ospf6_routemap_no_set_metric_type,
1622 ospf6_routemap_no_set_metric_type_cmd,
1623 "no set metric-type [<type-1|type-2>]",
1624 NO_STR
1625 "Set value\n"
1626 "Type of metric\n"
1627 "OSPF6 external type 1 metric\n"
1628 "OSPF6 external type 2 metric\n")
1629 {
1630 VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1631 char *ext = (argc == 4) ? argv[3]->text : NULL;
1632 enum rmap_compile_rets ret = route_map_delete_set(route_map_index,
1633 "metric-type", ext);
1634
1635 return route_map_command_status(vty, ret);
1636 }
1637
1638 /* add "set forwarding-address" */
1639 DEFUN (ospf6_routemap_set_forwarding,
1640 ospf6_routemap_set_forwarding_cmd,
1641 "set forwarding-address X:X::X:X",
1642 "Set value\n"
1643 "Forwarding Address\n"
1644 "IPv6 Address\n")
1645 {
1646 VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1647 int idx_ipv6 = 2;
1648 enum rmap_compile_rets ret = route_map_add_set(route_map_index,
1649 "forwarding-address",
1650 argv[idx_ipv6]->arg);
1651
1652 return route_map_command_status(vty, ret);
1653 }
1654
1655 /* delete "set forwarding-address" */
1656 DEFUN (ospf6_routemap_no_set_forwarding,
1657 ospf6_routemap_no_set_forwarding_cmd,
1658 "no set forwarding-address X:X::X:X",
1659 NO_STR
1660 "Set value\n"
1661 "Forwarding Address\n"
1662 "IPv6 Address\n")
1663 {
1664 VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1665 int idx_ipv6 = 3;
1666 enum rmap_compile_rets ret = route_map_delete_set(route_map_index,
1667 "forwarding-address",
1668 argv[idx_ipv6]->arg);
1669
1670 return route_map_command_status(vty, ret);
1671 }
1672
1673 static void ospf6_routemap_init(void)
1674 {
1675 route_map_init();
1676
1677 route_map_add_hook(ospf6_asbr_routemap_update);
1678 route_map_delete_hook(ospf6_asbr_routemap_update);
1679 route_map_event_hook(ospf6_asbr_routemap_event);
1680
1681 route_map_set_metric_hook(generic_set_add);
1682 route_map_no_set_metric_hook(generic_set_delete);
1683
1684 route_map_match_tag_hook(generic_match_add);
1685 route_map_no_match_tag_hook(generic_match_delete);
1686
1687 route_map_match_ipv6_address_prefix_list_hook(generic_match_add);
1688 route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete);
1689
1690 route_map_match_interface_hook(generic_match_add);
1691 route_map_no_match_interface_hook(generic_match_delete);
1692
1693 route_map_install_match(
1694 &ospf6_routemap_rule_match_address_prefixlist_cmd);
1695 route_map_install_match(&ospf6_routemap_rule_match_interface_cmd);
1696 route_map_install_match(&ospf6_routemap_rule_match_tag_cmd);
1697
1698 route_map_install_set(&ospf6_routemap_rule_set_metric_type_cmd);
1699 route_map_install_set(&ospf6_routemap_rule_set_metric_cmd);
1700 route_map_install_set(&ospf6_routemap_rule_set_forwarding_cmd);
1701 route_map_install_set(&ospf6_routemap_rule_set_tag_cmd);
1702
1703 /* ASE Metric Type (e.g. Type-1/Type-2) */
1704 install_element(RMAP_NODE, &ospf6_routemap_set_metric_type_cmd);
1705 install_element(RMAP_NODE, &ospf6_routemap_no_set_metric_type_cmd);
1706
1707 /* ASE Metric */
1708 install_element(RMAP_NODE, &ospf6_routemap_set_forwarding_cmd);
1709 install_element(RMAP_NODE, &ospf6_routemap_no_set_forwarding_cmd);
1710 }
1711
1712
1713 /* Display functions */
1714 static char *ospf6_as_external_lsa_get_prefix_str(struct ospf6_lsa *lsa,
1715 char *buf, int buflen,
1716 int pos)
1717 {
1718 struct ospf6_as_external_lsa *external;
1719 struct in6_addr in6;
1720 int prefix_length = 0;
1721
1722 if (lsa) {
1723 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
1724 lsa->header);
1725
1726 if (pos == 0) {
1727 ospf6_prefix_in6_addr(&in6, external,
1728 &external->prefix);
1729 prefix_length = external->prefix.prefix_length;
1730 } else {
1731 in6 = *((struct in6_addr
1732 *)((caddr_t)external
1733 + sizeof(struct
1734 ospf6_as_external_lsa)
1735 + OSPF6_PREFIX_SPACE(
1736 external->prefix
1737 .prefix_length)));
1738 }
1739 if (buf) {
1740 inet_ntop(AF_INET6, &in6, buf, buflen);
1741 if (prefix_length)
1742 sprintf(&buf[strlen(buf)], "/%d",
1743 prefix_length);
1744 }
1745 }
1746 return (buf);
1747 }
1748
1749 static int ospf6_as_external_lsa_show(struct vty *vty, struct ospf6_lsa *lsa)
1750 {
1751 struct ospf6_as_external_lsa *external;
1752 char buf[64];
1753
1754 assert(lsa->header);
1755 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
1756 lsa->header);
1757
1758 /* bits */
1759 snprintf(buf, sizeof(buf), "%c%c%c",
1760 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E) ? 'E'
1761 : '-'),
1762 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F) ? 'F'
1763 : '-'),
1764 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T) ? 'T'
1765 : '-'));
1766
1767 vty_out(vty, " Bits: %s\n", buf);
1768 vty_out(vty, " Metric: %5lu\n",
1769 (unsigned long)OSPF6_ASBR_METRIC(external));
1770
1771 ospf6_prefix_options_printbuf(external->prefix.prefix_options, buf,
1772 sizeof(buf));
1773 vty_out(vty, " Prefix Options: %s\n", buf);
1774
1775 vty_out(vty, " Referenced LSType: %d\n",
1776 ntohs(external->prefix.prefix_refer_lstype));
1777
1778 vty_out(vty, " Prefix: %s\n",
1779 ospf6_as_external_lsa_get_prefix_str(lsa, buf, sizeof(buf), 0));
1780
1781 /* Forwarding-Address */
1782 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F)) {
1783 vty_out(vty, " Forwarding-Address: %s\n",
1784 ospf6_as_external_lsa_get_prefix_str(lsa, buf,
1785 sizeof(buf), 1));
1786 }
1787
1788 /* Tag */
1789 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T)) {
1790 vty_out(vty, " Tag: %" ROUTE_TAG_PRI "\n",
1791 ospf6_as_external_lsa_get_tag(lsa));
1792 }
1793
1794 return 0;
1795 }
1796
1797 static void ospf6_asbr_external_route_show(struct vty *vty,
1798 struct ospf6_route *route)
1799 {
1800 struct ospf6_external_info *info = route->route_option;
1801 char prefix[PREFIX2STR_BUFFER], id[16], forwarding[64];
1802 uint32_t tmp_id;
1803
1804 prefix2str(&route->prefix, prefix, sizeof(prefix));
1805 tmp_id = ntohl(info->id);
1806 inet_ntop(AF_INET, &tmp_id, id, sizeof(id));
1807 if (!IN6_IS_ADDR_UNSPECIFIED(&info->forwarding))
1808 inet_ntop(AF_INET6, &info->forwarding, forwarding,
1809 sizeof(forwarding));
1810 else
1811 snprintf(forwarding, sizeof(forwarding), ":: (ifindex %d)",
1812 ospf6_route_get_first_nh_index(route));
1813
1814 vty_out(vty, "%c %-32s %-15s type-%d %5lu %s\n",
1815 zebra_route_char(info->type), prefix, id,
1816 route->path.metric_type,
1817 (unsigned long)(route->path.metric_type == 2
1818 ? route->path.u.cost_e2
1819 : route->path.cost),
1820 forwarding);
1821 }
1822
1823 DEFUN (show_ipv6_ospf6_redistribute,
1824 show_ipv6_ospf6_redistribute_cmd,
1825 "show ipv6 ospf6 redistribute",
1826 SHOW_STR
1827 IP6_STR
1828 OSPF6_STR
1829 "redistributing External information\n"
1830 )
1831 {
1832 struct ospf6_route *route;
1833
1834 OSPF6_CMD_CHECK_RUNNING();
1835
1836 ospf6_redistribute_show_config(vty);
1837
1838 for (route = ospf6_route_head(ospf6->external_table); route;
1839 route = ospf6_route_next(route))
1840 ospf6_asbr_external_route_show(vty, route);
1841
1842 return CMD_SUCCESS;
1843 }
1844
1845 struct ospf6_lsa_handler as_external_handler = {
1846 .lh_type = OSPF6_LSTYPE_AS_EXTERNAL,
1847 .lh_name = "AS-External",
1848 .lh_short_name = "ASE",
1849 .lh_show = ospf6_as_external_lsa_show,
1850 .lh_get_prefix_str = ospf6_as_external_lsa_get_prefix_str,
1851 .lh_debug = 0};
1852
1853 void ospf6_asbr_init(void)
1854 {
1855 ospf6_routemap_init();
1856
1857 ospf6_install_lsa_handler(&as_external_handler);
1858
1859 install_element(VIEW_NODE, &show_ipv6_ospf6_redistribute_cmd);
1860
1861 install_element(OSPF6_NODE, &ospf6_redistribute_cmd);
1862 install_element(OSPF6_NODE, &ospf6_redistribute_routemap_cmd);
1863 install_element(OSPF6_NODE, &no_ospf6_redistribute_cmd);
1864 }
1865
1866 void ospf6_asbr_redistribute_reset(void)
1867 {
1868 int type;
1869
1870 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1871 if (type == ZEBRA_ROUTE_OSPF6)
1872 continue;
1873 if (ospf6_zebra_is_redistribute(type))
1874 ospf6_asbr_redistribute_unset(type);
1875 }
1876 }
1877
1878 void ospf6_asbr_terminate(void)
1879 {
1880 /* Cleanup route maps */
1881 route_map_finish();
1882 }
1883
1884 DEFUN (debug_ospf6_asbr,
1885 debug_ospf6_asbr_cmd,
1886 "debug ospf6 asbr",
1887 DEBUG_STR
1888 OSPF6_STR
1889 "Debug OSPFv3 ASBR function\n"
1890 )
1891 {
1892 OSPF6_DEBUG_ASBR_ON();
1893 return CMD_SUCCESS;
1894 }
1895
1896 DEFUN (no_debug_ospf6_asbr,
1897 no_debug_ospf6_asbr_cmd,
1898 "no debug ospf6 asbr",
1899 NO_STR
1900 DEBUG_STR
1901 OSPF6_STR
1902 "Debug OSPFv3 ASBR function\n"
1903 )
1904 {
1905 OSPF6_DEBUG_ASBR_OFF();
1906 return CMD_SUCCESS;
1907 }
1908
1909 int config_write_ospf6_debug_asbr(struct vty *vty)
1910 {
1911 if (IS_OSPF6_DEBUG_ASBR)
1912 vty_out(vty, "debug ospf6 asbr\n");
1913 return 0;
1914 }
1915
1916 void install_element_ospf6_debug_asbr(void)
1917 {
1918 install_element(ENABLE_NODE, &debug_ospf6_asbr_cmd);
1919 install_element(ENABLE_NODE, &no_debug_ospf6_asbr_cmd);
1920 install_element(CONFIG_NODE, &debug_ospf6_asbr_cmd);
1921 install_element(CONFIG_NODE, &no_debug_ospf6_asbr_cmd);
1922 }
FRRouting mirror