]> git.proxmox.com Git - mirror_frr.git/blob - ospf6d/ospf6_flood.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #10121 from ton31337/feature/match_ipv6_nexthop_prefixlist
[mirror_frr.git] / ospf6d / ospf6_flood.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 "thread.h"
25 #include "linklist.h"
26 #include "vty.h"
27 #include "command.h"
28
29 #include "ospf6d.h"
30 #include "ospf6_proto.h"
31 #include "ospf6_lsa.h"
32 #include "ospf6_lsdb.h"
33 #include "ospf6_message.h"
34 #include "ospf6_route.h"
35 #include "ospf6_spf.h"
36
37 #include "ospf6_top.h"
38 #include "ospf6_area.h"
39 #include "ospf6_interface.h"
40 #include "ospf6_neighbor.h"
41
42 #include "ospf6_flood.h"
43 #include "ospf6_nssa.h"
44 #include "ospf6_gr.h"
45
46 unsigned char conf_debug_ospf6_flooding;
47
48 struct ospf6_lsdb *ospf6_get_scoped_lsdb(struct ospf6_lsa *lsa)
49 {
50 struct ospf6_lsdb *lsdb = NULL;
51 switch (OSPF6_LSA_SCOPE(lsa->header->type)) {
52 case OSPF6_SCOPE_LINKLOCAL:
53 lsdb = OSPF6_INTERFACE(lsa->lsdb->data)->lsdb;
54 break;
55 case OSPF6_SCOPE_AREA:
56 lsdb = OSPF6_AREA(lsa->lsdb->data)->lsdb;
57 break;
58 case OSPF6_SCOPE_AS:
59 lsdb = OSPF6_PROCESS(lsa->lsdb->data)->lsdb;
60 break;
61 default:
62 assert(0);
63 break;
64 }
65 return lsdb;
66 }
67
68 struct ospf6_lsdb *ospf6_get_scoped_lsdb_self(struct ospf6_lsa *lsa)
69 {
70 struct ospf6_lsdb *lsdb_self = NULL;
71 switch (OSPF6_LSA_SCOPE(lsa->header->type)) {
72 case OSPF6_SCOPE_LINKLOCAL:
73 lsdb_self = OSPF6_INTERFACE(lsa->lsdb->data)->lsdb_self;
74 break;
75 case OSPF6_SCOPE_AREA:
76 lsdb_self = OSPF6_AREA(lsa->lsdb->data)->lsdb_self;
77 break;
78 case OSPF6_SCOPE_AS:
79 lsdb_self = OSPF6_PROCESS(lsa->lsdb->data)->lsdb_self;
80 break;
81 default:
82 assert(0);
83 break;
84 }
85 return lsdb_self;
86 }
87
88 void ospf6_lsa_originate(struct ospf6 *ospf6, struct ospf6_lsa *lsa)
89 {
90 struct ospf6_lsa *old;
91 struct ospf6_lsdb *lsdb_self;
92
93 if (lsa->header->adv_router == INADDR_ANY) {
94 if (IS_OSPF6_DEBUG_ORIGINATE_TYPE(lsa->header->type))
95 zlog_debug(
96 "Refusing to originate LSA (zero router ID): %s",
97 lsa->name);
98
99 ospf6_lsa_delete(lsa);
100 return;
101 }
102
103 /* find previous LSA */
104 old = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
105 lsa->header->adv_router, lsa->lsdb);
106
107 /* if the new LSA does not differ from previous,
108 suppress this update of the LSA */
109 if (old && !OSPF6_LSA_IS_DIFFER(lsa, old)
110 && !ospf6->gr_info.finishing_restart) {
111 if (IS_OSPF6_DEBUG_ORIGINATE_TYPE(lsa->header->type))
112 zlog_debug("Suppress updating LSA: %s", lsa->name);
113 ospf6_lsa_delete(lsa);
114 return;
115 }
116
117 /* store it in the LSDB for self-originated LSAs */
118 lsdb_self = ospf6_get_scoped_lsdb_self(lsa);
119 ospf6_lsdb_add(ospf6_lsa_copy(lsa), lsdb_self);
120
121 THREAD_OFF(lsa->refresh);
122 thread_add_timer(master, ospf6_lsa_refresh, lsa, OSPF_LS_REFRESH_TIME,
123 &lsa->refresh);
124
125 if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type)
126 || IS_OSPF6_DEBUG_ORIGINATE_TYPE(lsa->header->type)) {
127 zlog_debug("LSA Originate:");
128 ospf6_lsa_header_print(lsa);
129 }
130
131 ospf6_install_lsa(lsa);
132 ospf6_flood(NULL, lsa);
133 }
134
135 void ospf6_lsa_originate_process(struct ospf6_lsa *lsa, struct ospf6 *process)
136 {
137 lsa->lsdb = process->lsdb;
138 ospf6_lsa_originate(process, lsa);
139 }
140
141 void ospf6_lsa_originate_area(struct ospf6_lsa *lsa, struct ospf6_area *oa)
142 {
143 lsa->lsdb = oa->lsdb;
144 ospf6_lsa_originate(oa->ospf6, lsa);
145 }
146
147 void ospf6_lsa_originate_interface(struct ospf6_lsa *lsa,
148 struct ospf6_interface *oi)
149 {
150 lsa->lsdb = oi->lsdb;
151 ospf6_lsa_originate(oi->area->ospf6, lsa);
152 }
153
154 void ospf6_external_lsa_purge(struct ospf6 *ospf6, struct ospf6_lsa *lsa)
155 {
156 uint32_t id = lsa->header->id;
157 struct ospf6_area *oa;
158 struct listnode *lnode;
159
160 ospf6_lsa_purge(lsa);
161
162 /* Delete the corresponding NSSA LSA */
163 for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, lnode, oa)) {
164 lsa = ospf6_lsdb_lookup(htons(OSPF6_LSTYPE_TYPE_7), id,
165 ospf6->router_id, oa->lsdb);
166 if (lsa) {
167 if (IS_OSPF6_DEBUG_NSSA)
168 zlog_debug("withdraw type 7 lsa, LS ID: %u",
169 htonl(id));
170
171 ospf6_lsa_purge(lsa);
172 }
173 }
174 }
175
176 void ospf6_lsa_purge(struct ospf6_lsa *lsa)
177 {
178 struct ospf6_lsa *self;
179 struct ospf6_lsdb *lsdb_self;
180
181 /* remove it from the LSDB for self-originated LSAs */
182 lsdb_self = ospf6_get_scoped_lsdb_self(lsa);
183 self = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
184 lsa->header->adv_router, lsdb_self);
185 if (self) {
186 THREAD_OFF(self->expire);
187 THREAD_OFF(self->refresh);
188 ospf6_lsdb_remove(self, lsdb_self);
189 }
190
191 ospf6_lsa_premature_aging(lsa);
192 }
193
194 /* Puring Multi Link-State IDs LSAs:
195 * Same Advertising Router with Multiple Link-State IDs
196 * LSAs, purging require to traverse all Link-State IDs
197 */
198 void ospf6_lsa_purge_multi_ls_id(struct ospf6_area *oa, struct ospf6_lsa *lsa)
199 {
200 int ls_id = 0;
201 struct ospf6_lsa *lsa_next;
202 uint16_t type;
203
204 type = lsa->header->type;
205
206 ospf6_lsa_purge(lsa);
207
208 lsa_next = ospf6_lsdb_lookup(type, htonl(++ls_id),
209 oa->ospf6->router_id, oa->lsdb);
210 while (lsa_next) {
211 ospf6_lsa_purge(lsa_next);
212 lsa_next = ospf6_lsdb_lookup(type, htonl(++ls_id),
213 oa->ospf6->router_id, oa->lsdb);
214 }
215 }
216
217 void ospf6_increment_retrans_count(struct ospf6_lsa *lsa)
218 {
219 /* The LSA must be the original one (see the description
220 in ospf6_decrement_retrans_count () below) */
221 lsa->retrans_count++;
222 }
223
224 void ospf6_decrement_retrans_count(struct ospf6_lsa *lsa)
225 {
226 struct ospf6_lsdb *lsdb;
227 struct ospf6_lsa *orig;
228
229 /* The LSA must be on the retrans-list of a neighbor. It means
230 the "lsa" is a copied one, and we have to decrement the
231 retransmission count of the original one (instead of this "lsa"'s).
232 In order to find the original LSA, first we have to find
233 appropriate LSDB that have the original LSA. */
234 lsdb = ospf6_get_scoped_lsdb(lsa);
235
236 /* Find the original LSA of which the retrans_count should be
237 * decremented */
238 orig = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
239 lsa->header->adv_router, lsdb);
240 if (orig) {
241 orig->retrans_count--;
242 assert(orig->retrans_count >= 0);
243 }
244 }
245
246 /* RFC2328 section 13.2 Installing LSAs in the database */
247 void ospf6_install_lsa(struct ospf6_lsa *lsa)
248 {
249 struct ospf6 *ospf6;
250 struct timeval now;
251 struct ospf6_lsa *old;
252 struct ospf6_area *area = NULL;
253
254 ospf6 = ospf6_get_by_lsdb(lsa);
255 assert(ospf6);
256
257 /* Remove the old instance from all neighbors' Link state
258 retransmission list (RFC2328 13.2 last paragraph) */
259 old = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
260 lsa->header->adv_router, lsa->lsdb);
261 if (old) {
262 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7) {
263 if (IS_OSPF6_DEBUG_NSSA)
264 zlog_debug("%s : old LSA %s", __func__,
265 lsa->name);
266 lsa->external_lsa_id = old->external_lsa_id;
267 }
268 THREAD_OFF(old->expire);
269 THREAD_OFF(old->refresh);
270 ospf6_flood_clear(old);
271 }
272
273 monotime(&now);
274 if (!OSPF6_LSA_IS_MAXAGE(lsa)) {
275 thread_add_timer(master, ospf6_lsa_expire, lsa,
276 OSPF_LSA_MAXAGE + lsa->birth.tv_sec
277 - now.tv_sec,
278 &lsa->expire);
279 } else
280 lsa->expire = NULL;
281
282 if (OSPF6_LSA_IS_SEQWRAP(lsa)
283 && !(CHECK_FLAG(lsa->flag, OSPF6_LSA_SEQWRAPPED)
284 && lsa->header->seqnum == htonl(OSPF_MAX_SEQUENCE_NUMBER))) {
285 if (IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa->header->type))
286 zlog_debug("lsa install wrapping: sequence 0x%x",
287 ntohl(lsa->header->seqnum));
288 SET_FLAG(lsa->flag, OSPF6_LSA_SEQWRAPPED);
289 /* in lieu of premature_aging, since we do not want to recreate
290 * this lsa
291 * and/or mess with timers etc, we just want to wrap the
292 * sequence number
293 * and reflood the lsa before continuing.
294 * NOTE: Flood needs to be called right after this function
295 * call, by the
296 * caller
297 */
298 lsa->header->seqnum = htonl(OSPF_MAX_SEQUENCE_NUMBER);
299 lsa->header->age = htons(OSPF_LSA_MAXAGE);
300 ospf6_lsa_checksum(lsa->header);
301 }
302
303 if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type)
304 || IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa->header->type))
305 zlog_debug("%s Install LSA: %s age %d seqnum %x in LSDB.",
306 __func__, lsa->name, ntohs(lsa->header->age),
307 ntohl(lsa->header->seqnum));
308
309 /* actually install */
310 lsa->installed = now;
311
312 /* Topo change handling */
313 if (CHECK_LSA_TOPO_CHG_ELIGIBLE(ntohs(lsa->header->type))
314 && !CHECK_FLAG(lsa->flag, OSPF6_LSA_DUPLICATE)) {
315
316 /* check if it is new lsa ? or existing lsa got modified ?*/
317 if (!old || OSPF6_LSA_IS_CHANGED(old, lsa))
318 ospf6_helper_handle_topo_chg(ospf6, lsa);
319 }
320
321 ospf6_lsdb_add(lsa, lsa->lsdb);
322
323 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7
324 && lsa->header->adv_router != ospf6->router_id) {
325 area = OSPF6_AREA(lsa->lsdb->data);
326 ospf6_translated_nssa_refresh(area, lsa, NULL);
327 ospf6_schedule_abr_task(area->ospf6);
328 }
329
330 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_ROUTER) {
331 area = OSPF6_AREA(lsa->lsdb->data);
332 if (old == NULL) {
333 if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type)
334 || IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa->header->type))
335 zlog_debug("%s: New router LSA %s", __func__,
336 lsa->name);
337 ospf6_abr_nssa_check_status(area->ospf6);
338 }
339 }
340 return;
341 }
342
343 /* RFC2740 section 3.5.2. Sending Link State Update packets */
344 /* RFC2328 section 13.3 Next step in the flooding procedure */
345 void ospf6_flood_interface(struct ospf6_neighbor *from, struct ospf6_lsa *lsa,
346 struct ospf6_interface *oi)
347 {
348 struct listnode *node, *nnode;
349 struct ospf6_neighbor *on;
350 struct ospf6_lsa *req, *old;
351 int retrans_added = 0;
352 int is_debug = 0;
353
354 if (IS_OSPF6_DEBUG_FLOODING
355 || IS_OSPF6_DEBUG_FLOOD_TYPE(lsa->header->type)) {
356 is_debug++;
357 zlog_debug("Flooding on %s: %s", oi->interface->name,
358 lsa->name);
359 }
360
361 /* (1) For each neighbor */
362 for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
363 if (is_debug)
364 zlog_debug("To neighbor %s", on->name);
365
366 /* (a) if neighbor state < Exchange, examin next */
367 if (on->state < OSPF6_NEIGHBOR_EXCHANGE) {
368 if (is_debug)
369 zlog_debug(
370 "Neighbor state less than ExChange, next neighbor");
371 continue;
372 }
373
374 /* (b) if neighbor not yet Full, check request-list */
375 if (on->state != OSPF6_NEIGHBOR_FULL) {
376 if (is_debug)
377 zlog_debug("Neighbor not yet Full");
378
379 req = ospf6_lsdb_lookup(
380 lsa->header->type, lsa->header->id,
381 lsa->header->adv_router, on->request_list);
382 if (req == NULL) {
383 if (is_debug)
384 zlog_debug(
385 "Not on request-list for this neighbor");
386 /* fall through */
387 } else {
388 /* If new LSA less recent, examin next neighbor
389 */
390 if (ospf6_lsa_compare(lsa, req) > 0) {
391 if (is_debug)
392 zlog_debug(
393 "Requesting is older, next neighbor");
394 continue;
395 }
396
397 /* If the same instance, delete from
398 request-list and
399 examin next neighbor */
400 if (ospf6_lsa_compare(lsa, req) == 0) {
401 if (is_debug)
402 zlog_debug(
403 "Requesting the same, remove it, next neighbor");
404 if (req == on->last_ls_req) {
405 /* sanity check refcount */
406 assert(req->lock >= 2);
407 req = ospf6_lsa_unlock(req);
408 on->last_ls_req = NULL;
409 }
410 if (req)
411 ospf6_lsdb_remove(
412 req, on->request_list);
413 ospf6_check_nbr_loading(on);
414 continue;
415 }
416
417 /* If the new LSA is more recent, delete from
418 * request-list */
419 if (ospf6_lsa_compare(lsa, req) < 0) {
420 if (is_debug)
421 zlog_debug(
422 "Received is newer, remove requesting");
423 if (req == on->last_ls_req) {
424 req = ospf6_lsa_unlock(req);
425 on->last_ls_req = NULL;
426 }
427 if (req)
428 ospf6_lsdb_remove(req,
429 on->request_list);
430 ospf6_check_nbr_loading(on);
431 /* fall through */
432 }
433 }
434 }
435
436 /* (c) If the new LSA was received from this neighbor,
437 examin next neighbor */
438 if (from == on) {
439 if (is_debug)
440 zlog_debug(
441 "Received is from the neighbor, next neighbor");
442 continue;
443 }
444
445 if ((oi->area->ospf6->inst_shutdown)
446 || CHECK_FLAG(lsa->flag, OSPF6_LSA_FLUSH)) {
447 if (is_debug)
448 zlog_debug(
449 "%s: Send LSA %s (age %d) update now",
450 __func__, lsa->name,
451 ntohs(lsa->header->age));
452 ospf6_lsupdate_send_neighbor_now(on, lsa);
453 continue;
454 } else {
455 /* (d) add retrans-list, schedule retransmission */
456 if (is_debug)
457 zlog_debug("Add retrans-list of neighbor %s ",
458 on->name);
459
460 /* Do not increment the retrans count if the lsa is
461 * already present in the retrans list.
462 */
463 old = ospf6_lsdb_lookup(
464 lsa->header->type, lsa->header->id,
465 lsa->header->adv_router, on->retrans_list);
466 if (!old) {
467 if (is_debug)
468 zlog_debug(
469 "Increment %s from retrans_list of %s",
470 lsa->name, on->name);
471 ospf6_increment_retrans_count(lsa);
472 ospf6_lsdb_add(ospf6_lsa_copy(lsa),
473 on->retrans_list);
474 thread_add_timer(
475 master, ospf6_lsupdate_send_neighbor,
476 on, on->ospf6_if->rxmt_interval,
477 &on->thread_send_lsupdate);
478 retrans_added++;
479 }
480 }
481 }
482
483 /* (2) examin next interface if not added to retrans-list */
484 if (retrans_added == 0) {
485 if (is_debug)
486 zlog_debug(
487 "No retransmission scheduled, next interface %s",
488 oi->interface->name);
489 return;
490 }
491
492 /* (3) If the new LSA was received on this interface,
493 and it was from DR or BDR, examin next interface */
494 if (from && from->ospf6_if == oi
495 && (from->router_id == oi->drouter
496 || from->router_id == oi->bdrouter)) {
497 if (is_debug)
498 zlog_debug(
499 "Received is from the I/F's DR or BDR, next interface");
500 return;
501 }
502
503 /* (4) If the new LSA was received on this interface,
504 and the interface state is BDR, examin next interface */
505 if (from && from->ospf6_if == oi) {
506 if (oi->state == OSPF6_INTERFACE_BDR) {
507 if (is_debug)
508 zlog_debug(
509 "Received is from the I/F, itself BDR, next interface");
510 return;
511 }
512 SET_FLAG(lsa->flag, OSPF6_LSA_FLOODBACK);
513 }
514
515 /* (5) flood the LSA out the interface. */
516 if (is_debug)
517 zlog_debug("Schedule flooding for the interface");
518 if ((oi->type == OSPF_IFTYPE_BROADCAST)
519 || (oi->type == OSPF_IFTYPE_POINTOPOINT)) {
520 ospf6_lsdb_add(ospf6_lsa_copy(lsa), oi->lsupdate_list);
521 thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0,
522 &oi->thread_send_lsupdate);
523 } else {
524 /* reschedule retransmissions to all neighbors */
525 for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
526 THREAD_OFF(on->thread_send_lsupdate);
527 thread_add_event(master, ospf6_lsupdate_send_neighbor,
528 on, 0, &on->thread_send_lsupdate);
529 }
530 }
531 }
532
533 void ospf6_flood_area(struct ospf6_neighbor *from, struct ospf6_lsa *lsa,
534 struct ospf6_area *oa)
535 {
536 struct listnode *node, *nnode;
537 struct ospf6_interface *oi;
538
539 for (ALL_LIST_ELEMENTS(oa->if_list, node, nnode, oi)) {
540 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_LINKLOCAL
541 && oi != OSPF6_INTERFACE(lsa->lsdb->data))
542 continue;
543
544 ospf6_flood_interface(from, lsa, oi);
545 }
546 }
547
548 static void ospf6_flood_process(struct ospf6_neighbor *from,
549 struct ospf6_lsa *lsa, struct ospf6 *process)
550 {
551 struct listnode *node, *nnode;
552 struct ospf6_area *oa;
553
554 for (ALL_LIST_ELEMENTS(process->area_list, node, nnode, oa)) {
555
556 /* If unknown LSA and U-bit clear, treat as link local
557 * flooding scope
558 */
559 if (!OSPF6_LSA_IS_KNOWN(lsa->header->type)
560 && !(ntohs(lsa->header->type) & OSPF6_LSTYPE_UBIT_MASK)
561 && (oa != OSPF6_INTERFACE(lsa->lsdb->data)->area)) {
562
563 if (IS_OSPF6_DEBUG_FLOODING)
564 zlog_debug("Unknown LSA, do not flood");
565 continue;
566 }
567
568 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_AREA
569 && oa != OSPF6_AREA(lsa->lsdb->data))
570 continue;
571 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_LINKLOCAL
572 && oa != OSPF6_INTERFACE(lsa->lsdb->data)->area)
573 continue;
574
575 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_AS_EXTERNAL
576 && (IS_AREA_STUB(oa) || IS_AREA_NSSA(oa)))
577 continue;
578
579 /* Check for NSSA LSA */
580 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7
581 && !IS_AREA_NSSA(oa) && !OSPF6_LSA_IS_MAXAGE(lsa))
582 continue;
583
584 ospf6_flood_area(from, lsa, oa);
585 }
586 }
587
588 void ospf6_flood(struct ospf6_neighbor *from, struct ospf6_lsa *lsa)
589 {
590 struct ospf6 *ospf6;
591
592 ospf6 = ospf6_get_by_lsdb(lsa);
593 if (ospf6 == NULL)
594 return;
595
596 ospf6_flood_process(from, lsa, ospf6);
597 }
598
599 static void ospf6_flood_clear_interface(struct ospf6_lsa *lsa,
600 struct ospf6_interface *oi)
601 {
602 struct listnode *node, *nnode;
603 struct ospf6_neighbor *on;
604 struct ospf6_lsa *rem;
605
606 for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
607 rem = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
608 lsa->header->adv_router,
609 on->retrans_list);
610 if (rem && !ospf6_lsa_compare(rem, lsa)) {
611 if (IS_OSPF6_DEBUG_FLOODING
612 || IS_OSPF6_DEBUG_FLOOD_TYPE(lsa->header->type))
613 zlog_debug("Remove %s from retrans_list of %s",
614 rem->name, on->name);
615 ospf6_decrement_retrans_count(rem);
616 ospf6_lsdb_remove(rem, on->retrans_list);
617 }
618 }
619 }
620
621 void ospf6_flood_clear_area(struct ospf6_lsa *lsa, struct ospf6_area *oa)
622 {
623 struct listnode *node, *nnode;
624 struct ospf6_interface *oi;
625
626 for (ALL_LIST_ELEMENTS(oa->if_list, node, nnode, oi)) {
627 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_LINKLOCAL
628 && oi != OSPF6_INTERFACE(lsa->lsdb->data))
629 continue;
630
631 ospf6_flood_clear_interface(lsa, oi);
632 }
633 }
634
635 static void ospf6_flood_clear_process(struct ospf6_lsa *lsa,
636 struct ospf6 *process)
637 {
638 struct listnode *node, *nnode;
639 struct ospf6_area *oa;
640
641 for (ALL_LIST_ELEMENTS(process->area_list, node, nnode, oa)) {
642 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_AREA
643 && oa != OSPF6_AREA(lsa->lsdb->data))
644 continue;
645 if (OSPF6_LSA_SCOPE(lsa->header->type) == OSPF6_SCOPE_LINKLOCAL
646 && oa != OSPF6_INTERFACE(lsa->lsdb->data)->area)
647 continue;
648
649 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_AS_EXTERNAL
650 && (IS_AREA_STUB(oa) || (IS_AREA_NSSA(oa))))
651 continue;
652 /* Check for NSSA LSA */
653 if (ntohs(lsa->header->type) == OSPF6_LSTYPE_TYPE_7
654 && !IS_AREA_NSSA(oa))
655 continue;
656
657 ospf6_flood_clear_area(lsa, oa);
658 }
659 }
660
661 void ospf6_flood_clear(struct ospf6_lsa *lsa)
662 {
663 struct ospf6 *ospf6;
664
665 ospf6 = ospf6_get_by_lsdb(lsa);
666 if (ospf6 == NULL)
667 return;
668 ospf6_flood_clear_process(lsa, ospf6);
669 }
670
671
672 /* RFC2328 13.5 (Table 19): Sending link state acknowledgements. */
673 static void ospf6_acknowledge_lsa_bdrouter(struct ospf6_lsa *lsa,
674 int ismore_recent,
675 struct ospf6_neighbor *from)
676 {
677 struct ospf6_interface *oi;
678 int is_debug = 0;
679
680 if (IS_OSPF6_DEBUG_FLOODING
681 || IS_OSPF6_DEBUG_FLOOD_TYPE(lsa->header->type))
682 is_debug++;
683
684 assert(from && from->ospf6_if);
685 oi = from->ospf6_if;
686
687 /* LSA is more recent than database copy, but was not flooded
688 back out receiving interface. Delayed acknowledgement sent
689 if advertisement received from Designated Router,
690 otherwide do nothing. */
691 if (ismore_recent < 0) {
692 if (oi->drouter == from->router_id) {
693 if (is_debug)
694 zlog_debug(
695 "Delayed acknowledgement (BDR & MoreRecent & from DR)");
696 /* Delayed acknowledgement */
697 ospf6_lsdb_add(ospf6_lsa_copy(lsa), oi->lsack_list);
698 thread_add_timer(master, ospf6_lsack_send_interface, oi,
699 3, &oi->thread_send_lsack);
700 } else {
701 if (is_debug)
702 zlog_debug(
703 "No acknowledgement (BDR & MoreRecent & ! from DR)");
704 }
705 return;
706 }
707
708 /* LSA is a duplicate, and was treated as an implied acknowledgement.
709 Delayed acknowledgement sent if advertisement received from
710 Designated Router, otherwise do nothing */
711 if (CHECK_FLAG(lsa->flag, OSPF6_LSA_DUPLICATE)
712 && CHECK_FLAG(lsa->flag, OSPF6_LSA_IMPLIEDACK)) {
713 if (oi->drouter == from->router_id) {
714 if (is_debug)
715 zlog_debug(
716 "Delayed acknowledgement (BDR & Duplicate & ImpliedAck & from DR)");
717 /* Delayed acknowledgement */
718 ospf6_lsdb_add(ospf6_lsa_copy(lsa), oi->lsack_list);
719 thread_add_timer(master, ospf6_lsack_send_interface, oi,
720 3, &oi->thread_send_lsack);
721 } else {
722 if (is_debug)
723 zlog_debug(
724 "No acknowledgement (BDR & Duplicate & ImpliedAck & ! from DR)");
725 }
726 return;
727 }
728
729 /* LSA is a duplicate, and was not treated as an implied
730 acknowledgement.
731 Direct acknowledgement sent */
732 if (CHECK_FLAG(lsa->flag, OSPF6_LSA_DUPLICATE)
733 && !CHECK_FLAG(lsa->flag, OSPF6_LSA_IMPLIEDACK)) {
734 if (is_debug)
735 zlog_debug("Direct acknowledgement (BDR & Duplicate)");
736 ospf6_lsdb_add(ospf6_lsa_copy(lsa), from->lsack_list);
737 thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
738 &from->thread_send_lsack);
739 return;
740 }
741
742 /* LSA's LS age is equal to Maxage, and there is no current instance
743 of the LSA in the link state database, and none of router's
744 neighbors are in states Exchange or Loading */
745 /* Direct acknowledgement sent, but this case is handled in
746 early of ospf6_receive_lsa () */
747 }
748
749 static void ospf6_acknowledge_lsa_allother(struct ospf6_lsa *lsa,
750 int ismore_recent,
751 struct ospf6_neighbor *from)
752 {
753 struct ospf6_interface *oi;
754 int is_debug = 0;
755
756 if (IS_OSPF6_DEBUG_FLOODING
757 || IS_OSPF6_DEBUG_FLOOD_TYPE(lsa->header->type))
758 is_debug++;
759
760 assert(from && from->ospf6_if);
761 oi = from->ospf6_if;
762
763 /* LSA has been flood back out receiving interface.
764 No acknowledgement sent. */
765 if (CHECK_FLAG(lsa->flag, OSPF6_LSA_FLOODBACK)) {
766 if (is_debug)
767 zlog_debug("No acknowledgement (AllOther & FloodBack)");
768 return;
769 }
770
771 /* LSA is more recent than database copy, but was not flooded
772 back out receiving interface. Delayed acknowledgement sent. */
773 if (ismore_recent < 0) {
774 if (is_debug)
775 zlog_debug(
776 "Delayed acknowledgement (AllOther & MoreRecent)");
777 /* Delayed acknowledgement */
778 ospf6_lsdb_add(ospf6_lsa_copy(lsa), oi->lsack_list);
779 thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
780 &oi->thread_send_lsack);
781 return;
782 }
783
784 /* LSA is a duplicate, and was treated as an implied acknowledgement.
785 No acknowledgement sent. */
786 if (CHECK_FLAG(lsa->flag, OSPF6_LSA_DUPLICATE)
787 && CHECK_FLAG(lsa->flag, OSPF6_LSA_IMPLIEDACK)) {
788 if (is_debug)
789 zlog_debug(
790 "No acknowledgement (AllOther & Duplicate & ImpliedAck)");
791 return;
792 }
793
794 /* LSA is a duplicate, and was not treated as an implied
795 acknowledgement.
796 Direct acknowledgement sent */
797 if (CHECK_FLAG(lsa->flag, OSPF6_LSA_DUPLICATE)
798 && !CHECK_FLAG(lsa->flag, OSPF6_LSA_IMPLIEDACK)) {
799 if (is_debug)
800 zlog_debug(
801 "Direct acknowledgement (AllOther & Duplicate)");
802 ospf6_lsdb_add(ospf6_lsa_copy(lsa), from->lsack_list);
803 thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
804 &from->thread_send_lsack);
805 return;
806 }
807
808 /* LSA's LS age is equal to Maxage, and there is no current instance
809 of the LSA in the link state database, and none of router's
810 neighbors are in states Exchange or Loading */
811 /* Direct acknowledgement sent, but this case is handled in
812 early of ospf6_receive_lsa () */
813 }
814
815 static void ospf6_acknowledge_lsa(struct ospf6_lsa *lsa, int ismore_recent,
816 struct ospf6_neighbor *from)
817 {
818 struct ospf6_interface *oi;
819
820 assert(from && from->ospf6_if);
821 oi = from->ospf6_if;
822
823 if (oi->state == OSPF6_INTERFACE_BDR)
824 ospf6_acknowledge_lsa_bdrouter(lsa, ismore_recent, from);
825 else
826 ospf6_acknowledge_lsa_allother(lsa, ismore_recent, from);
827 }
828
829 /* RFC2328 section 13 (4):
830 if MaxAge LSA and if we have no instance, and no neighbor
831 is in states Exchange or Loading
832 returns 1 if match this case, else returns 0 */
833 static int ospf6_is_maxage_lsa_drop(struct ospf6_lsa *lsa,
834 struct ospf6_neighbor *from)
835 {
836 struct ospf6_neighbor *on;
837 struct ospf6_interface *oi;
838 struct ospf6_area *oa;
839 struct ospf6 *process = NULL;
840 struct listnode *i, *j, *k;
841 int count = 0;
842
843 if (!OSPF6_LSA_IS_MAXAGE(lsa))
844 return 0;
845
846 if (ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
847 lsa->header->adv_router, lsa->lsdb))
848 return 0;
849
850 process = from->ospf6_if->area->ospf6;
851
852 for (ALL_LIST_ELEMENTS_RO(process->area_list, i, oa))
853 for (ALL_LIST_ELEMENTS_RO(oa->if_list, j, oi))
854 for (ALL_LIST_ELEMENTS_RO(oi->neighbor_list, k, on))
855 if (on->state == OSPF6_NEIGHBOR_EXCHANGE
856 || on->state == OSPF6_NEIGHBOR_LOADING)
857 count++;
858
859 if (count == 0)
860 return 1;
861 return 0;
862 }
863
864 /* RFC2328 section 13 The Flooding Procedure */
865 void ospf6_receive_lsa(struct ospf6_neighbor *from,
866 struct ospf6_lsa_header *lsa_header)
867 {
868 struct ospf6_lsa *new = NULL, *old = NULL, *rem = NULL;
869 int ismore_recent;
870 int is_debug = 0;
871 unsigned int time_delta_ms;
872
873 ismore_recent = 1;
874 assert(from);
875
876 /* if we receive a LSA with invalid seqnum drop it */
877 if (ntohl(lsa_header->seqnum) - 1 == OSPF_MAX_SEQUENCE_NUMBER) {
878 if (IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa_header->type)) {
879 zlog_debug(
880 "received lsa [%s Id:%pI4 Adv:%pI4] with invalid seqnum 0x%x, ignore",
881 ospf6_lstype_name(lsa_header->type),
882 &lsa_header->id, &lsa_header->adv_router,
883 ntohl(lsa_header->seqnum));
884 }
885 return;
886 }
887
888 /* make lsa structure for received lsa */
889 new = ospf6_lsa_create(lsa_header);
890
891 if (IS_OSPF6_DEBUG_FLOODING
892 || IS_OSPF6_DEBUG_FLOOD_TYPE(new->header->type)) {
893 is_debug++;
894 zlog_debug("LSA Receive from %s", from->name);
895 ospf6_lsa_header_print(new);
896 }
897
898 /* (1) LSA Checksum */
899 if (!ospf6_lsa_checksum_valid(new->header)) {
900 if (is_debug)
901 zlog_debug("Wrong LSA Checksum, discard");
902 ospf6_lsa_delete(new);
903 return;
904 }
905
906 /* (2) Examine the LSA's LS type.
907 RFC2470 3.5.1. Receiving Link State Update packets */
908 if (IS_AREA_STUB(from->ospf6_if->area)
909 && OSPF6_LSA_SCOPE(new->header->type) == OSPF6_SCOPE_AS) {
910 if (is_debug)
911 zlog_debug(
912 "AS-External-LSA (or AS-scope LSA) in stub area, discard");
913 ospf6_lsa_delete(new);
914 return;
915 }
916
917 /* (3) LSA which have reserved scope is discarded
918 RFC2470 3.5.1. Receiving Link State Update packets */
919 /* Flooding scope check. LSAs with unknown scope are discarded here.
920 Set appropriate LSDB for the LSA */
921 switch (OSPF6_LSA_SCOPE(new->header->type)) {
922 case OSPF6_SCOPE_LINKLOCAL:
923 new->lsdb = from->ospf6_if->lsdb;
924 break;
925 case OSPF6_SCOPE_AREA:
926 new->lsdb = from->ospf6_if->area->lsdb;
927 break;
928 case OSPF6_SCOPE_AS:
929 new->lsdb = from->ospf6_if->area->ospf6->lsdb;
930 break;
931 default:
932 if (is_debug)
933 zlog_debug("LSA has reserved scope, discard");
934 ospf6_lsa_delete(new);
935 return;
936 }
937
938 /* (4) if MaxAge LSA and if we have no instance, and no neighbor
939 is in states Exchange or Loading */
940 if (ospf6_is_maxage_lsa_drop(new, from)) {
941 /* log */
942 if (is_debug)
943 zlog_debug(
944 "Drop MaxAge LSA with direct acknowledgement.");
945
946 /* a) Acknowledge back to neighbor (Direct acknowledgement,
947 * 13.5) */
948 ospf6_lsdb_add(ospf6_lsa_copy(new), from->lsack_list);
949 thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
950 &from->thread_send_lsack);
951
952 /* b) Discard */
953 ospf6_lsa_delete(new);
954 return;
955 }
956
957 /* (5) */
958 /* lookup the same database copy in lsdb */
959 old = ospf6_lsdb_lookup(new->header->type, new->header->id,
960 new->header->adv_router, new->lsdb);
961 if (old) {
962 ismore_recent = ospf6_lsa_compare(new, old);
963 if (ntohl(new->header->seqnum) == ntohl(old->header->seqnum)) {
964 if (is_debug)
965 zlog_debug("Received is duplicated LSA");
966 SET_FLAG(new->flag, OSPF6_LSA_DUPLICATE);
967 }
968 }
969
970 /* if no database copy or received is more recent */
971 if (old == NULL || ismore_recent < 0) {
972 bool self_originated;
973
974 /* in case we have no database copy */
975 ismore_recent = -1;
976
977 /* (a) MinLSArrival check */
978 if (old) {
979 struct timeval now, res;
980 monotime(&now);
981 timersub(&now, &old->installed, &res);
982 time_delta_ms =
983 (res.tv_sec * 1000) + (int)(res.tv_usec / 1000);
984 if (time_delta_ms
985 < from->ospf6_if->area->ospf6->lsa_minarrival) {
986 if (is_debug)
987 zlog_debug(
988 "LSA can't be updated within MinLSArrival, %dms < %dms, discard",
989 time_delta_ms,
990 from->ospf6_if->area->ospf6
991 ->lsa_minarrival);
992 ospf6_lsa_delete(new);
993 return; /* examin next lsa */
994 }
995 }
996
997 monotime(&new->received);
998
999 if (is_debug)
1000 zlog_debug(
1001 "Install, Flood, Possibly acknowledge the received LSA");
1002
1003 /* Remove older copies of this LSA from retx lists */
1004 if (old)
1005 ospf6_flood_clear(old);
1006
1007 self_originated = (new->header->adv_router
1008 == from->ospf6_if->area->ospf6->router_id);
1009
1010 /* Received non-self-originated Grace LSA. */
1011 if (IS_GRACE_LSA(new) && !self_originated) {
1012 struct ospf6 *ospf6;
1013
1014 ospf6 = ospf6_get_by_lsdb(new);
1015
1016 assert(ospf6);
1017
1018 if (OSPF6_LSA_IS_MAXAGE(new)) {
1019
1020 if (IS_DEBUG_OSPF6_GR)
1021 zlog_debug(
1022 "%s, Received a maxage GraceLSA from router %pI4",
1023 __func__,
1024 &new->header->adv_router);
1025 if (old) {
1026 ospf6_process_maxage_grace_lsa(
1027 ospf6, new, from);
1028 } else {
1029 if (IS_DEBUG_OSPF6_GR)
1030 zlog_debug(
1031 "%s, GraceLSA doesn't exist in lsdb, so discarding GraceLSA",
1032 __func__);
1033 return;
1034 }
1035 } else {
1036
1037 if (IS_DEBUG_OSPF6_GR)
1038 zlog_debug(
1039 "%s, Received a GraceLSA from router %pI4",
1040 __func__,
1041 &new->header->adv_router);
1042
1043 if (ospf6_process_grace_lsa(ospf6, new, from)
1044 == OSPF6_GR_NOT_HELPER) {
1045 if (IS_DEBUG_OSPF6_GR)
1046 zlog_debug(
1047 "%s, Not moving to HELPER role, So dicarding GraceLSA",
1048 __func__);
1049 return;
1050 }
1051 }
1052 }
1053
1054 /* (b) immediately flood and (c) remove from all retrans-list */
1055 /* Prevent self-originated LSA to be flooded. this is to make
1056 * reoriginated instance of the LSA not to be rejected by other
1057 * routers due to MinLSArrival.
1058 */
1059 if (!self_originated)
1060 ospf6_flood(from, new);
1061
1062 /* (d), installing lsdb, which may cause routing
1063 table calculation (replacing database copy) */
1064 ospf6_install_lsa(new);
1065
1066 if (OSPF6_LSA_IS_MAXAGE(new))
1067 ospf6_maxage_remove(from->ospf6_if->area->ospf6);
1068
1069 /* (e) possibly acknowledge */
1070 ospf6_acknowledge_lsa(new, ismore_recent, from);
1071
1072 /* (f) Self Originated LSA, section 13.4 */
1073 if (self_originated) {
1074 if (from->ospf6_if->area->ospf6->gr_info
1075 .restart_in_progress) {
1076 if (IS_DEBUG_OSPF6_GR)
1077 zlog_debug(
1078 "Graceful Restart in progress -- not flushing self-originated LSA: %s",
1079 new->name);
1080 return;
1081 }
1082
1083 /* Self-originated LSA (newer than ours) is received
1084 from
1085 another router. We have to make a new instance of the
1086 LSA
1087 or have to flush this LSA. */
1088 if (is_debug) {
1089 zlog_debug(
1090 "Newer instance of the self-originated LSA");
1091 zlog_debug("Schedule reorigination");
1092 }
1093 thread_add_event(master, ospf6_lsa_refresh, new, 0,
1094 &new->refresh);
1095 }
1096
1097 struct ospf6 *ospf6 = from->ospf6_if->area->ospf6;
1098 struct ospf6_area *area = from->ospf6_if->area;
1099 if (ospf6->gr_info.restart_in_progress)
1100 ospf6_gr_check_lsdb_consistency(ospf6, area);
1101
1102 return;
1103 }
1104
1105 /* (6) if there is instance on sending neighbor's request list */
1106 if (ospf6_lsdb_lookup(new->header->type, new->header->id,
1107 new->header->adv_router, from->request_list)) {
1108 /* if no database copy, should go above state (5) */
1109 assert(old);
1110
1111 zlog_warn(
1112 "Received is not newer, on the neighbor %s request-list",
1113 from->name);
1114 zlog_warn(
1115 "BadLSReq, discard the received LSA lsa %s send badLSReq",
1116 new->name);
1117
1118 /* BadLSReq */
1119 thread_add_event(master, bad_lsreq, from, 0, NULL);
1120
1121 ospf6_lsa_delete(new);
1122 return;
1123 }
1124
1125 /* (7) if neither one is more recent */
1126 if (ismore_recent == 0) {
1127 if (is_debug)
1128 zlog_debug(
1129 "The same instance as database copy (neither recent)");
1130
1131 /* (a) if on retrans-list, Treat this LSA as an Ack: Implied Ack
1132 */
1133 rem = ospf6_lsdb_lookup(new->header->type, new->header->id,
1134 new->header->adv_router,
1135 from->retrans_list);
1136 if (rem) {
1137 if (is_debug) {
1138 zlog_debug(
1139 "It is on the neighbor's retrans-list.");
1140 zlog_debug(
1141 "Treat as an Implied acknowledgement");
1142 }
1143 SET_FLAG(new->flag, OSPF6_LSA_IMPLIEDACK);
1144 ospf6_decrement_retrans_count(rem);
1145 ospf6_lsdb_remove(rem, from->retrans_list);
1146 }
1147
1148 if (is_debug)
1149 zlog_debug("Possibly acknowledge and then discard");
1150
1151 /* (b) possibly acknowledge */
1152 ospf6_acknowledge_lsa(new, ismore_recent, from);
1153
1154 ospf6_lsa_delete(new);
1155 return;
1156 }
1157
1158 /* (8) previous database copy is more recent */
1159 {
1160 assert(old);
1161
1162 /* If database copy is in 'Seqnumber Wrapping',
1163 simply discard the received LSA */
1164 if (OSPF6_LSA_IS_MAXAGE(old)
1165 && old->header->seqnum == htonl(OSPF_MAX_SEQUENCE_NUMBER)) {
1166 if (is_debug) {
1167 zlog_debug("The LSA is in Seqnumber Wrapping");
1168 zlog_debug("MaxAge & MaxSeqNum, discard");
1169 }
1170 ospf6_lsa_delete(new);
1171 return;
1172 }
1173
1174 /* Otherwise, Send database copy of this LSA to this neighbor */
1175 {
1176 if (is_debug) {
1177 zlog_debug("Database copy is more recent.");
1178 zlog_debug(
1179 "Send back directly and then discard");
1180 }
1181
1182 /* Neighbor router sent recent age for LSA,
1183 * Router could be restarted while current copy is
1184 * MAXAGEd and not removed.*/
1185 if (OSPF6_LSA_IS_MAXAGE(old)
1186 && !OSPF6_LSA_IS_MAXAGE(new)) {
1187 if (new->header->adv_router
1188 != from->ospf6_if->area->ospf6->router_id) {
1189 if (is_debug)
1190 zlog_debug(
1191 "%s: Current copy of LSA %s is MAXAGE, but new has recent age, flooding/installing.",
1192 __PRETTY_FUNCTION__, old->name);
1193 ospf6_lsa_purge(old);
1194 ospf6_flood(from, new);
1195 ospf6_install_lsa(new);
1196 return;
1197 }
1198 /* For self-originated LSA, only trust
1199 * ourselves. Fall through and send
1200 * LS Update with our current copy.
1201 */
1202 if (is_debug)
1203 zlog_debug(
1204 "%s: Current copy of self-originated LSA %s is MAXAGE, but new has recent age, re-sending current one.",
1205 __PRETTY_FUNCTION__, old->name);
1206 }
1207
1208 /* XXX, MinLSArrival check !? RFC 2328 13 (8) */
1209
1210 ospf6_lsdb_add(ospf6_lsa_copy(old),
1211 from->lsupdate_list);
1212 thread_add_event(master, ospf6_lsupdate_send_neighbor,
1213 from, 0, &from->thread_send_lsupdate);
1214
1215 ospf6_lsa_delete(new);
1216 return;
1217 }
1218 }
1219 }
1220
1221 DEFUN (debug_ospf6_flooding,
1222 debug_ospf6_flooding_cmd,
1223 "debug ospf6 flooding",
1224 DEBUG_STR
1225 OSPF6_STR
1226 "Debug OSPFv3 flooding function\n"
1227 )
1228 {
1229 OSPF6_DEBUG_FLOODING_ON();
1230 return CMD_SUCCESS;
1231 }
1232
1233 DEFUN (no_debug_ospf6_flooding,
1234 no_debug_ospf6_flooding_cmd,
1235 "no debug ospf6 flooding",
1236 NO_STR
1237 DEBUG_STR
1238 OSPF6_STR
1239 "Debug OSPFv3 flooding function\n"
1240 )
1241 {
1242 OSPF6_DEBUG_FLOODING_OFF();
1243 return CMD_SUCCESS;
1244 }
1245
1246 int config_write_ospf6_debug_flood(struct vty *vty)
1247 {
1248 if (IS_OSPF6_DEBUG_FLOODING)
1249 vty_out(vty, "debug ospf6 flooding\n");
1250 return 0;
1251 }
1252
1253 void install_element_ospf6_debug_flood(void)
1254 {
1255 install_element(ENABLE_NODE, &debug_ospf6_flooding_cmd);
1256 install_element(ENABLE_NODE, &no_debug_ospf6_flooding_cmd);
1257 install_element(CONFIG_NODE, &debug_ospf6_flooding_cmd);
1258 install_element(CONFIG_NODE, &no_debug_ospf6_flooding_cmd);
1259 }
FRRouting mirror