]> 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 #11594 from louis-6wind/lfa-netlink
[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 #include "lib/northbound_cli.h"
34
35 #include "ospf6_proto.h"
36 #include "ospf6_lsa.h"
37 #include "ospf6_lsdb.h"
38 #include "ospf6_route.h"
39 #include "ospf6_zebra.h"
40 #include "ospf6_message.h"
41 #include "ospf6_spf.h"
42
43 #include "ospf6_top.h"
44 #include "ospf6d.h"
45 #include "ospf6_area.h"
46 #include "ospf6_interface.h"
47 #include "ospf6_neighbor.h"
48 #include "ospf6_asbr.h"
49 #include "ospf6_abr.h"
50 #include "ospf6_intra.h"
51 #include "ospf6_flood.h"
52 #include "ospf6_nssa.h"
53 #include "ospf6d.h"
54 #include "ospf6_spf.h"
55 #include "ospf6_nssa.h"
56 #include "ospf6_gr.h"
57 #include "lib/json.h"
58
59 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_EXTERNAL_INFO, "OSPF6 ext. info");
60 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_DIST_ARGS, "OSPF6 Distribute arguments");
61 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_REDISTRIBUTE, "OSPF6 Redistribute arguments");
62 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_EXTERNAL_RT_AGGR, "OSPF6 ASBR Summarisation");
63
64 static void ospf6_asbr_redistribute_set(struct ospf6 *ospf6, int type);
65 static void ospf6_asbr_redistribute_unset(struct ospf6 *ospf6,
66 struct ospf6_redist *red, int type);
67
68 #include "ospf6d/ospf6_asbr_clippy.c"
69
70 unsigned char conf_debug_ospf6_asbr = 0;
71
72 #define ZROUTE_NAME(x) zebra_route_string(x)
73
74 /* Originate Type-5 and Type-7 LSA */
75 static struct ospf6_lsa *ospf6_originate_type5_type7_lsas(
76 struct ospf6_route *route,
77 struct ospf6 *ospf6)
78 {
79 struct ospf6_lsa *lsa;
80 struct listnode *lnode;
81 struct ospf6_area *oa = NULL;
82
83 lsa = ospf6_as_external_lsa_originate(route, ospf6);
84
85 for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, lnode, oa)) {
86 if (IS_AREA_NSSA(oa))
87 ospf6_nssa_lsa_originate(route, oa, true);
88 }
89
90 return lsa;
91 }
92
93 /* AS External LSA origination */
94 struct ospf6_lsa *ospf6_as_external_lsa_originate(struct ospf6_route *route,
95 struct ospf6 *ospf6)
96 {
97 char buffer[OSPF6_MAX_LSASIZE];
98 struct ospf6_lsa_header *lsa_header;
99 struct ospf6_lsa *lsa;
100 struct ospf6_external_info *info = route->route_option;
101
102 struct ospf6_as_external_lsa *as_external_lsa;
103 caddr_t p;
104
105 if (ospf6->gr_info.restart_in_progress) {
106 if (IS_DEBUG_OSPF6_GR)
107 zlog_debug(
108 "Graceful Restart in progress, don't originate LSA");
109 return NULL;
110 }
111
112 if (IS_OSPF6_DEBUG_ASBR || IS_OSPF6_DEBUG_ORIGINATE(AS_EXTERNAL))
113 zlog_debug("Originate AS-External-LSA for %pFX",
114 &route->prefix);
115
116 /* prepare buffer */
117 memset(buffer, 0, sizeof(buffer));
118 lsa_header = (struct ospf6_lsa_header *)buffer;
119 as_external_lsa = (struct ospf6_as_external_lsa
120 *)((caddr_t)lsa_header
121 + sizeof(struct ospf6_lsa_header));
122 p = (caddr_t)((caddr_t)as_external_lsa
123 + sizeof(struct ospf6_as_external_lsa));
124
125 /* Fill AS-External-LSA */
126 /* Metric type */
127 if (route->path.metric_type == 2)
128 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
129 else
130 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
131
132 /* forwarding address */
133 if (!IN6_IS_ADDR_UNSPECIFIED(&info->forwarding))
134 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
135 else
136 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
137
138 /* external route tag */
139 if (info->tag)
140 SET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
141 else
142 UNSET_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
143
144 /* Set metric */
145 OSPF6_ASBR_METRIC_SET(as_external_lsa, route->path.cost);
146
147 /* prefixlen */
148 as_external_lsa->prefix.prefix_length = route->prefix.prefixlen;
149
150 /* PrefixOptions */
151 as_external_lsa->prefix.prefix_options = route->prefix_options;
152
153 /* don't use refer LS-type */
154 as_external_lsa->prefix.prefix_refer_lstype = htons(0);
155
156 /* set Prefix */
157 memcpy(p, &route->prefix.u.prefix6,
158 OSPF6_PREFIX_SPACE(route->prefix.prefixlen));
159 ospf6_prefix_apply_mask(&as_external_lsa->prefix);
160 p += OSPF6_PREFIX_SPACE(route->prefix.prefixlen);
161
162 /* Forwarding address */
163 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F)) {
164 memcpy(p, &info->forwarding, sizeof(struct in6_addr));
165 p += sizeof(struct in6_addr);
166 }
167
168 /* External Route Tag */
169 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T)) {
170 route_tag_t network_order = htonl(info->tag);
171
172 memcpy(p, &network_order, sizeof(network_order));
173 p += sizeof(network_order);
174 }
175
176 /* Fill LSA Header */
177 lsa_header->age = 0;
178 lsa_header->type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
179 lsa_header->id = route->path.origin.id;
180 lsa_header->adv_router = ospf6->router_id;
181 lsa_header->seqnum =
182 ospf6_new_ls_seqnum(lsa_header->type, lsa_header->id,
183 lsa_header->adv_router, ospf6->lsdb);
184 lsa_header->length = htons((caddr_t)p - (caddr_t)lsa_header);
185
186 /* LSA checksum */
187 ospf6_lsa_checksum(lsa_header);
188
189 /* create LSA */
190 lsa = ospf6_lsa_create(lsa_header);
191
192 /* Originate */
193 ospf6_lsa_originate_process(lsa, ospf6);
194
195 return lsa;
196 }
197
198 void ospf6_orig_as_external_lsa(struct thread *thread)
199 {
200 struct ospf6_interface *oi;
201 struct ospf6_lsa *lsa;
202 uint32_t type, adv_router;
203
204 oi = (struct ospf6_interface *)THREAD_ARG(thread);
205
206 if (oi->state == OSPF6_INTERFACE_DOWN)
207 return;
208 if (IS_AREA_NSSA(oi->area) || IS_AREA_STUB(oi->area))
209 return;
210
211 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
212 adv_router = oi->area->ospf6->router_id;
213 for (ALL_LSDB_TYPED_ADVRTR(oi->area->ospf6->lsdb, type, adv_router,
214 lsa)) {
215 if (IS_OSPF6_DEBUG_ASBR)
216 zlog_debug(
217 "%s: Send update of AS-External LSA %s seq 0x%x",
218 __func__, lsa->name,
219 ntohl(lsa->header->seqnum));
220
221 ospf6_flood_interface(NULL, lsa, oi);
222 }
223 }
224
225 static route_tag_t ospf6_as_external_lsa_get_tag(struct ospf6_lsa *lsa)
226 {
227 struct ospf6_as_external_lsa *external;
228 ptrdiff_t tag_offset;
229 route_tag_t network_order;
230
231 if (!lsa)
232 return 0;
233
234 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
235 lsa->header);
236
237 if (!CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T))
238 return 0;
239
240 tag_offset = sizeof(*external)
241 + OSPF6_PREFIX_SPACE(external->prefix.prefix_length);
242 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F))
243 tag_offset += sizeof(struct in6_addr);
244
245 memcpy(&network_order, (caddr_t)external + tag_offset,
246 sizeof(network_order));
247 return ntohl(network_order);
248 }
249
250 void ospf6_asbr_update_route_ecmp_path(struct ospf6_route *old,
251 struct ospf6_route *route,
252 struct ospf6 *ospf6)
253 {
254 struct ospf6_route *old_route, *next_route;
255 struct ospf6_path *ecmp_path, *o_path = NULL;
256 struct listnode *anode, *anext;
257 struct listnode *nnode, *rnode, *rnext;
258 struct ospf6_nexthop *nh, *rnh;
259 bool route_found = false;
260
261 /* check for old entry match with new route origin,
262 * delete old entry.
263 */
264 for (old_route = old; old_route; old_route = next_route) {
265 bool route_updated = false;
266
267 next_route = old_route->next;
268
269 /* The route linked-list is grouped in batches of prefix.
270 * If the new prefix is not the same as the one of interest
271 * then we have walked over the end of the batch and so we
272 * should break rather than continuing unnecessarily.
273 */
274 if (!ospf6_route_is_same(old_route, route))
275 break;
276 if (old_route->path.type != route->path.type)
277 continue;
278
279 /* Current and New route has same origin,
280 * delete old entry.
281 */
282 for (ALL_LIST_ELEMENTS(old_route->paths, anode, anext,
283 o_path)) {
284 /* Check old route path and route has same
285 * origin.
286 */
287 if (o_path->area_id != route->path.area_id
288 || !ospf6_ls_origin_same(o_path, &route->path))
289 continue;
290
291 /* Cost is not same then delete current path */
292 if ((o_path->cost == route->path.cost)
293 && (o_path->u.cost_e2 == route->path.u.cost_e2))
294 continue;
295
296 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
297 zlog_debug(
298 "%s: route %pFX cost old %u new %u is not same, replace route",
299 __func__, &old_route->prefix, o_path->cost,
300 route->path.cost);
301 }
302
303 /* Remove selected current rout path's nh from
304 * effective nh list.
305 */
306 for (ALL_LIST_ELEMENTS_RO(o_path->nh_list, nnode, nh)) {
307 for (ALL_LIST_ELEMENTS(old_route->nh_list,
308 rnode, rnext, rnh)) {
309 if (!ospf6_nexthop_is_same(rnh, nh))
310 continue;
311 listnode_delete(old_route->nh_list,
312 rnh);
313 ospf6_nexthop_delete(rnh);
314 }
315 }
316
317 listnode_delete(old_route->paths, o_path);
318 ospf6_path_free(o_path);
319 route_updated = true;
320
321 /* Current route's path (adv_router info) is similar
322 * to route being added.
323 * Replace current route's path with paths list head.
324 * Update FIB with effective NHs.
325 */
326 if (listcount(old_route->paths)) {
327 for (ALL_LIST_ELEMENTS(old_route->paths,
328 anode, anext, o_path)) {
329 ospf6_merge_nexthops(
330 old_route->nh_list,
331 o_path->nh_list);
332 }
333 /* Update RIB/FIB with effective
334 * nh_list
335 */
336 if (ospf6->route_table->hook_add)
337 (*ospf6->route_table->hook_add)(
338 old_route);
339
340 if (old_route->path.origin.id
341 == route->path.origin.id
342 && old_route->path.origin.adv_router
343 == route->path.origin
344 .adv_router) {
345 struct ospf6_path *h_path;
346
347 h_path = (struct ospf6_path *)
348 listgetdata(listhead(
349 old_route->paths));
350 old_route->path.origin.type =
351 h_path->origin.type;
352 old_route->path.origin.id =
353 h_path->origin.id;
354 old_route->path.origin.adv_router =
355 h_path->origin.adv_router;
356 }
357 } else {
358 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
359 zlog_debug(
360 "%s: route %pFX old cost %u new cost %u, delete old entry.",
361 __func__, &old_route->prefix,
362 old_route->path.cost,
363 route->path.cost);
364 }
365 if (old == old_route)
366 old = next_route;
367 ospf6_route_remove(old_route,
368 ospf6->route_table);
369 }
370 }
371 if (route_updated)
372 break;
373 }
374
375 /* Add new route */
376 for (old_route = old; old_route; old_route = old_route->next) {
377
378 /* The route linked-list is grouped in batches of prefix.
379 * If the new prefix is not the same as the one of interest
380 * then we have walked over the end of the batch and so we
381 * should break rather than continuing unnecessarily.
382 */
383 if (!ospf6_route_is_same(old_route, route))
384 break;
385 if (old_route->path.type != route->path.type)
386 continue;
387
388 /* Old Route and New Route have Equal Cost, Merge NHs */
389 if ((old_route->path.cost == route->path.cost)
390 && (old_route->path.u.cost_e2 == route->path.u.cost_e2)) {
391
392 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
393 zlog_debug(
394 "%s: old route %pFX path cost %u e2 %u",
395 __func__, &old_route->prefix,
396 old_route->path.cost,
397 old_route->path.u.cost_e2);
398 }
399 route_found = true;
400 /* check if this path exists already in
401 * route->paths list, if so, replace nh_list
402 * from asbr_entry.
403 */
404 for (ALL_LIST_ELEMENTS_RO(old_route->paths, anode,
405 o_path)) {
406 if (o_path->area_id == route->path.area_id
407 && ospf6_ls_origin_same(o_path, &route->path))
408 break;
409 }
410 /* If path is not found in old_route paths's list,
411 * add a new path to route paths list and merge
412 * nexthops in route->path->nh_list.
413 * Otherwise replace existing path's nh_list.
414 */
415 if (o_path == NULL) {
416 ecmp_path = ospf6_path_dup(&route->path);
417
418 /* Add a nh_list to new ecmp path */
419 ospf6_copy_nexthops(ecmp_path->nh_list,
420 route->nh_list);
421
422 /* Add the new path to route's path list */
423 listnode_add_sort(old_route->paths, ecmp_path);
424
425 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
426 zlog_debug(
427 "%s: route %pFX another path added with nh %u, effective paths %u nh %u",
428 __func__, &route->prefix,
429 listcount(ecmp_path->nh_list),
430 old_route->paths ? listcount(
431 old_route->paths)
432 : 0,
433 listcount(old_route->nh_list));
434 }
435 } else {
436 list_delete_all_node(o_path->nh_list);
437 ospf6_copy_nexthops(o_path->nh_list,
438 route->nh_list);
439 }
440
441 /* Reset nexthop lists, rebuild from brouter table
442 * for each adv. router.
443 */
444 list_delete_all_node(old_route->nh_list);
445
446 for (ALL_LIST_ELEMENTS_RO(old_route->paths, anode,
447 o_path)) {
448 struct ospf6_route *asbr_entry;
449
450 asbr_entry = ospf6_route_lookup(
451 &o_path->ls_prefix,
452 ospf6->brouter_table);
453 if (asbr_entry == NULL) {
454 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
455 zlog_debug(
456 "%s: ls_prfix %pFX asbr_entry not found.",
457 __func__,
458 &old_route->prefix);
459 continue;
460 }
461 ospf6_route_merge_nexthops(old_route,
462 asbr_entry);
463 }
464
465 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
466 zlog_debug(
467 "%s: route %pFX with effective paths %u nh %u",
468 __func__, &route->prefix,
469 old_route->paths
470 ? listcount(old_route->paths)
471 : 0,
472 old_route->nh_list
473 ? listcount(old_route->nh_list)
474 : 0);
475
476 /* Update RIB/FIB */
477 if (ospf6->route_table->hook_add)
478 (*ospf6->route_table->hook_add)(old_route);
479
480 /* Delete the new route its info added to existing
481 * route.
482 */
483 ospf6_route_delete(route);
484
485 break;
486 }
487 }
488
489 if (!route_found) {
490 /* Add new route to existing node in ospf6 route table. */
491 ospf6_route_add(route, ospf6->route_table);
492 }
493 }
494
495 /* Check if the forwarding address is local address */
496 static int ospf6_ase_forward_address_check(struct ospf6 *ospf6,
497 struct in6_addr *fwd_addr)
498 {
499 struct listnode *anode, *node, *cnode;
500 struct ospf6_interface *oi;
501 struct ospf6_area *oa;
502 struct interface *ifp;
503 struct connected *c;
504
505 for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, anode, oa)) {
506 for (ALL_LIST_ELEMENTS_RO(oa->if_list, node, oi)) {
507 if (!if_is_operative(oi->interface)
508 || oi->type == OSPF_IFTYPE_VIRTUALLINK)
509 continue;
510
511 ifp = oi->interface;
512 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
513 if (IPV6_ADDR_SAME(&c->address->u.prefix6,
514 fwd_addr))
515 return 0;
516 }
517 }
518 }
519
520 return 1;
521 }
522
523 void ospf6_asbr_lsa_add(struct ospf6_lsa *lsa)
524 {
525 struct ospf6_as_external_lsa *external;
526 struct prefix asbr_id;
527 struct ospf6_route *asbr_entry, *route, *old = NULL;
528 struct ospf6_path *path;
529 struct ospf6 *ospf6;
530 int type;
531 struct ospf6_area *oa = NULL;
532 struct prefix fwd_addr;
533 ptrdiff_t offset;
534
535 type = ntohs(lsa->header->type);
536 oa = lsa->lsdb->data;
537
538 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
539 lsa->header);
540
541 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
542 zlog_debug("Calculate AS-External route for %s", lsa->name);
543
544 ospf6 = ospf6_get_by_lsdb(lsa);
545
546 if (lsa->header->adv_router == ospf6->router_id) {
547 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
548 zlog_debug("Ignore self-originated AS-External-LSA");
549 return;
550 }
551
552 if (OSPF6_ASBR_METRIC(external) == OSPF_LS_INFINITY) {
553 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
554 zlog_debug("Ignore LSA with LSInfinity Metric");
555 return;
556 }
557
558 if (CHECK_FLAG(external->prefix.prefix_options,
559 OSPF6_PREFIX_OPTION_NU)) {
560 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
561 zlog_debug("Ignore LSA with NU bit set Metric");
562 return;
563 }
564
565 ospf6_linkstate_prefix(lsa->header->adv_router, htonl(0), &asbr_id);
566 asbr_entry = ospf6_route_lookup(&asbr_id, ospf6->brouter_table);
567 if (asbr_entry == NULL) {
568 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
569 zlog_debug("ASBR entry not found: %pFX", &asbr_id);
570 return;
571 } else {
572 /* The router advertising external LSA can be ASBR or ABR */
573 if (!CHECK_FLAG(asbr_entry->path.router_bits,
574 OSPF6_ROUTER_BIT_E)) {
575 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
576 zlog_debug(
577 "External bit reset ASBR route entry : %pFX",
578 &asbr_id);
579 return;
580 }
581
582 /*
583 * RFC 3101 - Section 2.5:
584 * "For a Type-7 LSA the matching routing table entry must
585 * specify an intra-area path through the LSA's originating
586 * NSSA".
587 */
588 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7
589 && (asbr_entry->path.area_id != oa->area_id
590 || asbr_entry->path.type != OSPF6_PATH_TYPE_INTRA)) {
591 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
592 zlog_debug(
593 "Intra-area route to NSSA ASBR not found: %pFX",
594 &asbr_id);
595 return;
596 }
597 }
598
599 /*
600 * RFC 3101 - Section 2.5:
601 * "If the destination is a Type-7 default route (destination ID =
602 * DefaultDestination) and one of the following is true, then do
603 * nothing with this LSA and consider the next in the list:
604 *
605 * o The calculating router is a border router and the LSA has
606 * its P-bit clear. Appendix E describes a technique
607 * whereby an NSSA border router installs a Type-7 default
608 * LSA without propagating it.
609 *
610 * o The calculating router is a border router and is
611 * suppressing the import of summary routes as Type-3
612 * summary-LSAs".
613 */
614 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7
615 && external->prefix.prefix_length == 0
616 && CHECK_FLAG(ospf6->flag, OSPF6_FLAG_ABR)
617 && (CHECK_FLAG(external->prefix.prefix_options,
618 OSPF6_PREFIX_OPTION_P)
619 || oa->no_summary)) {
620 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
621 zlog_debug("Skipping Type-7 default route");
622 return;
623 }
624
625 /* Check the forwarding address */
626 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F)) {
627 offset = sizeof(*external)
628 + OSPF6_PREFIX_SPACE(external->prefix.prefix_length);
629 memset(&fwd_addr, 0, sizeof(fwd_addr));
630 fwd_addr.family = AF_INET6;
631 fwd_addr.prefixlen = IPV6_MAX_BITLEN;
632 memcpy(&fwd_addr.u.prefix6, (caddr_t)external + offset,
633 sizeof(struct in6_addr));
634
635 if (!IN6_IS_ADDR_UNSPECIFIED(&fwd_addr.u.prefix6)) {
636 if (!ospf6_ase_forward_address_check(
637 ospf6, &fwd_addr.u.prefix6)) {
638 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
639 zlog_debug(
640 "Fwd address %pFX is local address",
641 &fwd_addr);
642 return;
643 }
644
645 /* Find the forwarding entry */
646 asbr_entry = ospf6_route_lookup_bestmatch(
647 &fwd_addr, ospf6->route_table);
648 if (asbr_entry == NULL) {
649 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
650 zlog_debug(
651 "Fwd address not found: %pFX",
652 &fwd_addr);
653 return;
654 }
655 }
656 }
657
658 route = ospf6_route_create(ospf6);
659 route->type = OSPF6_DEST_TYPE_NETWORK;
660 route->prefix.family = AF_INET6;
661 route->prefix.prefixlen = external->prefix.prefix_length;
662 ospf6_prefix_in6_addr(&route->prefix.u.prefix6, external,
663 &external->prefix);
664 route->prefix_options = external->prefix.prefix_options;
665
666 route->path.area_id = asbr_entry->path.area_id;
667 route->path.origin.type = lsa->header->type;
668 route->path.origin.id = lsa->header->id;
669 route->path.origin.adv_router = lsa->header->adv_router;
670 memcpy(&route->path.ls_prefix, &asbr_id, sizeof(struct prefix));
671
672 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E)) {
673 route->path.type = OSPF6_PATH_TYPE_EXTERNAL2;
674 route->path.metric_type = 2;
675 route->path.cost = asbr_entry->path.cost;
676 route->path.u.cost_e2 = OSPF6_ASBR_METRIC(external);
677 } else {
678 route->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
679 route->path.metric_type = 1;
680 route->path.cost =
681 asbr_entry->path.cost + OSPF6_ASBR_METRIC(external);
682 route->path.u.cost_e2 = 0;
683 }
684
685 route->path.tag = ospf6_as_external_lsa_get_tag(lsa);
686
687 ospf6_route_copy_nexthops(route, asbr_entry);
688
689 path = ospf6_path_dup(&route->path);
690 ospf6_copy_nexthops(path->nh_list, asbr_entry->nh_list);
691 listnode_add_sort(route->paths, path);
692
693
694 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
695 zlog_debug(
696 "%s: %s %u route add %pFX cost %u(%u) nh %u", __func__,
697 (type == OSPF6_LSTYPE_AS_EXTERNAL) ? "AS-External"
698 : "NSSA",
699 (route->path.type == OSPF6_PATH_TYPE_EXTERNAL1) ? 1 : 2,
700 &route->prefix, route->path.cost, route->path.u.cost_e2,
701 listcount(route->nh_list));
702
703 if (type == OSPF6_LSTYPE_AS_EXTERNAL)
704 old = ospf6_route_lookup(&route->prefix, ospf6->route_table);
705 else if (type == OSPF6_LSTYPE_TYPE_7)
706 old = ospf6_route_lookup(&route->prefix, oa->route_table);
707 if (!old) {
708 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
709 zlog_debug("%s: Adding new route", __func__);
710 /* Add the new route to ospf6 instance route table. */
711 if (type == OSPF6_LSTYPE_AS_EXTERNAL)
712 ospf6_route_add(route, ospf6->route_table);
713 /* Add the route to the area route table */
714 else if (type == OSPF6_LSTYPE_TYPE_7) {
715 ospf6_route_add(route, oa->route_table);
716 }
717 } else {
718 /* RFC 2328 16.4 (6)
719 * ECMP: Keep new equal preference path in current
720 * route's path list, update zebra with new effective
721 * list along with addition of ECMP path.
722 */
723 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL))
724 zlog_debug("%s : old route %pFX cost %u(%u) nh %u",
725 __func__, &route->prefix, route->path.cost,
726 route->path.u.cost_e2,
727 listcount(route->nh_list));
728 ospf6_asbr_update_route_ecmp_path(old, route, ospf6);
729 }
730 }
731
732 void ospf6_asbr_lsa_remove(struct ospf6_lsa *lsa,
733 struct ospf6_route *asbr_entry)
734 {
735 struct ospf6_as_external_lsa *external;
736 struct prefix prefix;
737 struct ospf6_route *route, *nroute, *route_to_del;
738 struct ospf6_area *oa = NULL;
739 struct ospf6 *ospf6;
740 int type;
741 bool debug = false;
742
743 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
744 lsa->header);
745
746 if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL) || (IS_OSPF6_DEBUG_NSSA))
747 debug = true;
748
749 ospf6 = ospf6_get_by_lsdb(lsa);
750 type = ntohs(lsa->header->type);
751
752 if (type == OSPF6_LSTYPE_TYPE_7) {
753 if (debug)
754 zlog_debug("%s: Withdraw Type 7 route for %s",
755 __func__, lsa->name);
756 oa = lsa->lsdb->data;
757 } else {
758 if (debug)
759 zlog_debug("%s: Withdraw AS-External route for %s",
760 __func__, lsa->name);
761
762 if (ospf6_check_and_set_router_abr(ospf6))
763 oa = ospf6->backbone;
764 else
765 oa = listnode_head(ospf6->area_list);
766 }
767
768 if (oa == NULL) {
769 if (debug)
770 zlog_debug("%s: Invalid area", __func__);
771 return;
772 }
773
774 if (lsa->header->adv_router == oa->ospf6->router_id) {
775 if (debug)
776 zlog_debug("Ignore self-originated AS-External-LSA");
777 return;
778 }
779
780 route_to_del = ospf6_route_create(ospf6);
781 route_to_del->type = OSPF6_DEST_TYPE_NETWORK;
782 route_to_del->prefix.family = AF_INET6;
783 route_to_del->prefix.prefixlen = external->prefix.prefix_length;
784 ospf6_prefix_in6_addr(&route_to_del->prefix.u.prefix6, external,
785 &external->prefix);
786
787 route_to_del->path.origin.type = lsa->header->type;
788 route_to_del->path.origin.id = lsa->header->id;
789 route_to_del->path.origin.adv_router = lsa->header->adv_router;
790
791 if (asbr_entry) {
792 route_to_del->path.area_id = asbr_entry->path.area_id;
793 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E)) {
794 route_to_del->path.type = OSPF6_PATH_TYPE_EXTERNAL2;
795 route_to_del->path.metric_type = 2;
796 route_to_del->path.cost = asbr_entry->path.cost;
797 route_to_del->path.u.cost_e2 =
798 OSPF6_ASBR_METRIC(external);
799 } else {
800 route_to_del->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
801 route_to_del->path.metric_type = 1;
802 route_to_del->path.cost = asbr_entry->path.cost
803 + OSPF6_ASBR_METRIC(external);
804 route_to_del->path.u.cost_e2 = 0;
805 }
806 }
807
808 memset(&prefix, 0, sizeof(struct prefix));
809 prefix.family = AF_INET6;
810 prefix.prefixlen = external->prefix.prefix_length;
811 ospf6_prefix_in6_addr(&prefix.u.prefix6, external, &external->prefix);
812
813 if (type == OSPF6_LSTYPE_TYPE_7)
814 route = ospf6_route_lookup(&prefix, oa->route_table);
815 else
816 route = ospf6_route_lookup(&prefix, oa->ospf6->route_table);
817
818 if (route == NULL) {
819 if (debug)
820 zlog_debug("AS-External route %pFX not found", &prefix);
821 ospf6_route_delete(route_to_del);
822 return;
823 }
824
825 if (debug)
826 zlog_debug(
827 "%s: Current route %pFX cost %u e2 %u, route to del cost %u e2 %u",
828 __func__, &prefix, route->path.cost, route->path.u.cost_e2,
829 route_to_del->path.cost, route_to_del->path.u.cost_e2);
830
831 for (ospf6_route_lock(route);
832 route && ospf6_route_is_prefix(&prefix, route); route = nroute) {
833 nroute = ospf6_route_next(route);
834
835 if (route->type != OSPF6_DEST_TYPE_NETWORK)
836 continue;
837
838 /* Route has multiple ECMP paths, remove matching
839 * path. Update current route's effective nh list
840 * after removal of one of the path.
841 */
842 if (listcount(route->paths) > 1) {
843 struct listnode *anode, *anext;
844 struct listnode *nnode, *rnode, *rnext;
845 struct ospf6_nexthop *nh, *rnh;
846 struct ospf6_path *o_path;
847 bool nh_updated = false;
848
849 /* Iterate all paths of route to find maching with LSA
850 * remove from route path list. If route->path is same,
851 * replace from paths list.
852 */
853 for (ALL_LIST_ELEMENTS(route->paths, anode, anext,
854 o_path)) {
855 if ((o_path->origin.type != lsa->header->type)
856 || (o_path->origin.adv_router
857 != lsa->header->adv_router)
858 || (o_path->origin.id != lsa->header->id))
859 continue;
860
861 /* Compare LSA cost with current
862 * route info.
863 */
864 if (asbr_entry
865 && (o_path->cost != route_to_del->path.cost
866 || o_path->u.cost_e2
867 != route_to_del->path.u
868 .cost_e2)) {
869 if (IS_OSPF6_DEBUG_EXAMIN(
870 AS_EXTERNAL)) {
871 zlog_debug(
872 "%s: route %pFX to delete is not same, cost %u del cost %u. skip",
873 __func__, &prefix,
874 route->path.cost,
875 route_to_del->path
876 .cost);
877 }
878 continue;
879 }
880
881 if (debug) {
882 zlog_debug(
883 "%s: route %pFX path found with cost %u nh %u to remove.",
884 __func__, &prefix, route->path.cost,
885 listcount(o_path->nh_list));
886 }
887
888 /* Remove found path's nh_list from
889 * the route's nh_list.
890 */
891 for (ALL_LIST_ELEMENTS_RO(o_path->nh_list,
892 nnode, nh)) {
893 for (ALL_LIST_ELEMENTS(route->nh_list,
894 rnode, rnext,
895 rnh)) {
896 if (!ospf6_nexthop_is_same(rnh,
897 nh))
898 continue;
899 listnode_delete(route->nh_list,
900 rnh);
901 ospf6_nexthop_delete(rnh);
902 }
903 }
904 /* Delete the path from route's path list */
905 listnode_delete(route->paths, o_path);
906 ospf6_path_free(o_path);
907 nh_updated = true;
908 }
909
910 if (nh_updated) {
911 /* Iterate all paths and merge nexthop,
912 * unlesss any of the nexthop similar to
913 * ones deleted as part of path deletion.
914 */
915
916 for (ALL_LIST_ELEMENTS(route->paths, anode,
917 anext, o_path)) {
918 ospf6_merge_nexthops(route->nh_list,
919 o_path->nh_list);
920 }
921
922 if (debug) {
923 zlog_debug(
924 "%s: AS-External %u route %pFX update paths %u nh %u",
925 __func__,
926 (route->path.type
927 == OSPF6_PATH_TYPE_EXTERNAL1)
928 ? 1
929 : 2,
930 &route->prefix, listcount(route->paths),
931 route->nh_list ? listcount(
932 route->nh_list)
933 : 0);
934 }
935
936 if (listcount(route->paths)) {
937 /* Update RIB/FIB with effective
938 * nh_list
939 */
940 if (oa->ospf6->route_table->hook_add)
941 (*oa->ospf6->route_table
942 ->hook_add)(route);
943
944 /* route's primary path is similar
945 * to LSA, replace route's primary
946 * path with route's paths list head.
947 */
948 if ((route->path.origin.id ==
949 lsa->header->id) &&
950 (route->path.origin.adv_router
951 == lsa->header->adv_router)) {
952 struct ospf6_path *h_path;
953
954 h_path = (struct ospf6_path *)
955 listgetdata(
956 listhead(route->paths));
957 route->path.origin.type =
958 h_path->origin.type;
959 route->path.origin.id =
960 h_path->origin.id;
961 route->path.origin.adv_router =
962 h_path->origin.adv_router;
963 }
964 } else {
965 if (type == OSPF6_LSTYPE_TYPE_7)
966 ospf6_route_remove(
967 route, oa->route_table);
968 else
969 ospf6_route_remove(
970 route,
971 oa->ospf6->route_table);
972 }
973 }
974 continue;
975
976 } else {
977 /* Compare LSA origin and cost with current route info.
978 * if any check fails skip del this route node.
979 */
980 if (asbr_entry
981 && (!ospf6_route_is_same_origin(route, route_to_del)
982 || (route->path.type != route_to_del->path.type)
983 || (route->path.cost != route_to_del->path.cost)
984 || (route->path.u.cost_e2
985 != route_to_del->path.u.cost_e2))) {
986 if (debug) {
987 zlog_debug(
988 "%s: route %pFX to delete is not same, cost %u del cost %u. skip",
989 __func__, &prefix, route->path.cost,
990 route_to_del->path.cost);
991 }
992 continue;
993 }
994
995 if ((route->path.origin.type != lsa->header->type)
996 || (route->path.origin.adv_router
997 != lsa->header->adv_router)
998 || (route->path.origin.id != lsa->header->id))
999 continue;
1000 }
1001 if (debug) {
1002 zlog_debug(
1003 "%s: AS-External %u route remove %pFX cost %u(%u) nh %u",
1004 __func__,
1005 route->path.type == OSPF6_PATH_TYPE_EXTERNAL1
1006 ? 1
1007 : 2,
1008 &route->prefix, route->path.cost, route->path.u.cost_e2,
1009 listcount(route->nh_list));
1010 }
1011 if (type == OSPF6_LSTYPE_TYPE_7)
1012 ospf6_route_remove(route, oa->route_table);
1013 else
1014 ospf6_route_remove(route, oa->ospf6->route_table);
1015 }
1016 if (route != NULL)
1017 ospf6_route_unlock(route);
1018
1019 ospf6_route_delete(route_to_del);
1020 }
1021
1022 void ospf6_asbr_lsentry_add(struct ospf6_route *asbr_entry, struct ospf6 *ospf6)
1023 {
1024 struct ospf6_lsa *lsa;
1025 uint16_t type;
1026 uint32_t router;
1027
1028 if (!CHECK_FLAG(asbr_entry->flag, OSPF6_ROUTE_BEST)) {
1029 char buf[16];
1030 inet_ntop(AF_INET, &ADV_ROUTER_IN_PREFIX(&asbr_entry->prefix),
1031 buf, sizeof(buf));
1032 zlog_info("ignore non-best path: lsentry %s add", buf);
1033 return;
1034 }
1035
1036 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
1037 router = ospf6_linkstate_prefix_adv_router(&asbr_entry->prefix);
1038 for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, router, lsa)) {
1039 if (!OSPF6_LSA_IS_MAXAGE(lsa))
1040 ospf6_asbr_lsa_add(lsa);
1041 }
1042 }
1043
1044 void ospf6_asbr_lsentry_remove(struct ospf6_route *asbr_entry,
1045 struct ospf6 *ospf6)
1046 {
1047 struct ospf6_lsa *lsa;
1048 uint16_t type;
1049 uint32_t router;
1050
1051 type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
1052 router = ospf6_linkstate_prefix_adv_router(&asbr_entry->prefix);
1053 for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, router, lsa))
1054 ospf6_asbr_lsa_remove(lsa, asbr_entry);
1055 }
1056
1057
1058 /* redistribute function */
1059 static void ospf6_asbr_routemap_set(struct ospf6_redist *red,
1060 const char *mapname)
1061 {
1062 if (ROUTEMAP_NAME(red)) {
1063 route_map_counter_decrement(ROUTEMAP(red));
1064 free(ROUTEMAP_NAME(red));
1065 }
1066
1067 ROUTEMAP_NAME(red) = strdup(mapname);
1068 ROUTEMAP(red) = route_map_lookup_by_name(mapname);
1069 route_map_counter_increment(ROUTEMAP(red));
1070 }
1071
1072 static void ospf6_asbr_routemap_unset(struct ospf6_redist *red)
1073 {
1074 if (ROUTEMAP_NAME(red))
1075 free(ROUTEMAP_NAME(red));
1076
1077 route_map_counter_decrement(ROUTEMAP(red));
1078
1079 ROUTEMAP_NAME(red) = NULL;
1080 ROUTEMAP(red) = NULL;
1081 }
1082
1083 static void ospf6_asbr_routemap_update_timer(struct thread *thread)
1084 {
1085 struct ospf6 *ospf6 = THREAD_ARG(thread);
1086 struct ospf6_redist *red;
1087 int type;
1088
1089 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1090 red = ospf6_redist_lookup(ospf6, type, 0);
1091
1092 if (!red)
1093 continue;
1094
1095 if (!CHECK_FLAG(red->flag, OSPF6_IS_RMAP_CHANGED))
1096 continue;
1097
1098 if (ROUTEMAP_NAME(red))
1099 ROUTEMAP(red) =
1100 route_map_lookup_by_name(ROUTEMAP_NAME(red));
1101
1102 if (ROUTEMAP(red)) {
1103 if (IS_OSPF6_DEBUG_ASBR)
1104 zlog_debug(
1105 "%s: route-map %s update, reset redist %s",
1106 __func__, ROUTEMAP_NAME(red),
1107 ZROUTE_NAME(type));
1108
1109 ospf6_zebra_no_redistribute(type, ospf6->vrf_id);
1110 ospf6_zebra_redistribute(type, ospf6->vrf_id);
1111 }
1112
1113 UNSET_FLAG(red->flag, OSPF6_IS_RMAP_CHANGED);
1114 }
1115 }
1116
1117 void ospf6_asbr_distribute_list_update(struct ospf6 *ospf6,
1118 struct ospf6_redist *red)
1119 {
1120 SET_FLAG(red->flag, OSPF6_IS_RMAP_CHANGED);
1121
1122 if (thread_is_scheduled(ospf6->t_distribute_update))
1123 return;
1124
1125 if (IS_OSPF6_DEBUG_ASBR)
1126 zlog_debug("%s: trigger redistribute reset thread", __func__);
1127
1128 thread_add_timer_msec(master, ospf6_asbr_routemap_update_timer, ospf6,
1129 OSPF_MIN_LS_INTERVAL,
1130 &ospf6->t_distribute_update);
1131 }
1132
1133 void ospf6_asbr_routemap_update(const char *mapname)
1134 {
1135 int type;
1136 struct listnode *node, *nnode;
1137 struct ospf6 *ospf6 = NULL;
1138 struct ospf6_redist *red;
1139
1140 if (om6 == NULL)
1141 return;
1142
1143 for (ALL_LIST_ELEMENTS(om6->ospf6, node, nnode, ospf6)) {
1144 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1145 red = ospf6_redist_lookup(ospf6, type, 0);
1146 if (!red || (ROUTEMAP_NAME(red) == NULL))
1147 continue;
1148 ROUTEMAP(red) =
1149 route_map_lookup_by_name(ROUTEMAP_NAME(red));
1150
1151 if (mapname == NULL
1152 || strcmp(ROUTEMAP_NAME(red), mapname))
1153 continue;
1154 if (ROUTEMAP(red)) {
1155 if (IS_OSPF6_DEBUG_ASBR)
1156 zlog_debug(
1157 "%s: route-map %s update, reset redist %s",
1158 __func__,
1159 mapname,
1160 ZROUTE_NAME(
1161 type));
1162
1163 route_map_counter_increment(ROUTEMAP(red));
1164 ospf6_asbr_distribute_list_update(ospf6, red);
1165 } else {
1166 /*
1167 * if the mapname matches a
1168 * route-map on ospf6 but the
1169 * map doesn't exist, it is
1170 * being deleted. flush and then
1171 * readvertise
1172 */
1173 if (IS_OSPF6_DEBUG_ASBR)
1174 zlog_debug(
1175 "%s: route-map %s deleted, reset redist %s",
1176 __func__,
1177 mapname,
1178 ZROUTE_NAME(
1179 type));
1180 ospf6_asbr_redistribute_unset(ospf6, red, type);
1181 ospf6_asbr_routemap_set(red, mapname);
1182 ospf6_asbr_redistribute_set(ospf6, type);
1183 }
1184 }
1185 }
1186 }
1187
1188 static void ospf6_asbr_routemap_event(const char *name)
1189 {
1190 int type;
1191 struct listnode *node, *nnode;
1192 struct ospf6 *ospf6;
1193 struct ospf6_redist *red;
1194
1195 if (om6 == NULL)
1196 return;
1197 for (ALL_LIST_ELEMENTS(om6->ospf6, node, nnode, ospf6)) {
1198 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1199 red = ospf6_redist_lookup(ospf6, type, 0);
1200 if (red && ROUTEMAP_NAME(red)
1201 && (strcmp(ROUTEMAP_NAME(red), name) == 0))
1202 ospf6_asbr_distribute_list_update(ospf6, red);
1203 }
1204 }
1205 }
1206
1207 int ospf6_asbr_is_asbr(struct ospf6 *o)
1208 {
1209 return (o->external_table->count || IS_OSPF6_ASBR(o));
1210 }
1211
1212 struct ospf6_redist *ospf6_redist_lookup(struct ospf6 *ospf6, int type,
1213 unsigned short instance)
1214 {
1215 struct list *red_list;
1216 struct listnode *node;
1217 struct ospf6_redist *red;
1218
1219 red_list = ospf6->redist[type];
1220 if (!red_list)
1221 return (NULL);
1222
1223 for (ALL_LIST_ELEMENTS_RO(red_list, node, red))
1224 if (red->instance == instance)
1225 return red;
1226
1227 return NULL;
1228 }
1229
1230 static struct ospf6_redist *ospf6_redist_add(struct ospf6 *ospf6, int type,
1231 uint8_t instance)
1232 {
1233 struct ospf6_redist *red;
1234
1235 red = ospf6_redist_lookup(ospf6, type, instance);
1236 if (red)
1237 return red;
1238
1239 if (!ospf6->redist[type])
1240 ospf6->redist[type] = list_new();
1241
1242 red = XCALLOC(MTYPE_OSPF6_REDISTRIBUTE, sizeof(struct ospf6_redist));
1243 red->instance = instance;
1244 red->dmetric.type = -1;
1245 red->dmetric.value = -1;
1246 ROUTEMAP_NAME(red) = NULL;
1247 ROUTEMAP(red) = NULL;
1248
1249 listnode_add(ospf6->redist[type], red);
1250 ospf6->redistribute++;
1251
1252 return red;
1253 }
1254
1255 static void ospf6_redist_del(struct ospf6 *ospf6, struct ospf6_redist *red,
1256 int type)
1257 {
1258 if (red) {
1259 listnode_delete(ospf6->redist[type], red);
1260 if (!ospf6->redist[type]->count) {
1261 list_delete(&ospf6->redist[type]);
1262 }
1263 XFREE(MTYPE_OSPF6_REDISTRIBUTE, red);
1264 ospf6->redistribute--;
1265 }
1266 }
1267
1268 /*Set the status of the ospf instance to ASBR based on the status parameter,
1269 * rechedule SPF calculation, originate router LSA*/
1270 void ospf6_asbr_status_update(struct ospf6 *ospf6, int status)
1271 {
1272 struct listnode *lnode, *lnnode;
1273 struct ospf6_area *oa;
1274
1275 zlog_info("ASBR[%s:Status:%d]: Update", ospf6->name, status);
1276
1277 if (status) {
1278 if (IS_OSPF6_ASBR(ospf6)) {
1279 zlog_info("ASBR[%s:Status:%d]: Already ASBR",
1280 ospf6->name, status);
1281 return;
1282 }
1283 SET_FLAG(ospf6->flag, OSPF6_FLAG_ASBR);
1284 } else {
1285 if (!IS_OSPF6_ASBR(ospf6)) {
1286 zlog_info("ASBR[%s:Status:%d]: Already non ASBR",
1287 ospf6->name, status);
1288 return;
1289 }
1290 UNSET_FLAG(ospf6->flag, OSPF6_FLAG_ASBR);
1291 }
1292
1293 /* Transition from/to status ASBR, schedule timer. */
1294 ospf6_spf_schedule(ospf6, OSPF6_SPF_FLAGS_ASBR_STATUS_CHANGE);
1295
1296 /* Reoriginate router LSA for all areas */
1297 for (ALL_LIST_ELEMENTS(ospf6->area_list, lnode, lnnode, oa))
1298 OSPF6_ROUTER_LSA_SCHEDULE(oa);
1299 }
1300
1301 static void ospf6_asbr_redistribute_set(struct ospf6 *ospf6, int type)
1302 {
1303 ospf6_zebra_redistribute(type, ospf6->vrf_id);
1304
1305 ++ospf6->redist_count;
1306 ospf6_asbr_status_update(ospf6, ospf6->redist_count);
1307 }
1308
1309 static void ospf6_asbr_redistribute_unset(struct ospf6 *ospf6,
1310 struct ospf6_redist *red, int type)
1311 {
1312 struct ospf6_route *route;
1313 struct ospf6_external_info *info;
1314
1315 ospf6_zebra_no_redistribute(type, ospf6->vrf_id);
1316
1317 for (route = ospf6_route_head(ospf6->external_table); route;
1318 route = ospf6_route_next(route)) {
1319 info = route->route_option;
1320 if (info->type != type)
1321 continue;
1322
1323 ospf6_asbr_redistribute_remove(info->type, 0, &route->prefix,
1324 ospf6);
1325 }
1326
1327 ospf6_asbr_routemap_unset(red);
1328 --ospf6->redist_count;
1329 ospf6_asbr_status_update(ospf6, ospf6->redist_count);
1330 }
1331
1332 /* When an area is unstubified, flood all the external LSAs in the area */
1333 void ospf6_asbr_send_externals_to_area(struct ospf6_area *oa)
1334 {
1335 struct ospf6_lsa *lsa, *lsanext;
1336
1337 for (ALL_LSDB(oa->ospf6->lsdb, lsa, lsanext)) {
1338 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_AS_EXTERNAL) {
1339 if (IS_OSPF6_DEBUG_ASBR)
1340 zlog_debug("%s: Flooding AS-External LSA %s",
1341 __func__, lsa->name);
1342
1343 ospf6_flood_area(NULL, lsa, oa);
1344 }
1345 }
1346 }
1347
1348 /* When an area is stubified, remove all the external LSAs in the area */
1349 void ospf6_asbr_remove_externals_from_area(struct ospf6_area *oa)
1350 {
1351 struct ospf6_lsa *lsa, *lsanext;
1352 struct listnode *node, *nnode;
1353 struct ospf6_area *area;
1354 struct ospf6 *ospf6 = oa->ospf6;
1355 const struct route_node *iterend;
1356
1357 /* skip if router is in other non-stub/non-NSSA areas */
1358 for (ALL_LIST_ELEMENTS(ospf6->area_list, node, nnode, area))
1359 if (!IS_AREA_STUB(area) && !IS_AREA_NSSA(area))
1360 return;
1361
1362 /* if router is only in a stub area then purge AS-External LSAs */
1363 iterend = ospf6_lsdb_head(ospf6->lsdb, 0, 0, 0, &lsa);
1364 while (lsa != NULL) {
1365 assert(lsa->lock > 1);
1366 lsanext = ospf6_lsdb_next(iterend, lsa);
1367 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_AS_EXTERNAL)
1368 ospf6_lsdb_remove(lsa, ospf6->lsdb);
1369 lsa = lsanext;
1370 }
1371 }
1372
1373 static struct ospf6_external_aggr_rt *
1374 ospf6_external_aggr_match(struct ospf6 *ospf6, struct prefix *p)
1375 {
1376 struct route_node *node;
1377
1378 node = route_node_match(ospf6->rt_aggr_tbl, p);
1379 if (node == NULL)
1380 return NULL;
1381
1382 if (IS_OSPF6_DEBUG_AGGR) {
1383 struct ospf6_external_aggr_rt *ag = node->info;
1384 zlog_debug("%s: Matching aggregator found.prefix: %pFX Aggregator %pFX",
1385 __func__,
1386 p,
1387 &ag->p);
1388 }
1389
1390 route_unlock_node(node);
1391
1392 return node->info;
1393 }
1394
1395 void ospf6_asbr_redistribute_add(int type, ifindex_t ifindex,
1396 struct prefix *prefix,
1397 unsigned int nexthop_num,
1398 struct in6_addr *nexthop, route_tag_t tag,
1399 struct ospf6 *ospf6)
1400 {
1401 route_map_result_t ret;
1402 struct ospf6_route troute;
1403 struct ospf6_external_info tinfo;
1404 struct ospf6_route *route, *match;
1405 struct ospf6_external_info *info;
1406 struct ospf6_redist *red;
1407
1408 red = ospf6_redist_lookup(ospf6, type, 0);
1409
1410 if (!red)
1411 return;
1412
1413 if ((type != DEFAULT_ROUTE)
1414 && !ospf6_zebra_is_redistribute(type, ospf6->vrf_id))
1415 return;
1416
1417 memset(&troute, 0, sizeof(troute));
1418 memset(&tinfo, 0, sizeof(tinfo));
1419
1420 if (IS_OSPF6_DEBUG_ASBR)
1421 zlog_debug("Redistribute %pFX (%s)", prefix,
1422 type == DEFAULT_ROUTE
1423 ? "default-information-originate"
1424 : ZROUTE_NAME(type));
1425
1426 /* if route-map was specified but not found, do not advertise */
1427 if (ROUTEMAP_NAME(red)) {
1428 if (ROUTEMAP(red) == NULL)
1429 ospf6_asbr_routemap_update(NULL);
1430 if (ROUTEMAP(red) == NULL) {
1431 zlog_warn(
1432 "route-map \"%s\" not found, suppress redistributing",
1433 ROUTEMAP_NAME(red));
1434 return;
1435 }
1436 }
1437
1438 /* apply route-map */
1439 if (ROUTEMAP(red)) {
1440 troute.route_option = &tinfo;
1441 troute.ospf6 = ospf6;
1442 tinfo.ifindex = ifindex;
1443 tinfo.tag = tag;
1444
1445 ret = route_map_apply(ROUTEMAP(red), prefix, &troute);
1446 if (ret == RMAP_DENYMATCH) {
1447 if (IS_OSPF6_DEBUG_ASBR)
1448 zlog_debug("Denied by route-map \"%s\"",
1449 ROUTEMAP_NAME(red));
1450 ospf6_asbr_redistribute_remove(type, ifindex, prefix,
1451 ospf6);
1452 return;
1453 }
1454 }
1455
1456 match = ospf6_route_lookup(prefix, ospf6->external_table);
1457 if (match) {
1458 info = match->route_option;
1459 /* copy result of route-map */
1460 if (ROUTEMAP(red)) {
1461 if (troute.path.metric_type)
1462 match->path.metric_type =
1463 troute.path.metric_type;
1464 else
1465 match->path.metric_type =
1466 metric_type(ospf6, type, 0);
1467 if (troute.path.cost)
1468 match->path.cost = troute.path.cost;
1469 else
1470 match->path.cost = metric_value(ospf6, type, 0);
1471
1472 if (!IN6_IS_ADDR_UNSPECIFIED(&tinfo.forwarding))
1473 memcpy(&info->forwarding, &tinfo.forwarding,
1474 sizeof(struct in6_addr));
1475 info->tag = tinfo.tag;
1476 } else {
1477 /* If there is no route-map, simply update the tag and
1478 * metric fields
1479 */
1480 match->path.metric_type = metric_type(ospf6, type, 0);
1481 match->path.cost = metric_value(ospf6, type, 0);
1482 info->tag = tag;
1483 }
1484
1485 info->type = type;
1486
1487 if (nexthop_num && nexthop)
1488 ospf6_route_add_nexthop(match, ifindex, nexthop);
1489 else
1490 ospf6_route_add_nexthop(match, ifindex, NULL);
1491
1492 match->path.origin.id = htonl(info->id);
1493 ospf6_handle_external_lsa_origination(ospf6, match, prefix);
1494
1495 ospf6_asbr_status_update(ospf6, ospf6->redistribute);
1496
1497 return;
1498 }
1499
1500 /* create new entry */
1501 route = ospf6_route_create(ospf6);
1502 route->type = OSPF6_DEST_TYPE_NETWORK;
1503 prefix_copy(&route->prefix, prefix);
1504
1505 info = (struct ospf6_external_info *)XCALLOC(
1506 MTYPE_OSPF6_EXTERNAL_INFO, sizeof(struct ospf6_external_info));
1507 route->route_option = info;
1508
1509 /* copy result of route-map */
1510 if (ROUTEMAP(red)) {
1511 if (troute.path.metric_type)
1512 route->path.metric_type = troute.path.metric_type;
1513 else
1514 route->path.metric_type = metric_type(ospf6, type, 0);
1515 if (troute.path.cost)
1516 route->path.cost = troute.path.cost;
1517 else
1518 route->path.cost = metric_value(ospf6, type, 0);
1519 if (!IN6_IS_ADDR_UNSPECIFIED(&tinfo.forwarding))
1520 memcpy(&info->forwarding, &tinfo.forwarding,
1521 sizeof(struct in6_addr));
1522 info->tag = tinfo.tag;
1523 } else {
1524 /* If there is no route-map, simply update the tag and metric
1525 * fields
1526 */
1527 route->path.metric_type = metric_type(ospf6, type, 0);
1528 route->path.cost = metric_value(ospf6, type, 0);
1529 info->tag = tag;
1530 }
1531
1532 info->type = type;
1533 if (nexthop_num && nexthop)
1534 ospf6_route_add_nexthop(route, ifindex, nexthop);
1535 else
1536 ospf6_route_add_nexthop(route, ifindex, NULL);
1537
1538 route = ospf6_route_add(route, ospf6->external_table);
1539 ospf6_handle_external_lsa_origination(ospf6, route, prefix);
1540
1541 ospf6_asbr_status_update(ospf6, ospf6->redistribute);
1542
1543 }
1544
1545 static void ospf6_asbr_external_lsa_remove_by_id(struct ospf6 *ospf6,
1546 uint32_t id)
1547 {
1548 struct ospf6_lsa *lsa;
1549
1550 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
1551 htonl(id), ospf6->router_id, ospf6->lsdb);
1552 if (!lsa)
1553 return;
1554
1555 ospf6_external_lsa_purge(ospf6, lsa);
1556
1557 }
1558
1559 static void
1560 ospf6_link_route_to_aggr(struct ospf6_external_aggr_rt *aggr,
1561 struct ospf6_route *rt)
1562 {
1563 (void)hash_get(aggr->match_extnl_hash, rt, hash_alloc_intern);
1564 rt->aggr_route = aggr;
1565 }
1566
1567 static void
1568 ospf6_asbr_summary_remove_lsa_and_route(struct ospf6 *ospf6,
1569 struct ospf6_external_aggr_rt *aggr)
1570 {
1571
1572 /* Send a Max age LSA if it is already originated.*/
1573 if (!CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED))
1574 return;
1575
1576 if (IS_OSPF6_DEBUG_AGGR)
1577 zlog_debug("%s: Flushing Aggregate route (%pFX)",
1578 __func__,
1579 &aggr->p);
1580
1581 ospf6_asbr_external_lsa_remove_by_id(ospf6, aggr->id);
1582
1583 if (aggr->route) {
1584 if (IS_OSPF6_DEBUG_AGGR)
1585 zlog_debug(
1586 "%s: Remove the blackhole route",
1587 __func__);
1588 ospf6_zebra_route_update_remove(aggr->route, ospf6);
1589 ospf6_route_delete(aggr->route);
1590 aggr->route = NULL;
1591 }
1592
1593 aggr->id = 0;
1594 /* Unset the Origination flag */
1595 UNSET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED);
1596 }
1597
1598 static void
1599 ospf6_unlink_route_from_aggr(struct ospf6 *ospf6,
1600 struct ospf6_external_aggr_rt *aggr,
1601 struct ospf6_route *rt)
1602 {
1603 if (IS_OSPF6_DEBUG_AGGR)
1604 zlog_debug("%s: Unlinking external route(%pFX) from aggregator(%pFX), external route count:%ld",
1605 __func__,
1606 &rt->prefix,
1607 &aggr->p,
1608 OSPF6_EXTERNAL_RT_COUNT(aggr));
1609
1610 hash_release(aggr->match_extnl_hash, rt);
1611 rt->aggr_route = NULL;
1612
1613 /* Flush the aggregate route if matching
1614 * external route count becomes zero.
1615 */
1616 if (!OSPF6_EXTERNAL_RT_COUNT(aggr))
1617 ospf6_asbr_summary_remove_lsa_and_route(ospf6, aggr);
1618 }
1619
1620 void ospf6_asbr_redistribute_remove(int type, ifindex_t ifindex,
1621 struct prefix *prefix, struct ospf6 *ospf6)
1622 {
1623 struct ospf6_route *match;
1624 struct ospf6_external_info *info = NULL;
1625
1626 match = ospf6_route_lookup(prefix, ospf6->external_table);
1627 if (match == NULL) {
1628 if (IS_OSPF6_DEBUG_ASBR)
1629 zlog_debug("No such route %pFX to withdraw", prefix);
1630 return;
1631 }
1632
1633 info = match->route_option;
1634 assert(info);
1635
1636 if (info->type != type) {
1637 if (IS_OSPF6_DEBUG_ASBR)
1638 zlog_debug("Original protocol mismatch: %pFX", prefix);
1639 return;
1640 }
1641
1642 /* This means aggregation on this route was not done, hence remove LSA
1643 * if any originated for this prefix
1644 */
1645 if (!match->aggr_route)
1646 ospf6_asbr_external_lsa_remove_by_id(ospf6, info->id);
1647 else
1648 ospf6_unlink_route_from_aggr(ospf6, match->aggr_route, match);
1649
1650 if (IS_OSPF6_DEBUG_ASBR)
1651 zlog_debug("Removing route from external table %pFX",
1652 prefix);
1653
1654 ospf6_route_remove(match, ospf6->external_table);
1655 XFREE(MTYPE_OSPF6_EXTERNAL_INFO, info);
1656
1657 ospf6_asbr_status_update(ospf6, ospf6->redistribute);
1658 }
1659
1660 DEFPY (ospf6_redistribute,
1661 ospf6_redistribute_cmd,
1662 "redistribute " FRR_REDIST_STR_OSPF6D "[{metric (0-16777214)|metric-type (1-2)$metric_type|route-map RMAP_NAME$rmap_str}]",
1663 "Redistribute\n"
1664 FRR_REDIST_HELP_STR_OSPF6D
1665 "Metric for redistributed routes\n"
1666 "OSPF default metric\n"
1667 "OSPF exterior metric type for redistributed routes\n"
1668 "Set OSPF External Type 1/2 metrics\n"
1669 "Route map reference\n"
1670 "Route map name\n")
1671 {
1672 int type;
1673 struct ospf6_redist *red;
1674 int idx_protocol = 1;
1675 char *proto = argv[idx_protocol]->text;
1676
1677 VTY_DECLVAR_CONTEXT(ospf6, ospf6);
1678
1679 type = proto_redistnum(AFI_IP6, proto);
1680 if (type < 0)
1681 return CMD_WARNING_CONFIG_FAILED;
1682
1683 if (!metric_str)
1684 metric = -1;
1685 if (!metric_type_str)
1686 metric_type = -1;
1687
1688 red = ospf6_redist_lookup(ospf6, type, 0);
1689 if (!red) {
1690 red = ospf6_redist_add(ospf6, type, 0);
1691 } else {
1692 /* Check if nothing has changed. */
1693 if (red->dmetric.value == metric
1694 && red->dmetric.type == metric_type
1695 && ((!ROUTEMAP_NAME(red) && !rmap_str)
1696 || (ROUTEMAP_NAME(red) && rmap_str
1697 && strmatch(ROUTEMAP_NAME(red), rmap_str))))
1698 return CMD_SUCCESS;
1699
1700 ospf6_asbr_redistribute_unset(ospf6, red, type);
1701 }
1702
1703 red->dmetric.value = metric;
1704 red->dmetric.type = metric_type;
1705 if (rmap_str)
1706 ospf6_asbr_routemap_set(red, rmap_str);
1707 else
1708 ospf6_asbr_routemap_unset(red);
1709 ospf6_asbr_redistribute_set(ospf6, type);
1710
1711 return CMD_SUCCESS;
1712 }
1713
1714 DEFUN (no_ospf6_redistribute,
1715 no_ospf6_redistribute_cmd,
1716 "no redistribute " FRR_REDIST_STR_OSPF6D "[{metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
1717 NO_STR
1718 "Redistribute\n"
1719 FRR_REDIST_HELP_STR_OSPF6D
1720 "Metric for redistributed routes\n"
1721 "OSPF default metric\n"
1722 "OSPF exterior metric type for redistributed routes\n"
1723 "Set OSPF External Type 1/2 metrics\n"
1724 "Route map reference\n"
1725 "Route map name\n")
1726 {
1727 int type;
1728 struct ospf6_redist *red;
1729 int idx_protocol = 2;
1730 char *proto = argv[idx_protocol]->text;
1731
1732 VTY_DECLVAR_CONTEXT(ospf6, ospf6);
1733
1734 type = proto_redistnum(AFI_IP6, proto);
1735 if (type < 0)
1736 return CMD_WARNING_CONFIG_FAILED;
1737
1738 red = ospf6_redist_lookup(ospf6, type, 0);
1739 if (!red)
1740 return CMD_SUCCESS;
1741
1742 ospf6_asbr_redistribute_unset(ospf6, red, type);
1743 ospf6_redist_del(ospf6, red, type);
1744
1745 return CMD_SUCCESS;
1746 }
1747
1748 int ospf6_redistribute_config_write(struct vty *vty, struct ospf6 *ospf6)
1749 {
1750 int type;
1751 struct ospf6_redist *red;
1752
1753 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1754 red = ospf6_redist_lookup(ospf6, type, 0);
1755 if (!red)
1756 continue;
1757 if (type == ZEBRA_ROUTE_OSPF6)
1758 continue;
1759
1760 vty_out(vty, " redistribute %s", ZROUTE_NAME(type));
1761 if (red->dmetric.value >= 0)
1762 vty_out(vty, " metric %d", red->dmetric.value);
1763 if (red->dmetric.type == 1)
1764 vty_out(vty, " metric-type 1");
1765 if (ROUTEMAP_NAME(red))
1766 vty_out(vty, " route-map %s", ROUTEMAP_NAME(red));
1767 vty_out(vty, "\n");
1768 }
1769
1770 return 0;
1771 }
1772
1773 static void ospf6_redistribute_show_config(struct vty *vty, struct ospf6 *ospf6,
1774 json_object *json_array,
1775 json_object *json, bool use_json)
1776 {
1777 int type;
1778 int nroute[ZEBRA_ROUTE_MAX];
1779 int total;
1780 struct ospf6_route *route;
1781 struct ospf6_external_info *info;
1782 json_object *json_route;
1783 struct ospf6_redist *red;
1784
1785 total = 0;
1786 memset(nroute, 0, sizeof(nroute));
1787 for (route = ospf6_route_head(ospf6->external_table); route;
1788 route = ospf6_route_next(route)) {
1789 info = route->route_option;
1790 nroute[info->type]++;
1791 total++;
1792 }
1793
1794 if (!use_json)
1795 vty_out(vty, "Redistributing External Routes from:\n");
1796
1797 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
1798
1799 red = ospf6_redist_lookup(ospf6, type, 0);
1800
1801 if (!red)
1802 continue;
1803 if (type == ZEBRA_ROUTE_OSPF6)
1804 continue;
1805
1806 if (use_json) {
1807 json_route = json_object_new_object();
1808 json_object_string_add(json_route, "routeType",
1809 ZROUTE_NAME(type));
1810 json_object_int_add(json_route, "numberOfRoutes",
1811 nroute[type]);
1812 json_object_boolean_add(json_route,
1813 "routeMapNamePresent",
1814 ROUTEMAP_NAME(red));
1815 }
1816
1817 if (ROUTEMAP_NAME(red)) {
1818 if (use_json) {
1819 json_object_string_add(json_route,
1820 "routeMapName",
1821 ROUTEMAP_NAME(red));
1822 json_object_boolean_add(json_route,
1823 "routeMapFound",
1824 ROUTEMAP(red));
1825 } else
1826 vty_out(vty,
1827 " %d: %s with route-map \"%s\"%s\n",
1828 nroute[type], ZROUTE_NAME(type),
1829 ROUTEMAP_NAME(red),
1830 (ROUTEMAP(red) ? ""
1831 : " (not found !)"));
1832 } else {
1833 if (!use_json)
1834 vty_out(vty, " %d: %s\n", nroute[type],
1835 ZROUTE_NAME(type));
1836 }
1837
1838 if (use_json)
1839 json_object_array_add(json_array, json_route);
1840 }
1841 if (use_json) {
1842 json_object_object_add(json, "redistributedRoutes", json_array);
1843 json_object_int_add(json, "totalRoutes", total);
1844 } else
1845 vty_out(vty, "Total %d routes\n", total);
1846 }
1847
1848 static void ospf6_redistribute_default_set(struct ospf6 *ospf6, int originate)
1849 {
1850 struct prefix_ipv6 p = {};
1851 struct in6_addr nexthop = {};
1852 int cur_originate = ospf6->default_originate;
1853
1854 p.family = AF_INET6;
1855 p.prefixlen = 0;
1856
1857 ospf6->default_originate = originate;
1858
1859 switch (cur_originate) {
1860 case DEFAULT_ORIGINATE_NONE:
1861 break;
1862 case DEFAULT_ORIGINATE_ZEBRA:
1863 zclient_redistribute_default(ZEBRA_REDISTRIBUTE_DEFAULT_DELETE,
1864 zclient, AFI_IP6, ospf6->vrf_id);
1865 ospf6_asbr_redistribute_remove(DEFAULT_ROUTE, 0,
1866 (struct prefix *)&p, ospf6);
1867
1868 break;
1869 case DEFAULT_ORIGINATE_ALWAYS:
1870 ospf6_asbr_redistribute_remove(DEFAULT_ROUTE, 0,
1871 (struct prefix *)&p, ospf6);
1872 break;
1873 }
1874
1875 switch (originate) {
1876 case DEFAULT_ORIGINATE_NONE:
1877 break;
1878 case DEFAULT_ORIGINATE_ZEBRA:
1879 zclient_redistribute_default(ZEBRA_REDISTRIBUTE_DEFAULT_ADD,
1880 zclient, AFI_IP6, ospf6->vrf_id);
1881
1882 break;
1883 case DEFAULT_ORIGINATE_ALWAYS:
1884 ospf6_asbr_redistribute_add(DEFAULT_ROUTE, 0,
1885 (struct prefix *)&p, 0, &nexthop, 0,
1886 ospf6);
1887 break;
1888 }
1889 }
1890
1891 /* Default Route originate. */
1892 DEFPY (ospf6_default_route_originate,
1893 ospf6_default_route_originate_cmd,
1894 "default-information originate [{always$always|metric (0-16777214)$mval|metric-type (1-2)$mtype|route-map RMAP_NAME$rtmap}]",
1895 "Control distribution of default route\n"
1896 "Distribute a default route\n"
1897 "Always advertise default route\n"
1898 "OSPFv3 default metric\n"
1899 "OSPFv3 metric\n"
1900 "OSPFv3 metric type for default routes\n"
1901 "Set OSPFv3 External Type 1/2 metrics\n"
1902 "Route map reference\n"
1903 "Pointer to route-map entries\n")
1904 {
1905 int default_originate = DEFAULT_ORIGINATE_ZEBRA;
1906 struct ospf6_redist *red;
1907 bool sameRtmap = false;
1908
1909 VTY_DECLVAR_CONTEXT(ospf6, ospf6);
1910
1911 int cur_originate = ospf6->default_originate;
1912
1913 red = ospf6_redist_add(ospf6, DEFAULT_ROUTE, 0);
1914
1915 if (always != NULL)
1916 default_originate = DEFAULT_ORIGINATE_ALWAYS;
1917
1918 if (mval_str == NULL)
1919 mval = -1;
1920
1921 if (mtype_str == NULL)
1922 mtype = -1;
1923
1924 /* To check if user is providing same route map */
1925 if ((!rtmap && !ROUTEMAP_NAME(red)) ||
1926 (rtmap && ROUTEMAP_NAME(red) &&
1927 (strcmp(rtmap, ROUTEMAP_NAME(red)) == 0)))
1928 sameRtmap = true;
1929
1930 /* Don't allow if the same lsa is already originated. */
1931 if ((sameRtmap) && (red->dmetric.type == mtype)
1932 && (red->dmetric.value == mval)
1933 && (cur_originate == default_originate))
1934 return CMD_SUCCESS;
1935
1936 /* Updating Metric details */
1937 red->dmetric.type = mtype;
1938 red->dmetric.value = mval;
1939
1940 /* updating route map details */
1941 if (rtmap)
1942 ospf6_asbr_routemap_set(red, rtmap);
1943 else
1944 ospf6_asbr_routemap_unset(red);
1945
1946 ospf6_redistribute_default_set(ospf6, default_originate);
1947 return CMD_SUCCESS;
1948 }
1949
1950 DEFPY (no_ospf6_default_information_originate,
1951 no_ospf6_default_information_originate_cmd,
1952 "no default-information originate [{always|metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
1953 NO_STR
1954 "Control distribution of default information\n"
1955 "Distribute a default route\n"
1956 "Always advertise default route\n"
1957 "OSPFv3 default metric\n"
1958 "OSPFv3 metric\n"
1959 "OSPFv3 metric type for default routes\n"
1960 "Set OSPFv3 External Type 1/2 metrics\n"
1961 "Route map reference\n"
1962 "Pointer to route-map entries\n")
1963 {
1964 struct ospf6_redist *red;
1965
1966 VTY_DECLVAR_CONTEXT(ospf6, ospf6);
1967
1968 red = ospf6_redist_lookup(ospf6, DEFAULT_ROUTE, 0);
1969 if (!red)
1970 return CMD_SUCCESS;
1971
1972 ospf6_asbr_routemap_unset(red);
1973 ospf6_redist_del(ospf6, red, DEFAULT_ROUTE);
1974
1975 ospf6_redistribute_default_set(ospf6, DEFAULT_ORIGINATE_NONE);
1976 return CMD_SUCCESS;
1977 }
1978
1979 /* Routemap Functions */
1980 static enum route_map_cmd_result_t
1981 ospf6_routemap_rule_match_address_prefixlist(void *rule,
1982 const struct prefix *prefix,
1983
1984 void *object)
1985 {
1986 struct prefix_list *plist;
1987
1988 plist = prefix_list_lookup(AFI_IP6, (char *)rule);
1989 if (plist == NULL)
1990 return RMAP_NOMATCH;
1991
1992 return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
1993 : RMAP_MATCH);
1994 }
1995
1996 static void *
1997 ospf6_routemap_rule_match_address_prefixlist_compile(const char *arg)
1998 {
1999 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2000 }
2001
2002 static void ospf6_routemap_rule_match_address_prefixlist_free(void *rule)
2003 {
2004 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2005 }
2006
2007 static const struct route_map_rule_cmd
2008 ospf6_routemap_rule_match_address_prefixlist_cmd = {
2009 "ipv6 address prefix-list",
2010 ospf6_routemap_rule_match_address_prefixlist,
2011 ospf6_routemap_rule_match_address_prefixlist_compile,
2012 ospf6_routemap_rule_match_address_prefixlist_free,
2013 };
2014
2015 /* `match interface IFNAME' */
2016 /* Match function should return 1 if match is success else return
2017 zero. */
2018 static enum route_map_cmd_result_t
2019 ospf6_routemap_rule_match_interface(void *rule, const struct prefix *prefix,
2020 void *object)
2021 {
2022 struct interface *ifp;
2023 struct ospf6_route *route;
2024 struct ospf6_external_info *ei;
2025
2026 route = object;
2027 ei = route->route_option;
2028 ifp = if_lookup_by_name((char *)rule, route->ospf6->vrf_id);
2029
2030 if (ifp != NULL && ei->ifindex == ifp->ifindex)
2031 return RMAP_MATCH;
2032
2033 return RMAP_NOMATCH;
2034 }
2035
2036 /* Route map `interface' match statement. `arg' should be
2037 interface name. */
2038 static void *ospf6_routemap_rule_match_interface_compile(const char *arg)
2039 {
2040 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2041 }
2042
2043 /* Free route map's compiled `interface' value. */
2044 static void ospf6_routemap_rule_match_interface_free(void *rule)
2045 {
2046 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2047 }
2048
2049 /* Route map commands for interface matching. */
2050 static const struct route_map_rule_cmd
2051 ospf6_routemap_rule_match_interface_cmd = {
2052 "interface",
2053 ospf6_routemap_rule_match_interface,
2054 ospf6_routemap_rule_match_interface_compile,
2055 ospf6_routemap_rule_match_interface_free
2056 };
2057
2058 /* Match function for matching route tags */
2059 static enum route_map_cmd_result_t
2060 ospf6_routemap_rule_match_tag(void *rule, const struct prefix *p, void *object)
2061 {
2062 route_tag_t *tag = rule;
2063 struct ospf6_route *route = object;
2064 struct ospf6_external_info *info = route->route_option;
2065
2066 if (info->tag == *tag)
2067 return RMAP_MATCH;
2068
2069 return RMAP_NOMATCH;
2070 }
2071
2072 static const struct route_map_rule_cmd
2073 ospf6_routemap_rule_match_tag_cmd = {
2074 "tag",
2075 ospf6_routemap_rule_match_tag,
2076 route_map_rule_tag_compile,
2077 route_map_rule_tag_free,
2078 };
2079
2080 static enum route_map_cmd_result_t
2081 ospf6_routemap_rule_set_metric_type(void *rule, const struct prefix *prefix,
2082 void *object)
2083 {
2084 char *metric_type = rule;
2085 struct ospf6_route *route = object;
2086
2087 if (strcmp(metric_type, "type-2") == 0)
2088 route->path.metric_type = 2;
2089 else
2090 route->path.metric_type = 1;
2091
2092 return RMAP_OKAY;
2093 }
2094
2095 static void *ospf6_routemap_rule_set_metric_type_compile(const char *arg)
2096 {
2097 if (strcmp(arg, "type-2") && strcmp(arg, "type-1"))
2098 return NULL;
2099 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2100 }
2101
2102 static void ospf6_routemap_rule_set_metric_type_free(void *rule)
2103 {
2104 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2105 }
2106
2107 static const struct route_map_rule_cmd
2108 ospf6_routemap_rule_set_metric_type_cmd = {
2109 "metric-type",
2110 ospf6_routemap_rule_set_metric_type,
2111 ospf6_routemap_rule_set_metric_type_compile,
2112 ospf6_routemap_rule_set_metric_type_free,
2113 };
2114
2115 static enum route_map_cmd_result_t
2116 ospf6_routemap_rule_set_metric(void *rule, const struct prefix *prefix,
2117 void *object)
2118 {
2119 char *metric = rule;
2120 struct ospf6_route *route = object;
2121
2122 route->path.cost = atoi(metric);
2123 return RMAP_OKAY;
2124 }
2125
2126 static void *ospf6_routemap_rule_set_metric_compile(const char *arg)
2127 {
2128 uint32_t metric;
2129 char *endp;
2130 metric = strtoul(arg, &endp, 0);
2131 if (metric > OSPF_LS_INFINITY || *endp != '\0')
2132 return NULL;
2133 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2134 }
2135
2136 static void ospf6_routemap_rule_set_metric_free(void *rule)
2137 {
2138 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2139 }
2140
2141 static const struct route_map_rule_cmd
2142 ospf6_routemap_rule_set_metric_cmd = {
2143 "metric",
2144 ospf6_routemap_rule_set_metric,
2145 ospf6_routemap_rule_set_metric_compile,
2146 ospf6_routemap_rule_set_metric_free,
2147 };
2148
2149 static enum route_map_cmd_result_t
2150 ospf6_routemap_rule_set_forwarding(void *rule, const struct prefix *prefix,
2151 void *object)
2152 {
2153 char *forwarding = rule;
2154 struct ospf6_route *route = object;
2155 struct ospf6_external_info *info = route->route_option;
2156
2157 if (inet_pton(AF_INET6, forwarding, &info->forwarding) != 1) {
2158 memset(&info->forwarding, 0, sizeof(struct in6_addr));
2159 return RMAP_ERROR;
2160 }
2161
2162 return RMAP_OKAY;
2163 }
2164
2165 static void *ospf6_routemap_rule_set_forwarding_compile(const char *arg)
2166 {
2167 struct in6_addr a;
2168 if (inet_pton(AF_INET6, arg, &a) != 1)
2169 return NULL;
2170 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2171 }
2172
2173 static void ospf6_routemap_rule_set_forwarding_free(void *rule)
2174 {
2175 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2176 }
2177
2178 static const struct route_map_rule_cmd
2179 ospf6_routemap_rule_set_forwarding_cmd = {
2180 "forwarding-address",
2181 ospf6_routemap_rule_set_forwarding,
2182 ospf6_routemap_rule_set_forwarding_compile,
2183 ospf6_routemap_rule_set_forwarding_free,
2184 };
2185
2186 static enum route_map_cmd_result_t
2187 ospf6_routemap_rule_set_tag(void *rule, const struct prefix *p, void *object)
2188 {
2189 route_tag_t *tag = rule;
2190 struct ospf6_route *route = object;
2191 struct ospf6_external_info *info = route->route_option;
2192
2193 info->tag = *tag;
2194 return RMAP_OKAY;
2195 }
2196
2197 static const struct route_map_rule_cmd ospf6_routemap_rule_set_tag_cmd = {
2198 "tag",
2199 ospf6_routemap_rule_set_tag,
2200 route_map_rule_tag_compile,
2201 route_map_rule_tag_free,
2202 };
2203
2204 /* add "set metric-type" */
2205 DEFUN_YANG (ospf6_routemap_set_metric_type, ospf6_routemap_set_metric_type_cmd,
2206 "set metric-type <type-1|type-2>",
2207 SET_STR
2208 "Type of metric for destination routing protocol\n"
2209 "OSPF[6] external type 1 metric\n"
2210 "OSPF[6] external type 2 metric\n")
2211 {
2212 char *ext = argv[2]->text;
2213
2214 const char *xpath =
2215 "./set-action[action='frr-ospf-route-map:metric-type']";
2216 char xpath_value[XPATH_MAXLEN];
2217
2218 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
2219 snprintf(xpath_value, sizeof(xpath_value),
2220 "%s/rmap-set-action/frr-ospf-route-map:metric-type", xpath);
2221 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, ext);
2222 return nb_cli_apply_changes(vty, NULL);
2223 }
2224
2225 /* delete "set metric-type" */
2226 DEFUN_YANG (ospf6_routemap_no_set_metric_type, ospf6_routemap_no_set_metric_type_cmd,
2227 "no set metric-type [<type-1|type-2>]",
2228 NO_STR
2229 SET_STR
2230 "Type of metric for destination routing protocol\n"
2231 "OSPF[6] external type 1 metric\n"
2232 "OSPF[6] external type 2 metric\n")
2233 {
2234 const char *xpath =
2235 "./set-action[action='frr-ospf-route-map:metric-type']";
2236
2237 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
2238 return nb_cli_apply_changes(vty, NULL);
2239 }
2240
2241 /* add "set forwarding-address" */
2242 DEFUN_YANG (ospf6_routemap_set_forwarding, ospf6_routemap_set_forwarding_cmd,
2243 "set forwarding-address X:X::X:X",
2244 "Set value\n"
2245 "Forwarding Address\n"
2246 "IPv6 Address\n")
2247 {
2248 int idx_ipv6 = 2;
2249 const char *xpath =
2250 "./set-action[action='frr-ospf6-route-map:forwarding-address']";
2251 char xpath_value[XPATH_MAXLEN];
2252
2253 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
2254 snprintf(xpath_value, sizeof(xpath_value),
2255 "%s/rmap-set-action/frr-ospf6-route-map:ipv6-address", xpath);
2256 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
2257 argv[idx_ipv6]->arg);
2258 return nb_cli_apply_changes(vty, NULL);
2259 }
2260
2261 /* delete "set forwarding-address" */
2262 DEFUN_YANG (ospf6_routemap_no_set_forwarding, ospf6_routemap_no_set_forwarding_cmd,
2263 "no set forwarding-address [X:X::X:X]",
2264 NO_STR
2265 "Set value\n"
2266 "Forwarding Address\n"
2267 "IPv6 Address\n")
2268 {
2269 const char *xpath =
2270 "./set-action[action='frr-ospf6-route-map:forwarding-address']";
2271
2272 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
2273 return nb_cli_apply_changes(vty, NULL);
2274 }
2275
2276 static void ospf6_routemap_init(void)
2277 {
2278 route_map_init();
2279
2280 route_map_add_hook(ospf6_asbr_routemap_update);
2281 route_map_delete_hook(ospf6_asbr_routemap_update);
2282 route_map_event_hook(ospf6_asbr_routemap_event);
2283
2284 route_map_set_metric_hook(generic_set_add);
2285 route_map_no_set_metric_hook(generic_set_delete);
2286
2287 route_map_set_tag_hook(generic_set_add);
2288 route_map_no_set_tag_hook(generic_set_delete);
2289
2290 route_map_match_tag_hook(generic_match_add);
2291 route_map_no_match_tag_hook(generic_match_delete);
2292
2293 route_map_match_ipv6_address_prefix_list_hook(generic_match_add);
2294 route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete);
2295
2296 route_map_match_interface_hook(generic_match_add);
2297 route_map_no_match_interface_hook(generic_match_delete);
2298
2299 route_map_install_match(
2300 &ospf6_routemap_rule_match_address_prefixlist_cmd);
2301 route_map_install_match(&ospf6_routemap_rule_match_interface_cmd);
2302 route_map_install_match(&ospf6_routemap_rule_match_tag_cmd);
2303
2304 route_map_install_set(&ospf6_routemap_rule_set_metric_type_cmd);
2305 route_map_install_set(&ospf6_routemap_rule_set_metric_cmd);
2306 route_map_install_set(&ospf6_routemap_rule_set_forwarding_cmd);
2307 route_map_install_set(&ospf6_routemap_rule_set_tag_cmd);
2308
2309 /* ASE Metric Type (e.g. Type-1/Type-2) */
2310 install_element(RMAP_NODE, &ospf6_routemap_set_metric_type_cmd);
2311 install_element(RMAP_NODE, &ospf6_routemap_no_set_metric_type_cmd);
2312
2313 /* ASE Metric */
2314 install_element(RMAP_NODE, &ospf6_routemap_set_forwarding_cmd);
2315 install_element(RMAP_NODE, &ospf6_routemap_no_set_forwarding_cmd);
2316 }
2317
2318
2319 /* Display functions */
2320 static char *ospf6_as_external_lsa_get_prefix_str(struct ospf6_lsa *lsa,
2321 char *buf, int buflen,
2322 int pos)
2323 {
2324 struct ospf6_as_external_lsa *external;
2325 struct in6_addr in6;
2326 int prefix_length = 0;
2327 char tbuf[16];
2328
2329 if (lsa) {
2330 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
2331 lsa->header);
2332
2333 if (pos == 0) {
2334 ospf6_prefix_in6_addr(&in6, external,
2335 &external->prefix);
2336 prefix_length = external->prefix.prefix_length;
2337 } else {
2338 in6 = *((struct in6_addr
2339 *)((caddr_t)external
2340 + sizeof(struct
2341 ospf6_as_external_lsa)
2342 + OSPF6_PREFIX_SPACE(
2343 external->prefix
2344 .prefix_length)));
2345 }
2346 if (buf) {
2347 inet_ntop(AF_INET6, &in6, buf, buflen);
2348 if (prefix_length) {
2349 snprintf(tbuf, sizeof(tbuf), "/%d",
2350 prefix_length);
2351 strlcat(buf, tbuf, buflen);
2352 }
2353 }
2354 }
2355 return (buf);
2356 }
2357
2358 static int ospf6_as_external_lsa_show(struct vty *vty, struct ospf6_lsa *lsa,
2359 json_object *json_obj, bool use_json)
2360 {
2361 struct ospf6_as_external_lsa *external;
2362 char buf[64];
2363
2364 assert(lsa->header);
2365 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END(
2366 lsa->header);
2367
2368 /* bits */
2369 snprintf(buf, sizeof(buf), "%c%c%c",
2370 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_E) ? 'E'
2371 : '-'),
2372 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F) ? 'F'
2373 : '-'),
2374 (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T) ? 'T'
2375 : '-'));
2376
2377 if (use_json) {
2378 json_object_string_add(json_obj, "bits", buf);
2379 json_object_int_add(json_obj, "metric",
2380 (unsigned long)OSPF6_ASBR_METRIC(external));
2381 ospf6_prefix_options_printbuf(external->prefix.prefix_options,
2382 buf, sizeof(buf));
2383 json_object_string_add(json_obj, "prefixOptions", buf);
2384 json_object_int_add(
2385 json_obj, "referenceLsType",
2386 ntohs(external->prefix.prefix_refer_lstype));
2387 json_object_string_add(json_obj, "prefix",
2388 ospf6_as_external_lsa_get_prefix_str(
2389 lsa, buf, sizeof(buf), 0));
2390
2391 /* Forwarding-Address */
2392 json_object_boolean_add(
2393 json_obj, "forwardingAddressPresent",
2394 CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F));
2395 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F))
2396 json_object_string_add(
2397 json_obj, "forwardingAddress",
2398 ospf6_as_external_lsa_get_prefix_str(
2399 lsa, buf, sizeof(buf), 1));
2400
2401 /* Tag */
2402 json_object_boolean_add(
2403 json_obj, "tagPresent",
2404 CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T));
2405 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T))
2406 json_object_int_add(json_obj, "tag",
2407 ospf6_as_external_lsa_get_tag(lsa));
2408 } else {
2409 vty_out(vty, " Bits: %s\n", buf);
2410 vty_out(vty, " Metric: %5lu\n",
2411 (unsigned long)OSPF6_ASBR_METRIC(external));
2412
2413 ospf6_prefix_options_printbuf(external->prefix.prefix_options,
2414 buf, sizeof(buf));
2415 vty_out(vty, " Prefix Options: %s\n", buf);
2416
2417 vty_out(vty, " Referenced LSType: %d\n",
2418 ntohs(external->prefix.prefix_refer_lstype));
2419
2420 vty_out(vty, " Prefix: %s\n",
2421 ospf6_as_external_lsa_get_prefix_str(lsa, buf,
2422 sizeof(buf), 0));
2423
2424 /* Forwarding-Address */
2425 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_F)) {
2426 vty_out(vty, " Forwarding-Address: %s\n",
2427 ospf6_as_external_lsa_get_prefix_str(
2428 lsa, buf, sizeof(buf), 1));
2429 }
2430
2431 /* Tag */
2432 if (CHECK_FLAG(external->bits_metric, OSPF6_ASBR_BIT_T)) {
2433 vty_out(vty, " Tag: %" ROUTE_TAG_PRI "\n",
2434 ospf6_as_external_lsa_get_tag(lsa));
2435 }
2436 }
2437
2438 return 0;
2439 }
2440
2441 static void ospf6_asbr_external_route_show(struct vty *vty,
2442 struct ospf6_route *route,
2443 json_object *json_array,
2444 bool use_json)
2445 {
2446 struct ospf6_external_info *info = route->route_option;
2447 char prefix[PREFIX2STR_BUFFER], id[16], forwarding[64];
2448 uint32_t tmp_id;
2449 json_object *json_route;
2450 char route_type[2];
2451
2452 prefix2str(&route->prefix, prefix, sizeof(prefix));
2453 tmp_id = ntohl(info->id);
2454 inet_ntop(AF_INET, &tmp_id, id, sizeof(id));
2455 if (!IN6_IS_ADDR_UNSPECIFIED(&info->forwarding))
2456 inet_ntop(AF_INET6, &info->forwarding, forwarding,
2457 sizeof(forwarding));
2458 else
2459 snprintf(forwarding, sizeof(forwarding), ":: (ifindex %d)",
2460 ospf6_route_get_first_nh_index(route));
2461
2462 if (use_json) {
2463 json_route = json_object_new_object();
2464 snprintf(route_type, sizeof(route_type), "%c",
2465 zebra_route_char(info->type));
2466 json_object_string_add(json_route, "routeType", route_type);
2467 json_object_string_add(json_route, "destination", prefix);
2468 json_object_string_add(json_route, "id", id);
2469 json_object_int_add(json_route, "metricType",
2470 route->path.metric_type);
2471 json_object_int_add(
2472 json_route, "routeCost",
2473 (unsigned long)(route->path.metric_type == 2
2474 ? route->path.u.cost_e2
2475 : route->path.cost));
2476 json_object_string_add(json_route, "forwarding", forwarding);
2477
2478 json_object_array_add(json_array, json_route);
2479 } else
2480
2481 vty_out(vty, "%c %-32pFX %-15s type-%d %5lu %s\n",
2482 zebra_route_char(info->type), &route->prefix, id,
2483 route->path.metric_type,
2484 (unsigned long)(route->path.metric_type == 2
2485 ? route->path.u.cost_e2
2486 : route->path.cost),
2487 forwarding);
2488 }
2489
2490 DEFUN(show_ipv6_ospf6_redistribute, show_ipv6_ospf6_redistribute_cmd,
2491 "show ipv6 ospf6 [vrf <NAME|all>] redistribute [json]",
2492 SHOW_STR IP6_STR OSPF6_STR VRF_CMD_HELP_STR
2493 "All VRFs\n"
2494 "redistributing External information\n" JSON_STR)
2495 {
2496 struct ospf6_route *route;
2497 struct ospf6 *ospf6 = NULL;
2498 json_object *json = NULL;
2499 bool uj = use_json(argc, argv);
2500 struct listnode *node;
2501 const char *vrf_name = NULL;
2502 bool all_vrf = false;
2503 int idx_vrf = 0;
2504
2505 json_object *json_array_routes = NULL;
2506 json_object *json_array_redistribute = NULL;
2507
2508 OSPF6_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
2509
2510 if (uj) {
2511 json = json_object_new_object();
2512 json_array_routes = json_object_new_array();
2513 json_array_redistribute = json_object_new_array();
2514 }
2515
2516 for (ALL_LIST_ELEMENTS_RO(om6->ospf6, node, ospf6)) {
2517 if (all_vrf
2518 || ((ospf6->name == NULL && vrf_name == NULL)
2519 || (ospf6->name && vrf_name
2520 && strcmp(ospf6->name, vrf_name) == 0))) {
2521 ospf6_redistribute_show_config(
2522 vty, ospf6, json_array_redistribute, json, uj);
2523
2524 for (route = ospf6_route_head(ospf6->external_table);
2525 route; route = ospf6_route_next(route)) {
2526 ospf6_asbr_external_route_show(
2527 vty, route, json_array_routes, uj);
2528 }
2529
2530 if (uj) {
2531 json_object_object_add(json, "routes",
2532 json_array_routes);
2533 vty_json(vty, json);
2534 }
2535
2536 if (!all_vrf)
2537 break;
2538 }
2539 }
2540
2541 OSPF6_CMD_CHECK_VRF(uj, all_vrf, ospf6);
2542
2543 return CMD_SUCCESS;
2544 }
2545
2546 static struct ospf6_lsa_handler as_external_handler = {
2547 .lh_type = OSPF6_LSTYPE_AS_EXTERNAL,
2548 .lh_name = "AS-External",
2549 .lh_short_name = "ASE",
2550 .lh_show = ospf6_as_external_lsa_show,
2551 .lh_get_prefix_str = ospf6_as_external_lsa_get_prefix_str,
2552 .lh_debug = 0};
2553
2554 static struct ospf6_lsa_handler nssa_external_handler = {
2555 .lh_type = OSPF6_LSTYPE_TYPE_7,
2556 .lh_name = "NSSA",
2557 .lh_short_name = "Type7",
2558 .lh_show = ospf6_as_external_lsa_show,
2559 .lh_get_prefix_str = ospf6_as_external_lsa_get_prefix_str,
2560 .lh_debug = 0};
2561
2562 void ospf6_asbr_init(void)
2563 {
2564 ospf6_routemap_init();
2565
2566 ospf6_install_lsa_handler(&as_external_handler);
2567 ospf6_install_lsa_handler(&nssa_external_handler);
2568
2569 install_element(VIEW_NODE, &show_ipv6_ospf6_redistribute_cmd);
2570
2571 install_element(OSPF6_NODE, &ospf6_default_route_originate_cmd);
2572 install_element(OSPF6_NODE,
2573 &no_ospf6_default_information_originate_cmd);
2574 install_element(OSPF6_NODE, &ospf6_redistribute_cmd);
2575 install_element(OSPF6_NODE, &no_ospf6_redistribute_cmd);
2576 }
2577
2578 void ospf6_asbr_redistribute_disable(struct ospf6 *ospf6)
2579 {
2580 int type;
2581 struct ospf6_redist *red;
2582
2583 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
2584 red = ospf6_redist_lookup(ospf6, type, 0);
2585 if (!red)
2586 continue;
2587 if (type == ZEBRA_ROUTE_OSPF6)
2588 continue;
2589 ospf6_asbr_redistribute_unset(ospf6, red, type);
2590 ospf6_redist_del(ospf6, red, type);
2591 }
2592 red = ospf6_redist_lookup(ospf6, DEFAULT_ROUTE, 0);
2593 if (red) {
2594 ospf6_asbr_routemap_unset(red);
2595 ospf6_redist_del(ospf6, red, type);
2596 ospf6_redistribute_default_set(ospf6, DEFAULT_ORIGINATE_NONE);
2597 }
2598 }
2599
2600 void ospf6_asbr_redistribute_reset(struct ospf6 *ospf6)
2601 {
2602 int type;
2603 struct ospf6_redist *red;
2604 char buf[RMAP_NAME_MAXLEN];
2605
2606 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
2607 buf[0] = '\0';
2608 if (type == ZEBRA_ROUTE_OSPF6)
2609 continue;
2610 red = ospf6_redist_lookup(ospf6, type, 0);
2611 if (!red)
2612 continue;
2613
2614 if (type == DEFAULT_ROUTE) {
2615 ospf6_redistribute_default_set(
2616 ospf6, ospf6->default_originate);
2617 continue;
2618 }
2619 if (ROUTEMAP_NAME(red))
2620 strlcpy(buf, ROUTEMAP_NAME(red), sizeof(buf));
2621
2622 ospf6_asbr_redistribute_unset(ospf6, red, type);
2623 if (buf[0])
2624 ospf6_asbr_routemap_set(red, buf);
2625 ospf6_asbr_redistribute_set(ospf6, type);
2626 }
2627 }
2628
2629 void ospf6_asbr_terminate(void)
2630 {
2631 /* Cleanup route maps */
2632 route_map_finish();
2633 }
2634
2635 DEFUN (debug_ospf6_asbr,
2636 debug_ospf6_asbr_cmd,
2637 "debug ospf6 asbr",
2638 DEBUG_STR
2639 OSPF6_STR
2640 "Debug OSPFv3 ASBR function\n"
2641 )
2642 {
2643 OSPF6_DEBUG_ASBR_ON();
2644 return CMD_SUCCESS;
2645 }
2646
2647 DEFUN (no_debug_ospf6_asbr,
2648 no_debug_ospf6_asbr_cmd,
2649 "no debug ospf6 asbr",
2650 NO_STR
2651 DEBUG_STR
2652 OSPF6_STR
2653 "Debug OSPFv3 ASBR function\n"
2654 )
2655 {
2656 OSPF6_DEBUG_ASBR_OFF();
2657 return CMD_SUCCESS;
2658 }
2659
2660 int config_write_ospf6_debug_asbr(struct vty *vty)
2661 {
2662 if (IS_OSPF6_DEBUG_ASBR)
2663 vty_out(vty, "debug ospf6 asbr\n");
2664 return 0;
2665 }
2666
2667 static void ospf6_default_originate_write(struct vty *vty, struct ospf6 *o)
2668 {
2669 struct ospf6_redist *red;
2670
2671 vty_out(vty, " default-information originate");
2672 if (o->default_originate == DEFAULT_ORIGINATE_ALWAYS)
2673 vty_out(vty, " always");
2674
2675 red = ospf6_redist_lookup(o, DEFAULT_ROUTE, 0);
2676 if (red == NULL) {
2677 vty_out(vty, "\n");
2678 return;
2679 }
2680
2681 if (red->dmetric.value >= 0)
2682 vty_out(vty, " metric %d", red->dmetric.value);
2683
2684 if (red->dmetric.type >= 0)
2685 vty_out(vty, " metric-type %d", red->dmetric.type);
2686
2687 if (ROUTEMAP_NAME(red))
2688 vty_out(vty, " route-map %s", ROUTEMAP_NAME(red));
2689
2690 vty_out(vty, "\n");
2691 }
2692
2693 int ospf6_distribute_config_write(struct vty *vty, struct ospf6 *o)
2694 {
2695 if (o == NULL)
2696 return 0;
2697
2698 /* Print default originate configuration. */
2699 if (o->default_originate != DEFAULT_ORIGINATE_NONE)
2700 ospf6_default_originate_write(vty, o);
2701
2702 return 0;
2703 }
2704
2705 void install_element_ospf6_debug_asbr(void)
2706 {
2707 install_element(ENABLE_NODE, &debug_ospf6_asbr_cmd);
2708 install_element(ENABLE_NODE, &no_debug_ospf6_asbr_cmd);
2709 install_element(CONFIG_NODE, &debug_ospf6_asbr_cmd);
2710 install_element(CONFIG_NODE, &no_debug_ospf6_asbr_cmd);
2711 }
2712
2713 /* ASBR Summarisation */
2714 void ospf6_fill_aggr_route_details(struct ospf6 *ospf6,
2715 struct ospf6_external_aggr_rt *aggr)
2716 {
2717 struct ospf6_route *rt_aggr = aggr->route;
2718 struct ospf6_external_info *ei_aggr = rt_aggr->route_option;
2719
2720 rt_aggr->prefix = aggr->p;
2721 ei_aggr->tag = aggr->tag;
2722 ei_aggr->type = 0;
2723 ei_aggr->id = aggr->id;
2724
2725 /* When metric is not configured, apply the default metric */
2726 rt_aggr->path.cost = ((aggr->metric == -1) ?
2727 DEFAULT_DEFAULT_METRIC
2728 : (unsigned int)(aggr->metric));
2729 rt_aggr->path.metric_type = aggr->mtype;
2730
2731 rt_aggr->path.origin.id = htonl(aggr->id);
2732 }
2733
2734 static void
2735 ospf6_summary_add_aggr_route_and_blackhole(struct ospf6 *ospf6,
2736 struct ospf6_external_aggr_rt *aggr)
2737 {
2738 struct ospf6_route *rt_aggr;
2739 struct ospf6_external_info *info;
2740
2741 /* Create summary route and save it. */
2742 rt_aggr = ospf6_route_create(ospf6);
2743 rt_aggr->type = OSPF6_DEST_TYPE_NETWORK;
2744 /* Needed to install route while calling zebra api */
2745 SET_FLAG(rt_aggr->flag, OSPF6_ROUTE_BEST);
2746
2747 info = XCALLOC(MTYPE_OSPF6_EXTERNAL_INFO, sizeof(*info));
2748 rt_aggr->route_option = info;
2749 aggr->route = rt_aggr;
2750
2751 /* Prepare the external_info for aggregator
2752 * Fill all the details which will get advertised
2753 */
2754 ospf6_fill_aggr_route_details(ospf6, aggr);
2755
2756 /* Add next-hop to Null interface. */
2757 ospf6_add_route_nexthop_blackhole(rt_aggr);
2758
2759 ospf6_zebra_route_update_add(rt_aggr, ospf6);
2760 }
2761
2762 static void ospf6_originate_new_aggr_lsa(struct ospf6 *ospf6,
2763 struct ospf6_external_aggr_rt *aggr)
2764 {
2765 struct prefix prefix_id;
2766 struct ospf6_lsa *lsa = NULL;
2767
2768 if (IS_OSPF6_DEBUG_AGGR)
2769 zlog_debug("%s: Originate new aggregate route(%pFX)", __func__,
2770 &aggr->p);
2771
2772 aggr->id = ospf6->external_id++;
2773
2774 if (IS_OSPF6_DEBUG_AGGR)
2775 zlog_debug(
2776 "Advertise AS-External Id:%pI4 prefix %pFX metric %u",
2777 &prefix_id.u.prefix4, &aggr->p, aggr->metric);
2778
2779 ospf6_summary_add_aggr_route_and_blackhole(ospf6, aggr);
2780
2781 /* Originate summary LSA */
2782 lsa = ospf6_originate_type5_type7_lsas(aggr->route, ospf6);
2783 if (lsa) {
2784 if (IS_OSPF6_DEBUG_AGGR)
2785 zlog_debug("%s: Set the origination bit for aggregator",
2786 __func__);
2787 SET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED);
2788 }
2789 }
2790
2791 static void
2792 ospf6_aggr_handle_advertise_change(struct ospf6 *ospf6,
2793 struct ospf6_external_aggr_rt *aggr)
2794 {
2795 /* Check if advertise option modified. */
2796 if (CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE)) {
2797 if (IS_OSPF6_DEBUG_AGGR)
2798 zlog_debug("%s: Don't originate the summary address,It is configured to not-advertise.",
2799 __func__);
2800 ospf6_asbr_summary_remove_lsa_and_route(ospf6, aggr);
2801
2802 return;
2803 }
2804
2805 /* There are no routes present under this aggregation config, hence
2806 * nothing to originate here
2807 */
2808 if (OSPF6_EXTERNAL_RT_COUNT(aggr) == 0) {
2809 if (IS_OSPF6_DEBUG_AGGR)
2810 zlog_debug("%s: No routes present under this aggregation",
2811 __func__);
2812 return;
2813 }
2814
2815 if (!CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED)) {
2816 if (IS_OSPF6_DEBUG_AGGR)
2817 zlog_debug("%s: Now it is advertisable",
2818 __func__);
2819
2820 ospf6_originate_new_aggr_lsa(ospf6, aggr);
2821
2822 return;
2823 }
2824 }
2825
2826 static void
2827 ospf6_originate_summary_lsa(struct ospf6 *ospf6,
2828 struct ospf6_external_aggr_rt *aggr,
2829 struct ospf6_route *rt)
2830 {
2831 struct ospf6_lsa *lsa = NULL, *aggr_lsa = NULL;
2832 struct ospf6_external_info *info = NULL;
2833 struct ospf6_external_aggr_rt *old_aggr;
2834 struct ospf6_as_external_lsa *external;
2835 struct ospf6_route *rt_aggr = NULL;
2836 route_tag_t tag = 0;
2837 unsigned int metric = 0;
2838 int mtype;
2839
2840 if (IS_OSPF6_DEBUG_AGGR)
2841 zlog_debug("%s: Prepare to originate Summary route(%pFX)",
2842 __func__, &aggr->p);
2843
2844 /* This case to handle when the overlapping aggregator address
2845 * is available. Best match will be considered.So need to delink
2846 * from old aggregator and link to the new aggr.
2847 */
2848 if (rt->aggr_route) {
2849 if (rt->aggr_route != aggr) {
2850 old_aggr = rt->aggr_route;
2851 ospf6_unlink_route_from_aggr(ospf6, old_aggr, rt);
2852 }
2853 }
2854
2855 /* Add the external route to hash table */
2856 ospf6_link_route_to_aggr(aggr, rt);
2857
2858 /* The key for ID field is a running number and not prefix */
2859 info = rt->route_option;
2860 assert(info);
2861 if (info->id)
2862 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
2863 htonl(info->id), ospf6->router_id,
2864 ospf6->lsdb);
2865
2866 aggr_lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
2867 htonl(aggr->id), ospf6->router_id, ospf6->lsdb);
2868
2869 if (IS_OSPF6_DEBUG_AGGR)
2870 zlog_debug("%s: Aggr LSA ID: %d flags %x.",
2871 __func__, aggr->id, aggr->aggrflags);
2872 /* Don't originate external LSA,
2873 * If it is configured not to advertise.
2874 */
2875 if (CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE)) {
2876 /* If it is already originated as external LSA,
2877 * But, it is configured not to advertise then
2878 * flush the originated external lsa.
2879 */
2880 if (lsa) {
2881 if (IS_OSPF6_DEBUG_AGGR)
2882 zlog_debug("%s: Purge the external LSA %s.",
2883 __func__, lsa->name);
2884 ospf6_external_lsa_purge(ospf6, lsa);
2885 info->id = 0;
2886 rt->path.origin.id = 0;
2887 }
2888
2889 if (aggr_lsa) {
2890 if (IS_OSPF6_DEBUG_AGGR)
2891 zlog_debug("%s: Purge the aggr external LSA %s.",
2892 __func__, lsa->name);
2893 ospf6_asbr_summary_remove_lsa_and_route(ospf6, aggr);
2894 }
2895
2896 UNSET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED);
2897
2898 if (IS_OSPF6_DEBUG_AGGR)
2899 zlog_debug("%s: Don't originate the summary address,It is configured to not-advertise.",
2900 __func__);
2901 return;
2902 }
2903
2904 /* Summary route already originated,
2905 * So, Do nothing.
2906 */
2907 if (CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED)) {
2908 if (!aggr_lsa) {
2909 zlog_warn(
2910 "%s: Could not refresh/originate %pFX",
2911 __func__,
2912 &aggr->p);
2913 /* Remove the assert later */
2914 assert(aggr_lsa);
2915 return;
2916 }
2917
2918 external = (struct ospf6_as_external_lsa *)OSPF6_LSA_HEADER_END
2919 (aggr_lsa->header);
2920 metric = (unsigned long)OSPF6_ASBR_METRIC(external);
2921 tag = ospf6_as_external_lsa_get_tag(aggr_lsa);
2922 mtype = CHECK_FLAG(external->bits_metric,
2923 OSPF6_ASBR_BIT_E) ? 2 : 1;
2924
2925 /* Prepare the external_info for aggregator */
2926 ospf6_fill_aggr_route_details(ospf6, aggr);
2927 rt_aggr = aggr->route;
2928 /* If tag/metric/metric-type modified , then re-originate the
2929 * route with modified tag/metric/metric-type details.
2930 */
2931 if ((tag != aggr->tag)
2932 || (metric != (unsigned int)rt_aggr->path.cost)
2933 || (mtype != aggr->mtype)) {
2934
2935 if (IS_OSPF6_DEBUG_AGGR)
2936 zlog_debug(
2937 "%s: Routetag(old:%d new:%d)/Metric(o:%u,n:%u)/mtype(o:%d n:%d) modified,So refresh the summary route.(%pFX)",
2938 __func__, tag, aggr->tag,
2939 metric,
2940 aggr->metric,
2941 mtype, aggr->mtype,
2942 &aggr->p);
2943
2944 aggr_lsa = ospf6_originate_type5_type7_lsas(aggr->route,
2945 ospf6);
2946 if (aggr_lsa)
2947 SET_FLAG(aggr->aggrflags,
2948 OSPF6_EXTERNAL_AGGRT_ORIGINATED);
2949 }
2950
2951 return;
2952 }
2953
2954 /* If the external route prefix same as aggregate route
2955 * and if external route is already originated as TYPE-5
2956 * then just update the aggr info and remove the route info
2957 */
2958 if (lsa && prefix_same(&aggr->p, &rt->prefix)) {
2959 if (IS_OSPF6_DEBUG_AGGR)
2960 zlog_debug(
2961 "%s: Route prefix is same as aggr so no need to re-originate LSA(%pFX)",
2962 __PRETTY_FUNCTION__, &aggr->p);
2963
2964 aggr->id = info->id;
2965 info->id = 0;
2966 rt->path.origin.id = 0;
2967
2968 ospf6_summary_add_aggr_route_and_blackhole(ospf6, aggr);
2969
2970 SET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED);
2971
2972 return;
2973 }
2974
2975 ospf6_originate_new_aggr_lsa(ospf6, aggr);
2976 }
2977
2978 static void ospf6_aggr_handle_external_info(void *data)
2979 {
2980 struct ospf6_route *rt = (struct ospf6_route *)data;
2981 struct ospf6_external_aggr_rt *aggr = NULL;
2982 struct ospf6_lsa *lsa = NULL;
2983 struct ospf6_external_info *info;
2984 struct ospf6 *ospf6 = NULL;
2985
2986 rt->aggr_route = NULL;
2987
2988 rt->to_be_processed = true;
2989
2990 if (IS_OSPF6_DEBUG_ASBR || IS_OSPF6_DEBUG_ORIGINATE(AS_EXTERNAL))
2991 zlog_debug("%s: Handle external route for origination/refresh (%pFX)",
2992 __func__,
2993 &rt->prefix);
2994
2995 ospf6 = rt->ospf6;
2996 assert(ospf6);
2997
2998 aggr = ospf6_external_aggr_match(ospf6,
2999 &rt->prefix);
3000 if (aggr) {
3001 ospf6_originate_summary_lsa(ospf6, aggr, rt);
3002 return;
3003 }
3004
3005 info = rt->route_option;
3006 if (info->id) {
3007 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
3008 htonl(info->id), ospf6->router_id,
3009 ospf6->lsdb);
3010 if (lsa) {
3011 if (IS_OSPF6_DEBUG_AGGR)
3012 zlog_debug("%s: LSA found, refresh it",
3013 __func__);
3014 THREAD_OFF(lsa->refresh);
3015 thread_add_event(master, ospf6_lsa_refresh, lsa, 0,
3016 &lsa->refresh);
3017 return;
3018 }
3019 }
3020
3021 info->id = ospf6->external_id++;
3022 rt->path.origin.id = htonl(info->id);
3023
3024 (void)ospf6_originate_type5_type7_lsas(rt, ospf6);
3025 }
3026
3027 static void
3028 ospf6_asbr_summary_config_delete(struct ospf6 *ospf6, struct route_node *rn)
3029 {
3030 struct ospf6_external_aggr_rt *aggr = rn->info;
3031
3032 if (IS_OSPF6_DEBUG_AGGR)
3033 zlog_debug("%s: Deleting Aggregate route (%pFX)",
3034 __func__,
3035 &aggr->p);
3036
3037 ospf6_asbr_summary_remove_lsa_and_route(ospf6, aggr);
3038
3039 rn->info = NULL;
3040 route_unlock_node(rn);
3041 }
3042
3043 static int
3044 ospf6_handle_external_aggr_modify(struct ospf6 *ospf6,
3045 struct ospf6_external_aggr_rt *aggr)
3046 {
3047 struct ospf6_lsa *lsa = NULL;
3048 struct ospf6_as_external_lsa *asel = NULL;
3049 struct ospf6_route *rt_aggr;
3050 unsigned int metric = 0;
3051 route_tag_t tag = 0;
3052 int mtype;
3053
3054 lsa = ospf6_lsdb_lookup(
3055 htons(OSPF6_LSTYPE_AS_EXTERNAL),
3056 htonl(aggr->id), ospf6->router_id,
3057 ospf6->lsdb);
3058 if (!lsa) {
3059 zlog_warn(
3060 "%s: Could not refresh/originate %pFX",
3061 __func__,
3062 &aggr->p);
3063
3064 return OSPF6_FAILURE;
3065 }
3066
3067 asel = (struct ospf6_as_external_lsa *)
3068 OSPF6_LSA_HEADER_END(lsa->header);
3069 metric = (unsigned long)OSPF6_ASBR_METRIC(asel);
3070 tag = ospf6_as_external_lsa_get_tag(lsa);
3071 mtype = CHECK_FLAG(asel->bits_metric,
3072 OSPF6_ASBR_BIT_E) ? 2 : 1;
3073
3074 /* Fill all the details for advertisement */
3075 ospf6_fill_aggr_route_details(ospf6, aggr);
3076 rt_aggr = aggr->route;
3077 /* If tag/metric/metric-type modified , then
3078 * re-originate the route with modified
3079 * tag/metric/metric-type details.
3080 */
3081 if ((tag != aggr->tag)
3082 || (metric
3083 != (unsigned int)rt_aggr->path.cost)
3084 || (mtype
3085 != aggr->mtype)) {
3086 if (IS_OSPF6_DEBUG_AGGR)
3087 zlog_debug(
3088 "%s: Changed tag(old:%d new:%d)/metric(o:%u n:%d)/mtype(o:%d n:%d),So refresh the summary route.(%pFX)",
3089 __func__, tag,
3090 aggr->tag,
3091 metric,
3092 (unsigned int)rt_aggr->path.cost,
3093 mtype, aggr->mtype,
3094 &aggr->p);
3095
3096 (void)ospf6_originate_type5_type7_lsas(
3097 aggr->route,
3098 ospf6);
3099 }
3100
3101 return OSPF6_SUCCESS;
3102 }
3103
3104 static void ospf6_handle_external_aggr_update(struct ospf6 *ospf6)
3105 {
3106 struct route_node *rn = NULL;
3107 int ret;
3108
3109 if (IS_OSPF6_DEBUG_AGGR)
3110 zlog_debug("%s: Process modified aggregators.", __func__);
3111
3112 for (rn = route_top(ospf6->rt_aggr_tbl); rn; rn = route_next(rn)) {
3113 struct ospf6_external_aggr_rt *aggr;
3114
3115 if (!rn->info)
3116 continue;
3117
3118 aggr = rn->info;
3119
3120 if (aggr->action == OSPF6_ROUTE_AGGR_DEL) {
3121 aggr->action = OSPF6_ROUTE_AGGR_NONE;
3122 ospf6_asbr_summary_config_delete(ospf6, rn);
3123
3124 if (OSPF6_EXTERNAL_RT_COUNT(aggr))
3125 hash_clean(aggr->match_extnl_hash,
3126 ospf6_aggr_handle_external_info);
3127
3128 hash_free(aggr->match_extnl_hash);
3129 XFREE(MTYPE_OSPF6_EXTERNAL_RT_AGGR, aggr);
3130
3131 } else if (aggr->action == OSPF6_ROUTE_AGGR_MODIFY) {
3132
3133 aggr->action = OSPF6_ROUTE_AGGR_NONE;
3134
3135 /* Check if tag/metric/metric-type modified */
3136 if (CHECK_FLAG(aggr->aggrflags,
3137 OSPF6_EXTERNAL_AGGRT_ORIGINATED)
3138 && !CHECK_FLAG(aggr->aggrflags,
3139 OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE)) {
3140
3141 ret = ospf6_handle_external_aggr_modify(ospf6,
3142 aggr);
3143 if (ret == OSPF6_FAILURE)
3144 continue;
3145 }
3146
3147 /* Advertise option modified ?
3148 * If so, handled it here.
3149 */
3150 ospf6_aggr_handle_advertise_change(ospf6, aggr);
3151 }
3152 }
3153 }
3154
3155 static void ospf6_aggr_unlink_external_info(void *data)
3156 {
3157 struct ospf6_route *rt = (struct ospf6_route *)data;
3158
3159 rt->aggr_route = NULL;
3160
3161 rt->to_be_processed = true;
3162 }
3163
3164 void ospf6_external_aggregator_free(struct ospf6_external_aggr_rt *aggr)
3165 {
3166 if (OSPF6_EXTERNAL_RT_COUNT(aggr))
3167 hash_clean(aggr->match_extnl_hash,
3168 ospf6_aggr_unlink_external_info);
3169
3170 if (aggr->route) {
3171 if (aggr->route->route_option)
3172 XFREE(MTYPE_OSPF6_EXTERNAL_INFO,
3173 aggr->route->route_option);
3174
3175 ospf6_route_delete(aggr->route);
3176 }
3177
3178 if (IS_OSPF6_DEBUG_AGGR)
3179 zlog_debug("%s: Release the aggregator Address(%pFX)",
3180 __func__,
3181 &aggr->p);
3182
3183 hash_free(aggr->match_extnl_hash);
3184 aggr->match_extnl_hash = NULL;
3185
3186 XFREE(MTYPE_OSPF6_EXTERNAL_RT_AGGR, aggr);
3187 }
3188
3189 static void
3190 ospf6_delete_all_marked_aggregators(struct ospf6 *ospf6)
3191 {
3192 struct route_node *rn = NULL;
3193 struct ospf6_external_aggr_rt *aggr;
3194
3195 /* Loop through all the aggregators, Delete all aggregators
3196 * which are marked as DELETE. Set action to NONE for remaining
3197 * aggregators
3198 */
3199 for (rn = route_top(ospf6->rt_aggr_tbl); rn; rn = route_next(rn)) {
3200 if (!rn->info)
3201 continue;
3202
3203 aggr = rn->info;
3204
3205 if (aggr->action != OSPF6_ROUTE_AGGR_DEL) {
3206 aggr->action = OSPF6_ROUTE_AGGR_NONE;
3207 continue;
3208 }
3209 ospf6_asbr_summary_config_delete(ospf6, rn);
3210 ospf6_external_aggregator_free(aggr);
3211 }
3212 }
3213
3214 static void ospf6_handle_exnl_rt_after_aggr_del(struct ospf6 *ospf6,
3215 struct ospf6_route *rt)
3216 {
3217 struct ospf6_lsa *lsa;
3218
3219 /* Process only marked external routes.
3220 * These routes were part of a deleted
3221 * aggregator.So, originate now.
3222 */
3223 if (!rt->to_be_processed)
3224 return;
3225
3226 rt->to_be_processed = false;
3227
3228 lsa = ospf6_find_external_lsa(ospf6, &rt->prefix);
3229
3230 if (lsa) {
3231 THREAD_OFF(lsa->refresh);
3232 thread_add_event(master, ospf6_lsa_refresh, lsa, 0,
3233 &lsa->refresh);
3234 } else {
3235 if (IS_OSPF6_DEBUG_AGGR)
3236 zlog_debug("%s: Originate external route(%pFX)",
3237 __func__,
3238 &rt->prefix);
3239
3240 (void)ospf6_originate_type5_type7_lsas(rt, ospf6);
3241 }
3242 }
3243
3244 static void ospf6_handle_aggregated_exnl_rt(struct ospf6 *ospf6,
3245 struct ospf6_external_aggr_rt *aggr,
3246 struct ospf6_route *rt)
3247 {
3248 struct ospf6_lsa *lsa;
3249 struct ospf6_as_external_lsa *ext_lsa;
3250 struct ospf6_external_info *info;
3251
3252 /* Handling the case where the external route prefix
3253 * and aggegate prefix is same
3254 * If same don't flush the originated external LSA.
3255 */
3256 if (prefix_same(&aggr->p, &rt->prefix)) {
3257 if (IS_OSPF6_DEBUG_AGGR)
3258 zlog_debug("%s: External Route prefix same as Aggregator(%pFX), so don't flush.",
3259 __func__,
3260 &rt->prefix);
3261
3262 return;
3263 }
3264
3265 info = rt->route_option;
3266 assert(info);
3267
3268 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_AS_EXTERNAL),
3269 htonl(info->id), ospf6->router_id, ospf6->lsdb);
3270 if (lsa) {
3271 ext_lsa = (struct ospf6_as_external_lsa
3272 *)((char *)(lsa->header)
3273 + sizeof(struct ospf6_lsa_header));
3274
3275 if (rt->prefix.prefixlen != ext_lsa->prefix.prefix_length)
3276 return;
3277
3278 ospf6_external_lsa_purge(ospf6, lsa);
3279
3280 /* Resetting the ID of route */
3281 rt->path.origin.id = 0;
3282 info->id = 0;
3283 }
3284 }
3285
3286 static void
3287 ospf6_handle_external_aggr_add(struct ospf6 *ospf6)
3288 {
3289 struct ospf6_route *rt = NULL;
3290 struct ospf6_external_info *ei = NULL;
3291 struct ospf6_external_aggr_rt *aggr;
3292
3293 /* Delete all the aggregators which are marked as
3294 * OSPF6_ROUTE_AGGR_DEL.
3295 */
3296 ospf6_delete_all_marked_aggregators(ospf6);
3297
3298 for (rt = ospf6_route_head(ospf6->external_table); rt;
3299 rt = ospf6_route_next(rt)) {
3300 ei = rt->route_option;
3301 if (ei == NULL)
3302 continue;
3303
3304 if (is_default_prefix(&rt->prefix))
3305 continue;
3306
3307 aggr = ospf6_external_aggr_match(ospf6,
3308 &rt->prefix);
3309
3310 /* If matching aggregator found, Add
3311 * the external route refrenace to the
3312 * aggregator and originate the aggr
3313 * route if it is advertisable.
3314 * flush the external LSA if it is
3315 * already originated for this external
3316 * prefix.
3317 */
3318 if (aggr) {
3319 ospf6_originate_summary_lsa(ospf6, aggr, rt);
3320
3321 /* All aggregated external rts
3322 * are handled here.
3323 */
3324 ospf6_handle_aggregated_exnl_rt(
3325 ospf6, aggr, rt);
3326 continue;
3327 }
3328
3329 /* External routes which are only out
3330 * of aggregation will be handled here.
3331 */
3332 ospf6_handle_exnl_rt_after_aggr_del(
3333 ospf6, rt);
3334 }
3335 }
3336
3337 static void ospf6_asbr_summary_process(struct thread *thread)
3338 {
3339 struct ospf6 *ospf6 = THREAD_ARG(thread);
3340 int operation = 0;
3341
3342 operation = ospf6->aggr_action;
3343
3344 if (IS_OSPF6_DEBUG_AGGR)
3345 zlog_debug("%s: operation:%d",
3346 __func__,
3347 operation);
3348
3349 switch (operation) {
3350 case OSPF6_ROUTE_AGGR_ADD:
3351 ospf6_handle_external_aggr_add(ospf6);
3352 break;
3353 case OSPF6_ROUTE_AGGR_DEL:
3354 case OSPF6_ROUTE_AGGR_MODIFY:
3355 ospf6_handle_external_aggr_update(ospf6);
3356 break;
3357 default:
3358 break;
3359 }
3360 }
3361
3362 static void
3363 ospf6_start_asbr_summary_delay_timer(struct ospf6 *ospf6,
3364 struct ospf6_external_aggr_rt *aggr,
3365 ospf6_aggr_action_t operation)
3366 {
3367 aggr->action = operation;
3368
3369 if (thread_is_scheduled(ospf6->t_external_aggr)) {
3370 if (ospf6->aggr_action == OSPF6_ROUTE_AGGR_ADD) {
3371
3372 if (IS_OSPF6_DEBUG_AGGR)
3373 zlog_debug("%s: Not required to restart timer,set is already added.",
3374 __func__);
3375 return;
3376 }
3377
3378 if (operation == OSPF6_ROUTE_AGGR_ADD) {
3379 if (IS_OSPF6_DEBUG_AGGR)
3380 zlog_debug("%s, Restarting Aggregator delay timer.",
3381 __func__);
3382 THREAD_OFF(ospf6->t_external_aggr);
3383 }
3384 }
3385
3386 if (IS_OSPF6_DEBUG_AGGR)
3387 zlog_debug("%s: Start Aggregator delay timer %u(in seconds).",
3388 __func__, ospf6->aggr_delay_interval);
3389
3390 ospf6->aggr_action = operation;
3391 thread_add_timer(master,
3392 ospf6_asbr_summary_process,
3393 ospf6, ospf6->aggr_delay_interval,
3394 &ospf6->t_external_aggr);
3395 }
3396
3397 int ospf6_asbr_external_rt_advertise(struct ospf6 *ospf6,
3398 struct prefix *p)
3399 {
3400 struct route_node *rn;
3401 struct ospf6_external_aggr_rt *aggr;
3402
3403 rn = route_node_lookup(ospf6->rt_aggr_tbl, p);
3404 if (!rn)
3405 return OSPF6_INVALID;
3406
3407 aggr = rn->info;
3408
3409 route_unlock_node(rn);
3410
3411 if (!CHECK_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE))
3412 return OSPF6_INVALID;
3413
3414 UNSET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE);
3415
3416 if (!OSPF6_EXTERNAL_RT_COUNT(aggr))
3417 return OSPF6_SUCCESS;
3418
3419 ospf6_start_asbr_summary_delay_timer(ospf6, aggr,
3420 OSPF6_ROUTE_AGGR_MODIFY);
3421
3422 return OSPF6_SUCCESS;
3423 }
3424
3425 int ospf6_external_aggr_delay_timer_set(struct ospf6 *ospf6, uint16_t interval)
3426 {
3427 ospf6->aggr_delay_interval = interval;
3428
3429 return OSPF6_SUCCESS;
3430 }
3431
3432 static unsigned int ospf6_external_rt_hash_key(const void *data)
3433 {
3434 const struct ospf6_route *rt = data;
3435 unsigned int key = 0;
3436
3437 key = prefix_hash_key(&rt->prefix);
3438 return key;
3439 }
3440
3441 static bool ospf6_external_rt_hash_cmp(const void *d1, const void *d2)
3442 {
3443 const struct ospf6_route *rt1 = d1;
3444 const struct ospf6_route *rt2 = d2;
3445
3446 return prefix_same(&rt1->prefix, &rt2->prefix);
3447 }
3448
3449 static struct ospf6_external_aggr_rt *
3450 ospf6_external_aggr_new(struct prefix *p)
3451 {
3452 struct ospf6_external_aggr_rt *aggr;
3453
3454 aggr = XCALLOC(MTYPE_OSPF6_EXTERNAL_RT_AGGR,
3455 sizeof(struct ospf6_external_aggr_rt));
3456
3457 prefix_copy(&aggr->p, p);
3458 aggr->metric = -1;
3459 aggr->mtype = DEFAULT_METRIC_TYPE;
3460 aggr->match_extnl_hash = hash_create(ospf6_external_rt_hash_key,
3461 ospf6_external_rt_hash_cmp,
3462 "Ospf6 external route hash");
3463 return aggr;
3464 }
3465
3466 static void ospf6_external_aggr_add(struct ospf6 *ospf6,
3467 struct ospf6_external_aggr_rt *aggr)
3468 {
3469 struct route_node *rn;
3470
3471 if (IS_OSPF6_DEBUG_AGGR)
3472 zlog_debug("%s: Adding Aggregate route to Aggr table (%pFX)",
3473 __func__,
3474 &aggr->p);
3475
3476 rn = route_node_get(ospf6->rt_aggr_tbl, &aggr->p);
3477 if (rn->info)
3478 route_unlock_node(rn);
3479 else
3480 rn->info = aggr;
3481 }
3482
3483 int ospf6_asbr_external_rt_no_advertise(struct ospf6 *ospf6,
3484 struct prefix *p)
3485 {
3486 struct ospf6_external_aggr_rt *aggr;
3487 route_tag_t tag = 0;
3488
3489 aggr = ospf6_external_aggr_config_lookup(ospf6, p);
3490 if (aggr) {
3491 if (CHECK_FLAG(aggr->aggrflags,
3492 OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE))
3493 return OSPF6_SUCCESS;
3494
3495 SET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE);
3496
3497 aggr->tag = tag;
3498 aggr->metric = -1;
3499
3500 if (!OSPF6_EXTERNAL_RT_COUNT(aggr))
3501 return OSPF6_SUCCESS;
3502
3503 ospf6_start_asbr_summary_delay_timer(ospf6, aggr,
3504 OSPF6_ROUTE_AGGR_MODIFY);
3505 } else {
3506 aggr = ospf6_external_aggr_new(p);
3507
3508 if (!aggr)
3509 return OSPF6_FAILURE;
3510
3511 SET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE);
3512 ospf6_external_aggr_add(ospf6, aggr);
3513 ospf6_start_asbr_summary_delay_timer(ospf6, aggr,
3514 OSPF6_ROUTE_AGGR_ADD);
3515 }
3516
3517 return OSPF6_SUCCESS;
3518 }
3519
3520 struct ospf6_external_aggr_rt *
3521 ospf6_external_aggr_config_lookup(struct ospf6 *ospf6, struct prefix *p)
3522 {
3523 struct route_node *rn;
3524
3525 rn = route_node_lookup(ospf6->rt_aggr_tbl, p);
3526 if (rn) {
3527 route_unlock_node(rn);
3528 return rn->info;
3529 }
3530
3531 return NULL;
3532 }
3533
3534
3535 int ospf6_external_aggr_config_set(struct ospf6 *ospf6, struct prefix *p,
3536 route_tag_t tag, int metric, int mtype)
3537 {
3538 struct ospf6_external_aggr_rt *aggregator;
3539
3540 aggregator = ospf6_external_aggr_config_lookup(ospf6, p);
3541
3542 if (aggregator) {
3543 if (CHECK_FLAG(aggregator->aggrflags,
3544 OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE))
3545 UNSET_FLAG(aggregator->aggrflags,
3546 OSPF6_EXTERNAL_AGGRT_NO_ADVERTISE);
3547 else if ((aggregator->tag == tag)
3548 && (aggregator->metric == metric)
3549 && (aggregator->mtype == mtype))
3550 return OSPF6_SUCCESS;
3551
3552 aggregator->tag = tag;
3553 aggregator->metric = metric;
3554 aggregator->mtype = mtype;
3555
3556 ospf6_start_asbr_summary_delay_timer(ospf6, aggregator,
3557 OSPF6_ROUTE_AGGR_MODIFY);
3558 } else {
3559 aggregator = ospf6_external_aggr_new(p);
3560 if (!aggregator)
3561 return OSPF6_FAILURE;
3562
3563 aggregator->tag = tag;
3564 aggregator->metric = metric;
3565 aggregator->mtype = mtype;
3566
3567 ospf6_external_aggr_add(ospf6, aggregator);
3568 ospf6_start_asbr_summary_delay_timer(ospf6, aggregator,
3569 OSPF6_ROUTE_AGGR_ADD);
3570 }
3571
3572 return OSPF6_SUCCESS;
3573 }
3574
3575 int ospf6_external_aggr_config_unset(struct ospf6 *ospf6,
3576 struct prefix *p)
3577 {
3578 struct route_node *rn;
3579 struct ospf6_external_aggr_rt *aggr;
3580
3581 rn = route_node_lookup(ospf6->rt_aggr_tbl, p);
3582 if (!rn)
3583 return OSPF6_INVALID;
3584
3585 aggr = rn->info;
3586
3587 route_unlock_node(rn);
3588
3589 if (!OSPF6_EXTERNAL_RT_COUNT(aggr)) {
3590 ospf6_asbr_summary_config_delete(ospf6, rn);
3591 ospf6_external_aggregator_free(aggr);
3592 return OSPF6_SUCCESS;
3593 }
3594
3595 ospf6_start_asbr_summary_delay_timer(ospf6, aggr,
3596 OSPF6_ROUTE_AGGR_DEL);
3597
3598 return OSPF6_SUCCESS;
3599 }
3600
3601 void ospf6_handle_external_lsa_origination(struct ospf6 *ospf6,
3602 struct ospf6_route *rt,
3603 struct prefix *p)
3604 {
3605
3606 struct ospf6_external_aggr_rt *aggr;
3607 struct ospf6_external_info *info;
3608 struct prefix prefix_id;
3609
3610 if (!is_default_prefix(p)) {
3611 aggr = ospf6_external_aggr_match(ospf6,
3612 p);
3613
3614 if (aggr) {
3615
3616 if (IS_OSPF6_DEBUG_AGGR)
3617 zlog_debug("%s: Send Aggregate LSA (%pFX)",
3618 __func__,
3619 &aggr->p);
3620
3621 ospf6_originate_summary_lsa(
3622 ospf6, aggr, rt);
3623
3624 /* Handling the case where the
3625 * external route prefix
3626 * and aggegate prefix is same
3627 * If same don't flush the
3628 * originated
3629 * external LSA.
3630 */
3631 ospf6_handle_aggregated_exnl_rt(
3632 ospf6, aggr, rt);
3633 return;
3634 }
3635 }
3636
3637 info = rt->route_option;
3638
3639 /* When the info->id = 0, it means it is being originated for the
3640 * first time.
3641 */
3642 if (!info->id) {
3643 info->id = ospf6->external_id++;
3644 } else {
3645 prefix_id.family = AF_INET;
3646 prefix_id.prefixlen = 32;
3647 prefix_id.u.prefix4.s_addr = htonl(info->id);
3648 }
3649
3650 rt->path.origin.id = htonl(info->id);
3651
3652 if (IS_OSPF6_DEBUG_ASBR) {
3653 zlog_debug("Advertise new AS-External Id:%pI4 prefix %pFX metric %u",
3654 &prefix_id.u.prefix4, p, rt->path.metric_type);
3655 }
3656
3657 ospf6_originate_type5_type7_lsas(rt, ospf6);
3658
3659 }
3660
3661 void ospf6_unset_all_aggr_flag(struct ospf6 *ospf6)
3662 {
3663 struct route_node *rn = NULL;
3664 struct ospf6_external_aggr_rt *aggr;
3665
3666 if (IS_OSPF6_DEBUG_AGGR)
3667 zlog_debug("Unset the origination bit for all aggregator");
3668
3669 /* Resetting the running external ID counter so that the origination
3670 * of external LSAs starts from the beginning 0.0.0.1
3671 */
3672 ospf6->external_id = OSPF6_EXT_INIT_LS_ID;
3673
3674 for (rn = route_top(ospf6->rt_aggr_tbl); rn; rn = route_next(rn)) {
3675 if (!rn->info)
3676 continue;
3677
3678 aggr = rn->info;
3679
3680 UNSET_FLAG(aggr->aggrflags, OSPF6_EXTERNAL_AGGRT_ORIGINATED);
3681 }
3682 }
FRRouting mirror