]> git.proxmox.com Git - mirror_frr.git/blob - ospfd/ospf_vty.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
build, vtysh: extract vtysh commands from .xref
[mirror_frr.git] / ospfd / ospf_vty.c
1 /* OSPF VTY interface.
2 * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
3 * Copyright (C) 2000 Toshiaki Takada
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23 #include <string.h>
24
25 #include "printfrr.h"
26 #include "monotime.h"
27 #include "memory.h"
28 #include "thread.h"
29 #include "prefix.h"
30 #include "table.h"
31 #include "vty.h"
32 #include "command.h"
33 #include "plist.h"
34 #include "log.h"
35 #include "zclient.h"
36 #include <lib/json.h>
37 #include "defaults.h"
38 #include "lib/printfrr.h"
39
40 #include "ospfd/ospfd.h"
41 #include "ospfd/ospf_asbr.h"
42 #include "ospfd/ospf_lsa.h"
43 #include "ospfd/ospf_lsdb.h"
44 #include "ospfd/ospf_ism.h"
45 #include "ospfd/ospf_interface.h"
46 #include "ospfd/ospf_nsm.h"
47 #include "ospfd/ospf_neighbor.h"
48 #include "ospfd/ospf_flood.h"
49 #include "ospfd/ospf_abr.h"
50 #include "ospfd/ospf_spf.h"
51 #include "ospfd/ospf_route.h"
52 #include "ospfd/ospf_zebra.h"
53 /*#include "ospfd/ospf_routemap.h" */
54 #include "ospfd/ospf_vty.h"
55 #include "ospfd/ospf_dump.h"
56 #include "ospfd/ospf_bfd.h"
57 #include "ospfd/ospf_ldp_sync.h"
58 #include "ospfd/ospf_orr.h"
59
60
61 FRR_CFG_DEFAULT_BOOL(OSPF_LOG_ADJACENCY_CHANGES,
62 { .val_bool = true, .match_profile = "datacenter", },
63 { .val_bool = false },
64 );
65
66 static const char *const ospf_network_type_str[] = {
67 "Null", "POINTOPOINT", "BROADCAST", "NBMA", "POINTOMULTIPOINT",
68 "VIRTUALLINK", "LOOPBACK"};
69
70 /* Utility functions. */
71 int str2area_id(const char *str, struct in_addr *area_id, int *area_id_fmt)
72 {
73 char *ep;
74
75 area_id->s_addr = htonl(strtoul(str, &ep, 10));
76 if (*ep && !inet_aton(str, area_id))
77 return -1;
78
79 *area_id_fmt =
80 *ep ? OSPF_AREA_ID_FMT_DOTTEDQUAD : OSPF_AREA_ID_FMT_DECIMAL;
81
82 return 0;
83 }
84
85 static void area_id2str(char *buf, int length, struct in_addr *area_id,
86 int area_id_fmt)
87 {
88 if (area_id_fmt == OSPF_AREA_ID_FMT_DOTTEDQUAD)
89 inet_ntop(AF_INET, area_id, buf, length);
90 else
91 snprintf(buf, length, "%lu",
92 (unsigned long)ntohl(area_id->s_addr));
93 }
94
95 static int str2metric(const char *str, int *metric)
96 {
97 /* Sanity check. */
98 if (str == NULL)
99 return 0;
100
101 *metric = strtol(str, NULL, 10);
102 if (*metric < 0 || *metric > 16777214) {
103 /* vty_out (vty, "OSPF metric value is invalid\n"); */
104 return 0;
105 }
106
107 return 1;
108 }
109
110 static int str2metric_type(const char *str, int *metric_type)
111 {
112 /* Sanity check. */
113 if (str == NULL)
114 return 0;
115
116 if (strncmp(str, "1", 1) == 0)
117 *metric_type = EXTERNAL_METRIC_TYPE_1;
118 else if (strncmp(str, "2", 1) == 0)
119 *metric_type = EXTERNAL_METRIC_TYPE_2;
120 else
121 return 0;
122
123 return 1;
124 }
125
126 int ospf_oi_count(struct interface *ifp)
127 {
128 struct route_node *rn;
129 int i = 0;
130
131 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn))
132 if (rn->info)
133 i++;
134
135 return i;
136 }
137
138 #define OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf) \
139 if (argv_find(argv, argc, "vrf", &idx_vrf)) { \
140 vrf_name = argv[idx_vrf + 1]->arg; \
141 all_vrf = strmatch(vrf_name, "all"); \
142 }
143
144 static int ospf_router_cmd_parse(struct vty *vty, struct cmd_token *argv[],
145 const int argc, unsigned short *instance,
146 const char **vrf_name)
147 {
148 int idx_vrf = 0, idx_inst = 0;
149
150 *instance = 0;
151 if (argv_find(argv, argc, "(1-65535)", &idx_inst)) {
152 if (ospf_instance == 0) {
153 vty_out(vty,
154 "%% OSPF is not running in instance mode\n");
155 return CMD_WARNING_CONFIG_FAILED;
156 }
157
158 *instance = strtoul(argv[idx_inst]->arg, NULL, 10);
159 }
160
161 *vrf_name = VRF_DEFAULT_NAME;
162 if (argv_find(argv, argc, "vrf", &idx_vrf)) {
163 if (ospf_instance != 0) {
164 vty_out(vty,
165 "%% VRF is not supported in instance mode\n");
166 return CMD_WARNING_CONFIG_FAILED;
167 }
168
169 *vrf_name = argv[idx_vrf + 1]->arg;
170 }
171
172 return CMD_SUCCESS;
173 }
174
175 static void ospf_show_vrf_name(struct ospf *ospf, struct vty *vty,
176 json_object *json, uint8_t use_vrf)
177 {
178 if (use_vrf) {
179 if (json) {
180 json_object_string_add(json, "vrfName",
181 ospf_get_name(ospf));
182 json_object_int_add(json, "vrfId", ospf->vrf_id);
183 } else
184 vty_out(vty, "VRF Name: %s\n", ospf_get_name(ospf));
185 }
186 }
187
188 #include "ospfd/ospf_vty_clippy.c"
189
190 DEFUN_NOSH (router_ospf,
191 router_ospf_cmd,
192 "router ospf [{(1-65535)|vrf NAME}]",
193 "Enable a routing process\n"
194 "Start OSPF configuration\n"
195 "Instance ID\n"
196 VRF_CMD_HELP_STR)
197 {
198 unsigned short instance;
199 const char *vrf_name;
200 bool created = false;
201 struct ospf *ospf;
202 int ret;
203
204 ret = ospf_router_cmd_parse(vty, argv, argc, &instance, &vrf_name);
205 if (ret != CMD_SUCCESS)
206 return ret;
207
208 if (instance != ospf_instance) {
209 VTY_PUSH_CONTEXT_NULL(OSPF_NODE);
210 return CMD_NOT_MY_INSTANCE;
211 }
212
213 ospf = ospf_get(instance, vrf_name, &created);
214
215 if (created)
216 if (DFLT_OSPF_LOG_ADJACENCY_CHANGES)
217 SET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES);
218
219 if (IS_DEBUG_OSPF_EVENT)
220 zlog_debug(
221 "Config command 'router ospf %d' received, vrf %s id %u oi_running %u",
222 ospf->instance, ospf_get_name(ospf), ospf->vrf_id,
223 ospf->oi_running);
224
225 VTY_PUSH_CONTEXT(OSPF_NODE, ospf);
226
227 return ret;
228 }
229
230 DEFUN (no_router_ospf,
231 no_router_ospf_cmd,
232 "no router ospf [{(1-65535)|vrf NAME}]",
233 NO_STR
234 "Enable a routing process\n"
235 "Start OSPF configuration\n"
236 "Instance ID\n"
237 VRF_CMD_HELP_STR)
238 {
239 unsigned short instance;
240 const char *vrf_name;
241 struct ospf *ospf;
242 int ret;
243
244 ret = ospf_router_cmd_parse(vty, argv, argc, &instance, &vrf_name);
245 if (ret != CMD_SUCCESS)
246 return ret;
247
248 if (instance != ospf_instance)
249 return CMD_NOT_MY_INSTANCE;
250
251 ospf = ospf_lookup(instance, vrf_name);
252 if (ospf)
253 ospf_finish(ospf);
254 else
255 ret = CMD_WARNING_CONFIG_FAILED;
256
257 return ret;
258 }
259
260
261 DEFPY (ospf_router_id,
262 ospf_router_id_cmd,
263 "ospf router-id A.B.C.D",
264 "OSPF specific commands\n"
265 "router-id for the OSPF process\n"
266 "OSPF router-id in IP address format\n")
267 {
268 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
269
270 struct listnode *node;
271 struct ospf_area *area;
272
273 ospf->router_id_static = router_id;
274
275 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area))
276 if (area->full_nbrs) {
277 vty_out(vty,
278 "For this router-id change to take effect, use \"clear ip ospf process\" command\n");
279 return CMD_SUCCESS;
280 }
281
282 ospf_router_id_update(ospf);
283
284 return CMD_SUCCESS;
285 }
286
287 DEFUN_HIDDEN (ospf_router_id_old,
288 ospf_router_id_old_cmd,
289 "router-id A.B.C.D",
290 "router-id for the OSPF process\n"
291 "OSPF router-id in IP address format\n")
292 {
293 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
294 int idx_ipv4 = 1;
295 struct listnode *node;
296 struct ospf_area *area;
297 struct in_addr router_id;
298 int ret;
299
300 ret = inet_aton(argv[idx_ipv4]->arg, &router_id);
301 if (!ret) {
302 vty_out(vty, "Please specify Router ID by A.B.C.D\n");
303 return CMD_WARNING_CONFIG_FAILED;
304 }
305
306 ospf->router_id_static = router_id;
307
308 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area))
309 if (area->full_nbrs) {
310 vty_out(vty,
311 "For this router-id change to take effect, use \"clear ip ospf process\" command\n");
312 return CMD_SUCCESS;
313 }
314
315 ospf_router_id_update(ospf);
316
317 return CMD_SUCCESS;
318 }
319
320 DEFPY (no_ospf_router_id,
321 no_ospf_router_id_cmd,
322 "no ospf router-id [A.B.C.D]",
323 NO_STR
324 "OSPF specific commands\n"
325 "router-id for the OSPF process\n"
326 "OSPF router-id in IP address format\n")
327 {
328 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
329 struct listnode *node;
330 struct ospf_area *area;
331
332 if (router_id_str) {
333 if (!IPV4_ADDR_SAME(&ospf->router_id_static, &router_id)) {
334 vty_out(vty, "%% OSPF router-id doesn't match\n");
335 return CMD_WARNING_CONFIG_FAILED;
336 }
337 }
338
339 ospf->router_id_static.s_addr = 0;
340
341 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area))
342 if (area->full_nbrs) {
343 vty_out(vty,
344 "For this router-id change to take effect, use \"clear ip ospf process\" command\n");
345 return CMD_SUCCESS;
346 }
347
348 ospf_router_id_update(ospf);
349
350 return CMD_SUCCESS;
351 }
352
353
354 static void ospf_passive_interface_default_update(struct ospf *ospf,
355 uint8_t newval)
356 {
357 struct listnode *ln;
358 struct ospf_interface *oi;
359
360 ospf->passive_interface_default = newval;
361
362 /* update multicast memberships */
363 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, ln, oi))
364 ospf_if_set_multicast(oi);
365 }
366
367 static void ospf_passive_interface_update(struct interface *ifp,
368 struct ospf_if_params *params,
369 struct in_addr addr, uint8_t newval)
370 {
371 struct route_node *rn;
372
373 if (OSPF_IF_PARAM_CONFIGURED(params, passive_interface)) {
374 if (params->passive_interface == newval)
375 return;
376
377 params->passive_interface = newval;
378 UNSET_IF_PARAM(params, passive_interface);
379 if (params != IF_DEF_PARAMS(ifp)) {
380 ospf_free_if_params(ifp, addr);
381 ospf_if_update_params(ifp, addr);
382 }
383 } else {
384 params->passive_interface = newval;
385 SET_IF_PARAM(params, passive_interface);
386 }
387
388 /*
389 * XXX We should call ospf_if_set_multicast on exactly those
390 * interfaces for which the passive property changed. It is too much
391 * work to determine this set, so we do this for every interface.
392 * This is safe and reasonable because ospf_if_set_multicast uses a
393 * record of joined groups to avoid systems calls if the desired
394 * memberships match the current memership.
395 */
396
397 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
398 struct ospf_interface *oi = rn->info;
399
400 if (oi)
401 ospf_if_set_multicast(oi);
402 }
403
404 /*
405 * XXX It is not clear what state transitions the interface needs to
406 * undergo when going from active to passive and vice versa. Fixing
407 * this will require precise identification of interfaces having such a
408 * transition.
409 */
410 }
411
412 DEFUN (ospf_passive_interface_default,
413 ospf_passive_interface_default_cmd,
414 "passive-interface default",
415 "Suppress routing updates on an interface\n"
416 "Suppress routing updates on interfaces by default\n")
417 {
418 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
419
420 ospf_passive_interface_default_update(ospf, OSPF_IF_PASSIVE);
421
422 return CMD_SUCCESS;
423 }
424
425 DEFUN_HIDDEN (ospf_passive_interface_addr,
426 ospf_passive_interface_addr_cmd,
427 "passive-interface IFNAME [A.B.C.D]",
428 "Suppress routing updates on an interface\n"
429 "Interface's name\n"
430 "IPv4 address\n")
431 {
432 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
433 int idx_ipv4 = 2;
434 struct interface *ifp = NULL;
435 struct in_addr addr = {.s_addr = INADDR_ANY};
436 struct ospf_if_params *params;
437 int ret;
438
439 vty_out(vty,
440 "This command is deprecated, because it is not VRF-aware.\n");
441 vty_out(vty,
442 "Please, use \"ip ospf passive\" on an interface instead.\n");
443
444 if (ospf->vrf_id != VRF_UNKNOWN)
445 ifp = if_get_by_name(argv[1]->arg, ospf->vrf_id, ospf->name);
446
447 if (ifp == NULL) {
448 vty_out(vty, "interface %s not found.\n", (char *)argv[1]->arg);
449 return CMD_WARNING_CONFIG_FAILED;
450 }
451
452 if (argc == 3) {
453 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
454 if (!ret) {
455 vty_out(vty,
456 "Please specify interface address by A.B.C.D\n");
457 return CMD_WARNING_CONFIG_FAILED;
458 }
459
460 params = ospf_get_if_params(ifp, addr);
461 ospf_if_update_params(ifp, addr);
462 } else {
463 params = IF_DEF_PARAMS(ifp);
464 }
465
466 ospf_passive_interface_update(ifp, params, addr, OSPF_IF_PASSIVE);
467
468 return CMD_SUCCESS;
469 }
470
471 DEFUN (no_ospf_passive_interface_default,
472 no_ospf_passive_interface_default_cmd,
473 "no passive-interface default",
474 NO_STR
475 "Allow routing updates on an interface\n"
476 "Allow routing updates on interfaces by default\n")
477 {
478 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
479
480 ospf_passive_interface_default_update(ospf, OSPF_IF_ACTIVE);
481
482 return CMD_SUCCESS;
483 }
484
485 DEFUN_HIDDEN (no_ospf_passive_interface,
486 no_ospf_passive_interface_addr_cmd,
487 "no passive-interface IFNAME [A.B.C.D]",
488 NO_STR
489 "Allow routing updates on an interface\n"
490 "Interface's name\n"
491 "IPv4 address\n")
492 {
493 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
494 int idx_ipv4 = 3;
495 struct interface *ifp = NULL;
496 struct in_addr addr = {.s_addr = INADDR_ANY};
497 struct ospf_if_params *params;
498 int ret;
499
500 vty_out(vty,
501 "This command is deprecated, because it is not VRF-aware.\n");
502 vty_out(vty,
503 "Please, use \"no ip ospf passive\" on an interface instead.\n");
504
505 if (ospf->vrf_id != VRF_UNKNOWN)
506 ifp = if_get_by_name(argv[2]->arg, ospf->vrf_id, ospf->name);
507
508 if (ifp == NULL) {
509 vty_out(vty, "interface %s not found.\n", (char *)argv[2]->arg);
510 return CMD_WARNING_CONFIG_FAILED;
511 }
512
513 if (argc == 4) {
514 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
515 if (!ret) {
516 vty_out(vty,
517 "Please specify interface address by A.B.C.D\n");
518 return CMD_WARNING_CONFIG_FAILED;
519 }
520 params = ospf_lookup_if_params(ifp, addr);
521 if (params == NULL)
522 return CMD_SUCCESS;
523 } else {
524 params = IF_DEF_PARAMS(ifp);
525 }
526
527 ospf_passive_interface_update(ifp, params, addr, OSPF_IF_ACTIVE);
528
529 return CMD_SUCCESS;
530 }
531
532
533 DEFUN (ospf_network_area,
534 ospf_network_area_cmd,
535 "network A.B.C.D/M area <A.B.C.D|(0-4294967295)>",
536 "Enable routing on an IP network\n"
537 "OSPF network prefix\n"
538 "Set the OSPF area ID\n"
539 "OSPF area ID in IP address format\n"
540 "OSPF area ID as a decimal value\n")
541 {
542 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
543 int idx_ipv4_prefixlen = 1;
544 int idx_ipv4_number = 3;
545 struct prefix_ipv4 p;
546 struct in_addr area_id;
547 int ret, format;
548 uint32_t count;
549
550 if (ospf->instance) {
551 vty_out(vty,
552 "The network command is not supported in multi-instance ospf\n");
553 return CMD_WARNING_CONFIG_FAILED;
554 }
555
556 count = ospf_count_area_params(ospf);
557 if (count > 0) {
558 vty_out(vty,
559 "Please remove all ip ospf area x.x.x.x commands first.\n");
560 if (IS_DEBUG_OSPF_EVENT)
561 zlog_debug(
562 "%s ospf vrf %s num of %u ip ospf area x config",
563 __func__, ospf_get_name(ospf), count);
564 return CMD_WARNING_CONFIG_FAILED;
565 }
566
567 /* Get network prefix and Area ID. */
568 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
569 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
570
571 ret = ospf_network_set(ospf, &p, area_id, format);
572 if (ret == 0) {
573 vty_out(vty, "There is already same network statement.\n");
574 return CMD_WARNING_CONFIG_FAILED;
575 }
576
577 return CMD_SUCCESS;
578 }
579
580 DEFUN (no_ospf_network_area,
581 no_ospf_network_area_cmd,
582 "no network A.B.C.D/M area <A.B.C.D|(0-4294967295)>",
583 NO_STR
584 "Enable routing on an IP network\n"
585 "OSPF network prefix\n"
586 "Set the OSPF area ID\n"
587 "OSPF area ID in IP address format\n"
588 "OSPF area ID as a decimal value\n")
589 {
590 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
591 int idx_ipv4_prefixlen = 2;
592 int idx_ipv4_number = 4;
593 struct prefix_ipv4 p;
594 struct in_addr area_id;
595 int ret, format;
596
597 if (ospf->instance) {
598 vty_out(vty,
599 "The network command is not supported in multi-instance ospf\n");
600 return CMD_WARNING_CONFIG_FAILED;
601 }
602
603 /* Get network prefix and Area ID. */
604 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
605 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
606
607 ret = ospf_network_unset(ospf, &p, area_id);
608 if (ret == 0) {
609 vty_out(vty,
610 "Can't find specified network area configuration.\n");
611 return CMD_WARNING_CONFIG_FAILED;
612 }
613
614 return CMD_SUCCESS;
615 }
616
617 DEFUN (ospf_area_range,
618 ospf_area_range_cmd,
619 "area <A.B.C.D|(0-4294967295)> range A.B.C.D/M [advertise [cost (0-16777215)]]",
620 "OSPF area parameters\n"
621 "OSPF area ID in IP address format\n"
622 "OSPF area ID as a decimal value\n"
623 "Summarize routes matching address/mask (border routers only)\n"
624 "Area range prefix\n"
625 "Advertise this range (default)\n"
626 "User specified metric for this range\n"
627 "Advertised metric for this range\n")
628 {
629 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
630 int idx_ipv4_number = 1;
631 int idx_ipv4_prefixlen = 3;
632 int idx_cost = 6;
633 struct prefix_ipv4 p;
634 struct in_addr area_id;
635 int format;
636 uint32_t cost;
637
638 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
639 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
640
641 ospf_area_range_set(ospf, area_id, &p, OSPF_AREA_RANGE_ADVERTISE);
642 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
643 format);
644 if (argc > 5) {
645 cost = strtoul(argv[idx_cost]->arg, NULL, 10);
646 ospf_area_range_cost_set(ospf, area_id, &p, cost);
647 }
648
649 return CMD_SUCCESS;
650 }
651
652 DEFUN (ospf_area_range_cost,
653 ospf_area_range_cost_cmd,
654 "area <A.B.C.D|(0-4294967295)> range A.B.C.D/M {cost (0-16777215)|substitute A.B.C.D/M}",
655 "OSPF area parameters\n"
656 "OSPF area ID in IP address format\n"
657 "OSPF area ID as a decimal value\n"
658 "Summarize routes matching address/mask (border routers only)\n"
659 "Area range prefix\n"
660 "User specified metric for this range\n"
661 "Advertised metric for this range\n"
662 "Announce area range as another prefix\n"
663 "Network prefix to be announced instead of range\n")
664 {
665 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
666 int idx_ipv4_number = 1;
667 int idx_ipv4_prefixlen = 3;
668 int idx = 4;
669 struct prefix_ipv4 p, s;
670 struct in_addr area_id;
671 int format;
672 uint32_t cost;
673
674 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
675 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
676
677 ospf_area_range_set(ospf, area_id, &p, OSPF_AREA_RANGE_ADVERTISE);
678 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
679 format);
680
681 if (argv_find(argv, argc, "cost", &idx)) {
682 cost = strtoul(argv[idx + 1]->arg, NULL, 10);
683 ospf_area_range_cost_set(ospf, area_id, &p, cost);
684 }
685
686 idx = 4;
687 if (argv_find(argv, argc, "substitute", &idx)) {
688 str2prefix_ipv4(argv[idx + 1]->arg, &s);
689 ospf_area_range_substitute_set(ospf, area_id, &p, &s);
690 }
691
692 return CMD_SUCCESS;
693 }
694
695 DEFUN (ospf_area_range_not_advertise,
696 ospf_area_range_not_advertise_cmd,
697 "area <A.B.C.D|(0-4294967295)> range A.B.C.D/M not-advertise",
698 "OSPF area parameters\n"
699 "OSPF area ID in IP address format\n"
700 "OSPF area ID as a decimal value\n"
701 "Summarize routes matching address/mask (border routers only)\n"
702 "Area range prefix\n"
703 "DoNotAdvertise this range\n")
704 {
705 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
706 int idx_ipv4_number = 1;
707 int idx_ipv4_prefixlen = 3;
708 struct prefix_ipv4 p;
709 struct in_addr area_id;
710 int format;
711
712 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
713 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
714
715 ospf_area_range_set(ospf, area_id, &p, 0);
716 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
717 format);
718 ospf_area_range_substitute_unset(ospf, area_id, &p);
719
720 return CMD_SUCCESS;
721 }
722
723 DEFUN (no_ospf_area_range,
724 no_ospf_area_range_cmd,
725 "no area <A.B.C.D|(0-4294967295)> range A.B.C.D/M [<cost (0-16777215)|advertise [cost (0-16777215)]|not-advertise>]",
726 NO_STR
727 "OSPF area parameters\n"
728 "OSPF area ID in IP address format\n"
729 "OSPF area ID as a decimal value\n"
730 "Summarize routes matching address/mask (border routers only)\n"
731 "Area range prefix\n"
732 "User specified metric for this range\n"
733 "Advertised metric for this range\n"
734 "Advertise this range (default)\n"
735 "User specified metric for this range\n"
736 "Advertised metric for this range\n"
737 "DoNotAdvertise this range\n")
738 {
739 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
740 int idx_ipv4_number = 2;
741 int idx_ipv4_prefixlen = 4;
742 struct prefix_ipv4 p;
743 struct in_addr area_id;
744 int format;
745
746 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
747 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
748
749 ospf_area_range_unset(ospf, area_id, &p);
750
751 return CMD_SUCCESS;
752 }
753
754 DEFUN (no_ospf_area_range_substitute,
755 no_ospf_area_range_substitute_cmd,
756 "no area <A.B.C.D|(0-4294967295)> range A.B.C.D/M substitute A.B.C.D/M",
757 NO_STR
758 "OSPF area parameters\n"
759 "OSPF area ID in IP address format\n"
760 "OSPF area ID as a decimal value\n"
761 "Summarize routes matching address/mask (border routers only)\n"
762 "Area range prefix\n"
763 "Announce area range as another prefix\n"
764 "Network prefix to be announced instead of range\n")
765 {
766 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
767 int idx_ipv4_number = 2;
768 int idx_ipv4_prefixlen = 4;
769 int idx_ipv4_prefixlen_2 = 6;
770 struct prefix_ipv4 p, s;
771 struct in_addr area_id;
772 int format;
773
774 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
775 str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
776 str2prefix_ipv4(argv[idx_ipv4_prefixlen_2]->arg, &s);
777
778 ospf_area_range_substitute_unset(ospf, area_id, &p);
779
780 return CMD_SUCCESS;
781 }
782
783
784 /* Command Handler Logic in VLink stuff is delicate!!
785
786 ALTER AT YOUR OWN RISK!!!!
787
788 Various dummy values are used to represent 'NoChange' state for
789 VLink configuration NOT being changed by a VLink command, and
790 special syntax is used within the command strings so that the
791 typed in command verbs can be seen in the configuration command
792 bacckend handler. This is to drastically reduce the verbeage
793 required to coe up with a reasonably compatible Cisco VLink command
794
795 - Matthew Grant <grantma@anathoth.gen.nz>
796 Wed, 21 Feb 2001 15:13:52 +1300
797 */
798
799 /* Configuration data for virtual links
800 */
801 struct ospf_vl_config_data {
802 struct vty *vty; /* vty stuff */
803 struct in_addr area_id; /* area ID from command line */
804 int area_id_fmt; /* command line area ID format */
805 struct in_addr vl_peer; /* command line vl_peer */
806 int auth_type; /* Authehntication type, if given */
807 char *auth_key; /* simple password if present */
808 int crypto_key_id; /* Cryptographic key ID */
809 char *md5_key; /* MD5 authentication key */
810 int hello_interval; /* Obvious what these are... */
811 int retransmit_interval;
812 int transmit_delay;
813 int dead_interval;
814 };
815
816 static void ospf_vl_config_data_init(struct ospf_vl_config_data *vl_config,
817 struct vty *vty)
818 {
819 memset(vl_config, 0, sizeof(struct ospf_vl_config_data));
820 vl_config->auth_type = OSPF_AUTH_CMD_NOTSEEN;
821 vl_config->vty = vty;
822 }
823
824 static struct ospf_vl_data *
825 ospf_find_vl_data(struct ospf *ospf, struct ospf_vl_config_data *vl_config)
826 {
827 struct ospf_area *area;
828 struct ospf_vl_data *vl_data;
829 struct vty *vty;
830 struct in_addr area_id;
831
832 vty = vl_config->vty;
833 area_id = vl_config->area_id;
834
835 if (area_id.s_addr == OSPF_AREA_BACKBONE) {
836 vty_out(vty,
837 "Configuring VLs over the backbone is not allowed\n");
838 return NULL;
839 }
840 area = ospf_area_get(ospf, area_id);
841 ospf_area_display_format_set(ospf, area, vl_config->area_id_fmt);
842
843 if (area->external_routing != OSPF_AREA_DEFAULT) {
844 if (vl_config->area_id_fmt == OSPF_AREA_ID_FMT_DOTTEDQUAD)
845 vty_out(vty, "Area %pI4 is %s\n", &area_id,
846 area->external_routing == OSPF_AREA_NSSA
847 ? "nssa"
848 : "stub");
849 else
850 vty_out(vty, "Area %ld is %s\n",
851 (unsigned long)ntohl(area_id.s_addr),
852 area->external_routing == OSPF_AREA_NSSA
853 ? "nssa"
854 : "stub");
855 return NULL;
856 }
857
858 if ((vl_data = ospf_vl_lookup(ospf, area, vl_config->vl_peer))
859 == NULL) {
860 vl_data = ospf_vl_data_new(area, vl_config->vl_peer);
861 if (vl_data->vl_oi == NULL) {
862 vl_data->vl_oi = ospf_vl_new(ospf, vl_data);
863 ospf_vl_add(ospf, vl_data);
864 ospf_spf_calculate_schedule(ospf,
865 SPF_FLAG_CONFIG_CHANGE);
866 }
867 }
868 return vl_data;
869 }
870
871
872 static int ospf_vl_set_security(struct ospf_vl_data *vl_data,
873 struct ospf_vl_config_data *vl_config)
874 {
875 struct crypt_key *ck;
876 struct vty *vty;
877 struct interface *ifp = vl_data->vl_oi->ifp;
878
879 vty = vl_config->vty;
880
881 if (vl_config->auth_type != OSPF_AUTH_CMD_NOTSEEN) {
882 SET_IF_PARAM(IF_DEF_PARAMS(ifp), auth_type);
883 IF_DEF_PARAMS(ifp)->auth_type = vl_config->auth_type;
884 }
885
886 if (vl_config->auth_key) {
887 memset(IF_DEF_PARAMS(ifp)->auth_simple, 0,
888 OSPF_AUTH_SIMPLE_SIZE + 1);
889 strlcpy((char *)IF_DEF_PARAMS(ifp)->auth_simple,
890 vl_config->auth_key,
891 sizeof(IF_DEF_PARAMS(ifp)->auth_simple));
892 } else if (vl_config->md5_key) {
893 if (ospf_crypt_key_lookup(IF_DEF_PARAMS(ifp)->auth_crypt,
894 vl_config->crypto_key_id)
895 != NULL) {
896 vty_out(vty, "OSPF: Key %d already exists\n",
897 vl_config->crypto_key_id);
898 return CMD_WARNING;
899 }
900 ck = ospf_crypt_key_new();
901 ck->key_id = vl_config->crypto_key_id;
902 memset(ck->auth_key, 0, OSPF_AUTH_MD5_SIZE + 1);
903 strlcpy((char *)ck->auth_key, vl_config->md5_key,
904 sizeof(ck->auth_key));
905
906 ospf_crypt_key_add(IF_DEF_PARAMS(ifp)->auth_crypt, ck);
907 } else if (vl_config->crypto_key_id != 0) {
908 /* Delete a key */
909
910 if (ospf_crypt_key_lookup(IF_DEF_PARAMS(ifp)->auth_crypt,
911 vl_config->crypto_key_id)
912 == NULL) {
913 vty_out(vty, "OSPF: Key %d does not exist\n",
914 vl_config->crypto_key_id);
915 return CMD_WARNING_CONFIG_FAILED;
916 }
917
918 ospf_crypt_key_delete(IF_DEF_PARAMS(ifp)->auth_crypt,
919 vl_config->crypto_key_id);
920 }
921
922 return CMD_SUCCESS;
923 }
924
925 static int ospf_vl_set_timers(struct ospf_vl_data *vl_data,
926 struct ospf_vl_config_data *vl_config)
927 {
928 struct interface *ifp = vl_data->vl_oi->ifp;
929 /* Virtual Link data initialised to defaults, so only set
930 if a value given */
931 if (vl_config->hello_interval) {
932 SET_IF_PARAM(IF_DEF_PARAMS(ifp), v_hello);
933 IF_DEF_PARAMS(ifp)->v_hello = vl_config->hello_interval;
934 }
935
936 if (vl_config->dead_interval) {
937 SET_IF_PARAM(IF_DEF_PARAMS(ifp), v_wait);
938 IF_DEF_PARAMS(ifp)->v_wait = vl_config->dead_interval;
939 }
940
941 if (vl_config->retransmit_interval) {
942 SET_IF_PARAM(IF_DEF_PARAMS(ifp), retransmit_interval);
943 IF_DEF_PARAMS(ifp)->retransmit_interval =
944 vl_config->retransmit_interval;
945 }
946
947 if (vl_config->transmit_delay) {
948 SET_IF_PARAM(IF_DEF_PARAMS(ifp), transmit_delay);
949 IF_DEF_PARAMS(ifp)->transmit_delay = vl_config->transmit_delay;
950 }
951
952 return CMD_SUCCESS;
953 }
954
955
956 /* The business end of all of the above */
957 static int ospf_vl_set(struct ospf *ospf, struct ospf_vl_config_data *vl_config)
958 {
959 struct ospf_vl_data *vl_data;
960 int ret;
961
962 vl_data = ospf_find_vl_data(ospf, vl_config);
963 if (!vl_data)
964 return CMD_WARNING_CONFIG_FAILED;
965
966 /* Process this one first as it can have a fatal result, which can
967 only logically occur if the virtual link exists already
968 Thus a command error does not result in a change to the
969 running configuration such as unexpectedly altered timer
970 values etc.*/
971 ret = ospf_vl_set_security(vl_data, vl_config);
972 if (ret != CMD_SUCCESS)
973 return ret;
974
975 /* Set any time based parameters, these area already range checked */
976
977 ret = ospf_vl_set_timers(vl_data, vl_config);
978 if (ret != CMD_SUCCESS)
979 return ret;
980
981 return CMD_SUCCESS;
982 }
983
984 /* This stuff exists to make specifying all the alias commands A LOT simpler
985 */
986 #define VLINK_HELPSTR_IPADDR \
987 "OSPF area parameters\n" \
988 "OSPF area ID in IP address format\n" \
989 "OSPF area ID as a decimal value\n" \
990 "Configure a virtual link\n" \
991 "Router ID of the remote ABR\n"
992
993 #define VLINK_HELPSTR_AUTHTYPE_SIMPLE \
994 "Enable authentication on this virtual link\n" \
995 "dummy string \n"
996
997 #define VLINK_HELPSTR_AUTHTYPE_ALL \
998 VLINK_HELPSTR_AUTHTYPE_SIMPLE \
999 "Use null authentication\n" \
1000 "Use message-digest authentication\n"
1001
1002 #define VLINK_HELPSTR_TIME_PARAM \
1003 "Time between HELLO packets\n" \
1004 "Seconds\n" \
1005 "Time between retransmitting lost link state advertisements\n" \
1006 "Seconds\n" \
1007 "Link state transmit delay\n" \
1008 "Seconds\n" \
1009 "Interval time after which a neighbor is declared down\n" \
1010 "Seconds\n"
1011
1012 #define VLINK_HELPSTR_AUTH_SIMPLE \
1013 "Authentication password (key)\n" \
1014 "The OSPF password (key)\n"
1015
1016 #define VLINK_HELPSTR_AUTH_MD5 \
1017 "Message digest authentication password (key)\n" \
1018 "Key ID\n" \
1019 "Use MD5 algorithm\n" \
1020 "The OSPF password (key)\n"
1021
1022 DEFUN (ospf_area_vlink,
1023 ospf_area_vlink_cmd,
1024 "area <A.B.C.D|(0-4294967295)> virtual-link A.B.C.D [authentication [<message-digest|null>]] [<message-digest-key (1-255) md5 KEY|authentication-key AUTH_KEY>]",
1025 VLINK_HELPSTR_IPADDR
1026 "Enable authentication on this virtual link\n"
1027 "Use message-digest authentication\n"
1028 "Use null authentication\n"
1029 VLINK_HELPSTR_AUTH_MD5
1030 VLINK_HELPSTR_AUTH_SIMPLE)
1031 {
1032 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1033 int idx_ipv4_number = 1;
1034 int idx_ipv4 = 3;
1035 struct ospf_vl_config_data vl_config;
1036 char auth_key[OSPF_AUTH_SIMPLE_SIZE + 1];
1037 char md5_key[OSPF_AUTH_MD5_SIZE + 1];
1038 int ret;
1039 int idx = 0;
1040
1041 ospf_vl_config_data_init(&vl_config, vty);
1042
1043 /* Read off first 2 parameters and check them */
1044 ret = str2area_id(argv[idx_ipv4_number]->arg, &vl_config.area_id,
1045 &vl_config.area_id_fmt);
1046 if (ret < 0) {
1047 vty_out(vty, "OSPF area ID is invalid\n");
1048 return CMD_WARNING_CONFIG_FAILED;
1049 }
1050
1051 ret = inet_aton(argv[idx_ipv4]->arg, &vl_config.vl_peer);
1052 if (!ret) {
1053 vty_out(vty, "Please specify valid Router ID as a.b.c.d\n");
1054 return CMD_WARNING_CONFIG_FAILED;
1055 }
1056
1057 if (argc <= 4) {
1058 /* Thats all folks! - BUGS B. strikes again!!!*/
1059
1060 return ospf_vl_set(ospf, &vl_config);
1061 }
1062
1063 if (argv_find(argv, argc, "authentication", &idx)) {
1064 /* authentication - this option can only occur
1065 at start of command line */
1066 vl_config.auth_type = OSPF_AUTH_SIMPLE;
1067 }
1068
1069 if (argv_find(argv, argc, "message-digest", &idx)) {
1070 /* authentication message-digest */
1071 vl_config.auth_type = OSPF_AUTH_CRYPTOGRAPHIC;
1072 } else if (argv_find(argv, argc, "null", &idx)) {
1073 /* "authentication null" */
1074 vl_config.auth_type = OSPF_AUTH_NULL;
1075 }
1076
1077 if (argv_find(argv, argc, "message-digest-key", &idx)) {
1078 vl_config.md5_key = NULL;
1079 vl_config.crypto_key_id = strtol(argv[idx + 1]->arg, NULL, 10);
1080 if (vl_config.crypto_key_id < 0)
1081 return CMD_WARNING_CONFIG_FAILED;
1082
1083 strlcpy(md5_key, argv[idx + 3]->arg, sizeof(md5_key));
1084 vl_config.md5_key = md5_key;
1085 }
1086
1087 if (argv_find(argv, argc, "authentication-key", &idx)) {
1088 strlcpy(auth_key, argv[idx + 1]->arg, sizeof(auth_key));
1089 vl_config.auth_key = auth_key;
1090 }
1091
1092 /* Action configuration */
1093
1094 return ospf_vl_set(ospf, &vl_config);
1095 }
1096
1097 DEFUN (no_ospf_area_vlink,
1098 no_ospf_area_vlink_cmd,
1099 "no area <A.B.C.D|(0-4294967295)> virtual-link A.B.C.D [authentication [<message-digest|null>]] [<message-digest-key (1-255) md5 KEY|authentication-key AUTH_KEY>]",
1100 NO_STR
1101 VLINK_HELPSTR_IPADDR
1102 "Enable authentication on this virtual link\n"
1103 "Use message-digest authentication\n"
1104 "Use null authentication\n"
1105 VLINK_HELPSTR_AUTH_MD5
1106 VLINK_HELPSTR_AUTH_SIMPLE)
1107 {
1108 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1109 int idx_ipv4_number = 2;
1110 int idx_ipv4 = 4;
1111 struct ospf_area *area;
1112 struct ospf_vl_config_data vl_config;
1113 struct ospf_vl_data *vl_data = NULL;
1114 char auth_key[OSPF_AUTH_SIMPLE_SIZE + 1];
1115 int idx = 0;
1116 int ret, format;
1117
1118 ospf_vl_config_data_init(&vl_config, vty);
1119
1120 ret = str2area_id(argv[idx_ipv4_number]->arg, &vl_config.area_id,
1121 &format);
1122 if (ret < 0) {
1123 vty_out(vty, "OSPF area ID is invalid\n");
1124 return CMD_WARNING_CONFIG_FAILED;
1125 }
1126
1127 area = ospf_area_lookup_by_area_id(ospf, vl_config.area_id);
1128 if (!area) {
1129 vty_out(vty, "Area does not exist\n");
1130 return CMD_WARNING_CONFIG_FAILED;
1131 }
1132
1133 ret = inet_aton(argv[idx_ipv4]->arg, &vl_config.vl_peer);
1134 if (!ret) {
1135 vty_out(vty, "Please specify valid Router ID as a.b.c.d\n");
1136 return CMD_WARNING_CONFIG_FAILED;
1137 }
1138
1139 vl_data = ospf_vl_lookup(ospf, area, vl_config.vl_peer);
1140 if (!vl_data) {
1141 vty_out(vty, "Virtual link does not exist\n");
1142 return CMD_WARNING_CONFIG_FAILED;
1143 }
1144
1145 if (argc <= 5) {
1146 /* Basic VLink no command */
1147 /* Thats all folks! - BUGS B. strikes again!!!*/
1148 ospf_vl_delete(ospf, vl_data);
1149 ospf_area_check_free(ospf, vl_config.area_id);
1150 return CMD_SUCCESS;
1151 }
1152
1153 /* If we are down here, we are reseting parameters */
1154 /* Deal with other parameters */
1155
1156 if (argv_find(argv, argc, "authentication", &idx)) {
1157 /* authentication - this option can only occur
1158 at start of command line */
1159 vl_config.auth_type = OSPF_AUTH_NOTSET;
1160 }
1161
1162 if (argv_find(argv, argc, "message-digest-key", &idx)) {
1163 vl_config.md5_key = NULL;
1164 vl_config.crypto_key_id = strtol(argv[idx + 1]->arg, NULL, 10);
1165 if (vl_config.crypto_key_id < 0)
1166 return CMD_WARNING_CONFIG_FAILED;
1167 }
1168
1169 if (argv_find(argv, argc, "authentication-key", &idx)) {
1170 /* Reset authentication-key to 0 */
1171 memset(auth_key, 0, OSPF_AUTH_SIMPLE_SIZE + 1);
1172 vl_config.auth_key = auth_key;
1173 }
1174
1175 /* Action configuration */
1176
1177 return ospf_vl_set(ospf, &vl_config);
1178 }
1179
1180 DEFUN (ospf_area_vlink_intervals,
1181 ospf_area_vlink_intervals_cmd,
1182 "area <A.B.C.D|(0-4294967295)> virtual-link A.B.C.D {hello-interval (1-65535)|retransmit-interval (1-65535)|transmit-delay (1-65535)|dead-interval (1-65535)}",
1183 VLINK_HELPSTR_IPADDR
1184 VLINK_HELPSTR_TIME_PARAM)
1185 {
1186 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1187 struct ospf_vl_config_data vl_config;
1188 int ret = 0;
1189
1190 ospf_vl_config_data_init(&vl_config, vty);
1191
1192 char *area_id = argv[1]->arg;
1193 char *router_id = argv[3]->arg;
1194
1195 ret = str2area_id(area_id, &vl_config.area_id, &vl_config.area_id_fmt);
1196 if (ret < 0) {
1197 vty_out(vty, "OSPF area ID is invalid\n");
1198 return CMD_WARNING_CONFIG_FAILED;
1199 }
1200
1201 ret = inet_aton(router_id, &vl_config.vl_peer);
1202 if (!ret) {
1203 vty_out(vty, "Please specify valid Router ID as a.b.c.d\n");
1204 return CMD_WARNING_CONFIG_FAILED;
1205 }
1206
1207 for (int idx = 4; idx < argc; idx++) {
1208 if (strmatch(argv[idx]->text, "hello-interval"))
1209 vl_config.hello_interval =
1210 strtol(argv[++idx]->arg, NULL, 10);
1211 else if (strmatch(argv[idx]->text, "retransmit-interval"))
1212 vl_config.retransmit_interval =
1213 strtol(argv[++idx]->arg, NULL, 10);
1214 else if (strmatch(argv[idx]->text, "transmit-delay"))
1215 vl_config.transmit_delay =
1216 strtol(argv[++idx]->arg, NULL, 10);
1217 else if (strmatch(argv[idx]->text, "dead-interval"))
1218 vl_config.dead_interval =
1219 strtol(argv[++idx]->arg, NULL, 10);
1220 }
1221
1222 /* Action configuration */
1223 return ospf_vl_set(ospf, &vl_config);
1224 }
1225
1226 DEFUN (no_ospf_area_vlink_intervals,
1227 no_ospf_area_vlink_intervals_cmd,
1228 "no area <A.B.C.D|(0-4294967295)> virtual-link A.B.C.D {hello-interval (1-65535)|retransmit-interval (1-65535)|transmit-delay (1-65535)|dead-interval (1-65535)}",
1229 NO_STR
1230 VLINK_HELPSTR_IPADDR
1231 VLINK_HELPSTR_TIME_PARAM)
1232 {
1233 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1234 struct ospf_vl_config_data vl_config;
1235 int ret = 0;
1236
1237 ospf_vl_config_data_init(&vl_config, vty);
1238
1239 char *area_id = argv[2]->arg;
1240 char *router_id = argv[4]->arg;
1241
1242 ret = str2area_id(area_id, &vl_config.area_id, &vl_config.area_id_fmt);
1243 if (ret < 0) {
1244 vty_out(vty, "OSPF area ID is invalid\n");
1245 return CMD_WARNING_CONFIG_FAILED;
1246 }
1247
1248 ret = inet_aton(router_id, &vl_config.vl_peer);
1249 if (!ret) {
1250 vty_out(vty, "Please specify valid Router ID as a.b.c.d\n");
1251 return CMD_WARNING_CONFIG_FAILED;
1252 }
1253
1254 for (int idx = 5; idx < argc; idx++) {
1255 if (strmatch(argv[idx]->text, "hello-interval"))
1256 vl_config.hello_interval = OSPF_HELLO_INTERVAL_DEFAULT;
1257 else if (strmatch(argv[idx]->text, "retransmit-interval"))
1258 vl_config.retransmit_interval =
1259 OSPF_RETRANSMIT_INTERVAL_DEFAULT;
1260 else if (strmatch(argv[idx]->text, "transmit-delay"))
1261 vl_config.transmit_delay = OSPF_TRANSMIT_DELAY_DEFAULT;
1262 else if (strmatch(argv[idx]->text, "dead-interval"))
1263 vl_config.dead_interval =
1264 OSPF_ROUTER_DEAD_INTERVAL_DEFAULT;
1265 }
1266
1267 /* Action configuration */
1268 return ospf_vl_set(ospf, &vl_config);
1269 }
1270
1271 DEFUN (ospf_area_shortcut,
1272 ospf_area_shortcut_cmd,
1273 "area <A.B.C.D|(0-4294967295)> shortcut <default|enable|disable>",
1274 "OSPF area parameters\n"
1275 "OSPF area ID in IP address format\n"
1276 "OSPF area ID as a decimal value\n"
1277 "Configure the area's shortcutting mode\n"
1278 "Set default shortcutting behavior\n"
1279 "Enable shortcutting through the area\n"
1280 "Disable shortcutting through the area\n")
1281 {
1282 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1283 int idx_ipv4_number = 1;
1284 int idx_enable_disable = 3;
1285 struct ospf_area *area;
1286 struct in_addr area_id;
1287 int mode;
1288 int format;
1289
1290 VTY_GET_OSPF_AREA_ID_NO_BB("shortcut", area_id, format,
1291 argv[idx_ipv4_number]->arg);
1292
1293 area = ospf_area_get(ospf, area_id);
1294 ospf_area_display_format_set(ospf, area, format);
1295
1296 if (strncmp(argv[idx_enable_disable]->arg, "de", 2) == 0)
1297 mode = OSPF_SHORTCUT_DEFAULT;
1298 else if (strncmp(argv[idx_enable_disable]->arg, "di", 2) == 0)
1299 mode = OSPF_SHORTCUT_DISABLE;
1300 else if (strncmp(argv[idx_enable_disable]->arg, "e", 1) == 0)
1301 mode = OSPF_SHORTCUT_ENABLE;
1302 else
1303 return CMD_WARNING_CONFIG_FAILED;
1304
1305 ospf_area_shortcut_set(ospf, area, mode);
1306
1307 if (ospf->abr_type != OSPF_ABR_SHORTCUT)
1308 vty_out(vty,
1309 "Shortcut area setting will take effect only when the router is configured as Shortcut ABR\n");
1310
1311 return CMD_SUCCESS;
1312 }
1313
1314 DEFUN (no_ospf_area_shortcut,
1315 no_ospf_area_shortcut_cmd,
1316 "no area <A.B.C.D|(0-4294967295)> shortcut <enable|disable>",
1317 NO_STR
1318 "OSPF area parameters\n"
1319 "OSPF area ID in IP address format\n"
1320 "OSPF area ID as a decimal value\n"
1321 "Deconfigure the area's shortcutting mode\n"
1322 "Deconfigure enabled shortcutting through the area\n"
1323 "Deconfigure disabled shortcutting through the area\n")
1324 {
1325 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1326 int idx_ipv4_number = 2;
1327 struct ospf_area *area;
1328 struct in_addr area_id;
1329 int format;
1330
1331 VTY_GET_OSPF_AREA_ID_NO_BB("shortcut", area_id, format,
1332 argv[idx_ipv4_number]->arg);
1333
1334 area = ospf_area_lookup_by_area_id(ospf, area_id);
1335 if (!area)
1336 return CMD_SUCCESS;
1337
1338 ospf_area_shortcut_unset(ospf, area);
1339
1340 return CMD_SUCCESS;
1341 }
1342
1343
1344 DEFUN (ospf_area_stub,
1345 ospf_area_stub_cmd,
1346 "area <A.B.C.D|(0-4294967295)> stub",
1347 "OSPF area parameters\n"
1348 "OSPF area ID in IP address format\n"
1349 "OSPF area ID as a decimal value\n"
1350 "Configure OSPF area as stub\n")
1351 {
1352 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1353 int idx_ipv4_number = 1;
1354 struct in_addr area_id;
1355 int ret, format;
1356
1357 VTY_GET_OSPF_AREA_ID_NO_BB("stub", area_id, format,
1358 argv[idx_ipv4_number]->arg);
1359
1360 ret = ospf_area_stub_set(ospf, area_id);
1361 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1362 format);
1363 if (ret == 0) {
1364 vty_out(vty,
1365 "First deconfigure all virtual link through this area\n");
1366 return CMD_WARNING_CONFIG_FAILED;
1367 }
1368
1369 /* Flush the external LSAs from the specified area */
1370 ospf_flush_lsa_from_area(ospf, area_id, OSPF_AS_EXTERNAL_LSA);
1371 ospf_area_no_summary_unset(ospf, area_id);
1372
1373 return CMD_SUCCESS;
1374 }
1375
1376 DEFUN (ospf_area_stub_no_summary,
1377 ospf_area_stub_no_summary_cmd,
1378 "area <A.B.C.D|(0-4294967295)> stub no-summary",
1379 "OSPF stub parameters\n"
1380 "OSPF area ID in IP address format\n"
1381 "OSPF area ID as a decimal value\n"
1382 "Configure OSPF area as stub\n"
1383 "Do not inject inter-area routes into stub\n")
1384 {
1385 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1386 int idx_ipv4_number = 1;
1387 struct in_addr area_id;
1388 int ret, format;
1389
1390 VTY_GET_OSPF_AREA_ID_NO_BB("stub", area_id, format,
1391 argv[idx_ipv4_number]->arg);
1392
1393 ret = ospf_area_stub_set(ospf, area_id);
1394 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1395 format);
1396 if (ret == 0) {
1397 vty_out(vty,
1398 "%% Area cannot be stub as it contains a virtual link\n");
1399 return CMD_WARNING_CONFIG_FAILED;
1400 }
1401
1402 ospf_area_no_summary_set(ospf, area_id);
1403
1404 return CMD_SUCCESS;
1405 }
1406
1407 DEFUN (no_ospf_area_stub,
1408 no_ospf_area_stub_cmd,
1409 "no area <A.B.C.D|(0-4294967295)> stub",
1410 NO_STR
1411 "OSPF area parameters\n"
1412 "OSPF area ID in IP address format\n"
1413 "OSPF area ID as a decimal value\n"
1414 "Configure OSPF area as stub\n")
1415 {
1416 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1417 int idx_ipv4_number = 2;
1418 struct in_addr area_id;
1419 int format;
1420
1421 VTY_GET_OSPF_AREA_ID_NO_BB("stub", area_id, format,
1422 argv[idx_ipv4_number]->arg);
1423
1424 ospf_area_stub_unset(ospf, area_id);
1425 ospf_area_no_summary_unset(ospf, area_id);
1426
1427 return CMD_SUCCESS;
1428 }
1429
1430 DEFUN (no_ospf_area_stub_no_summary,
1431 no_ospf_area_stub_no_summary_cmd,
1432 "no area <A.B.C.D|(0-4294967295)> stub no-summary",
1433 NO_STR
1434 "OSPF area parameters\n"
1435 "OSPF area ID in IP address format\n"
1436 "OSPF area ID as a decimal value\n"
1437 "Configure OSPF area as stub\n"
1438 "Do not inject inter-area routes into area\n")
1439 {
1440 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1441 int idx_ipv4_number = 2;
1442 struct in_addr area_id;
1443 int format;
1444
1445 VTY_GET_OSPF_AREA_ID_NO_BB("stub", area_id, format,
1446 argv[idx_ipv4_number]->arg);
1447 ospf_area_no_summary_unset(ospf, area_id);
1448
1449 return CMD_SUCCESS;
1450 }
1451
1452 static int ospf_area_nssa_cmd_handler(struct vty *vty, int argc,
1453 struct cmd_token **argv, int cfg_nosum,
1454 int nosum)
1455 {
1456 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1457 struct in_addr area_id;
1458 int ret, format;
1459
1460 VTY_GET_OSPF_AREA_ID_NO_BB("NSSA", area_id, format, argv[1]->arg);
1461
1462 ret = ospf_area_nssa_set(ospf, area_id);
1463 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1464 format);
1465 if (ret == 0) {
1466 vty_out(vty,
1467 "%% Area cannot be nssa as it contains a virtual link\n");
1468 return CMD_WARNING_CONFIG_FAILED;
1469 }
1470
1471 if (argc > 3) {
1472 if (strncmp(argv[3]->text, "translate-c", 11) == 0)
1473 ospf_area_nssa_translator_role_set(
1474 ospf, area_id, OSPF_NSSA_ROLE_CANDIDATE);
1475 else if (strncmp(argv[3]->text, "translate-n", 11) == 0)
1476 ospf_area_nssa_translator_role_set(
1477 ospf, area_id, OSPF_NSSA_ROLE_NEVER);
1478 else if (strncmp(argv[3]->text, "translate-a", 11) == 0)
1479 ospf_area_nssa_translator_role_set(
1480 ospf, area_id, OSPF_NSSA_ROLE_ALWAYS);
1481 } else {
1482 ospf_area_nssa_translator_role_set(ospf, area_id,
1483 OSPF_NSSA_ROLE_CANDIDATE);
1484 }
1485
1486 if (cfg_nosum) {
1487 if (nosum)
1488 ospf_area_no_summary_set(ospf, area_id);
1489 else
1490 ospf_area_no_summary_unset(ospf, area_id);
1491 }
1492
1493 /* Flush the external LSA for the specified area */
1494 ospf_flush_lsa_from_area(ospf, area_id, OSPF_AS_EXTERNAL_LSA);
1495 ospf_schedule_abr_task(ospf);
1496 ospf_schedule_asbr_nssa_redist_update(ospf);
1497
1498 return CMD_SUCCESS;
1499 }
1500
1501
1502 DEFUN (ospf_area_nssa_translate,
1503 ospf_area_nssa_translate_cmd,
1504 "area <A.B.C.D|(0-4294967295)> nssa <translate-candidate|translate-never|translate-always>",
1505 "OSPF area parameters\n"
1506 "OSPF area ID in IP address format\n"
1507 "OSPF area ID as a decimal value\n"
1508 "Configure OSPF area as nssa\n"
1509 "Configure NSSA-ABR for translate election (default)\n"
1510 "Configure NSSA-ABR to never translate\n"
1511 "Configure NSSA-ABR to always translate\n")
1512 {
1513 return ospf_area_nssa_cmd_handler(vty, argc, argv, 0, 0);
1514 }
1515
1516 DEFUN (ospf_area_nssa,
1517 ospf_area_nssa_cmd,
1518 "area <A.B.C.D|(0-4294967295)> nssa",
1519 "OSPF area parameters\n"
1520 "OSPF area ID in IP address format\n"
1521 "OSPF area ID as a decimal value\n"
1522 "Configure OSPF area as nssa\n")
1523 {
1524 return ospf_area_nssa_cmd_handler(vty, argc, argv, 0, 0);
1525 }
1526
1527 DEFUN(ospf_area_nssa_suppress_fa, ospf_area_nssa_suppress_fa_cmd,
1528 "area <A.B.C.D|(0-4294967295)> nssa suppress-fa",
1529 "OSPF area parameters\n"
1530 "OSPF area ID in IP address format\n"
1531 "OSPF area ID as a decimal value\n"
1532 "Configure OSPF area as nssa\n"
1533 "Suppress forwarding address\n")
1534 {
1535 int idx_ipv4_number = 1;
1536 struct in_addr area_id;
1537 int format;
1538
1539 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1540 VTY_GET_OSPF_AREA_ID_NO_BB("NSSA", area_id, format,
1541 argv[idx_ipv4_number]->arg);
1542
1543 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1544 format);
1545 ospf_area_nssa_suppress_fa_set(ospf, area_id);
1546
1547 ospf_schedule_abr_task(ospf);
1548
1549 return CMD_SUCCESS;
1550 }
1551
1552 DEFUN(no_ospf_area_nssa_suppress_fa, no_ospf_area_nssa_suppress_fa_cmd,
1553 "no area <A.B.C.D|(0-4294967295)> nssa suppress-fa",
1554 NO_STR
1555 "OSPF area parameters\n"
1556 "OSPF area ID in IP address format\n"
1557 "OSPF area ID as a decimal value\n"
1558 "Configure OSPF area as nssa\n"
1559 "Suppress forwarding address\n")
1560 {
1561 int idx_ipv4_number = 2;
1562 struct in_addr area_id;
1563 int format;
1564
1565 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1566
1567 VTY_GET_OSPF_AREA_ID_NO_BB("nssa", area_id, format,
1568 argv[idx_ipv4_number]->arg);
1569
1570 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1571 format);
1572 ospf_area_nssa_suppress_fa_unset(ospf, area_id);
1573
1574 ospf_schedule_abr_task(ospf);
1575
1576 return CMD_SUCCESS;
1577 }
1578
1579 DEFUN (ospf_area_nssa_no_summary,
1580 ospf_area_nssa_no_summary_cmd,
1581 "area <A.B.C.D|(0-4294967295)> nssa no-summary",
1582 "OSPF area parameters\n"
1583 "OSPF area ID in IP address format\n"
1584 "OSPF area ID as a decimal value\n"
1585 "Configure OSPF area as nssa\n"
1586 "Do not inject inter-area routes into nssa\n")
1587 {
1588 int idx_ipv4_number = 1;
1589 struct in_addr area_id;
1590 int format;
1591
1592 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1593 VTY_GET_OSPF_AREA_ID_NO_BB("NSSA", area_id, format,
1594 argv[idx_ipv4_number]->arg);
1595
1596 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1597 format);
1598 ospf_area_nssa_no_summary_set(ospf, area_id);
1599
1600 ospf_schedule_abr_task(ospf);
1601
1602 return CMD_SUCCESS;
1603 }
1604
1605 DEFUN (no_ospf_area_nssa_no_summary,
1606 no_ospf_area_nssa_no_summary_cmd,
1607 "no area <A.B.C.D|(0-4294967295)> nssa no-summary",
1608 NO_STR
1609 "OSPF area parameters\n"
1610 "OSPF area ID in IP address format\n"
1611 "OSPF area ID as a decimal value\n"
1612 "Configure OSPF area as nssa\n"
1613 "Do not inject inter-area routes into nssa\n")
1614 {
1615 int idx_ipv4_number = 2;
1616 struct in_addr area_id;
1617 int format;
1618
1619 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1620
1621 VTY_GET_OSPF_AREA_ID_NO_BB("nssa", area_id, format,
1622 argv[idx_ipv4_number]->arg);
1623
1624 ospf_area_display_format_set(ospf, ospf_area_get(ospf, area_id),
1625 format);
1626 ospf_area_no_summary_unset(ospf, area_id);
1627
1628 ospf_schedule_abr_task(ospf);
1629
1630 return CMD_SUCCESS;
1631 }
1632
1633 DEFUN (no_ospf_area_nssa,
1634 no_ospf_area_nssa_cmd,
1635 "no area <A.B.C.D|(0-4294967295)> nssa [<translate-candidate|translate-never|translate-always>]",
1636 NO_STR
1637 "OSPF area parameters\n"
1638 "OSPF area ID in IP address format\n"
1639 "OSPF area ID as a decimal value\n"
1640 "Configure OSPF area as nssa\n"
1641 "Configure NSSA-ABR for translate election (default)\n"
1642 "Configure NSSA-ABR to never translate\n"
1643 "Configure NSSA-ABR to always translate\n")
1644 {
1645 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1646 int idx_ipv4_number = 2;
1647 struct in_addr area_id;
1648 int format;
1649
1650 VTY_GET_OSPF_AREA_ID_NO_BB("NSSA", area_id, format,
1651 argv[idx_ipv4_number]->arg);
1652
1653 /* Flush the NSSA LSA for the specified area */
1654 ospf_flush_lsa_from_area(ospf, area_id, OSPF_AS_NSSA_LSA);
1655 ospf_area_nssa_unset(ospf, area_id, argc);
1656
1657 ospf_schedule_abr_task(ospf);
1658
1659 return CMD_SUCCESS;
1660 }
1661
1662
1663 DEFUN (ospf_area_default_cost,
1664 ospf_area_default_cost_cmd,
1665 "area <A.B.C.D|(0-4294967295)> default-cost (0-16777215)",
1666 "OSPF area parameters\n"
1667 "OSPF area ID in IP address format\n"
1668 "OSPF area ID as a decimal value\n"
1669 "Set the summary-default cost of a NSSA or stub area\n"
1670 "Stub's advertised default summary cost\n")
1671 {
1672 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1673 int idx_ipv4_number = 1;
1674 int idx_number = 3;
1675 struct ospf_area *area;
1676 struct in_addr area_id;
1677 uint32_t cost;
1678 int format;
1679 struct prefix_ipv4 p;
1680
1681 VTY_GET_OSPF_AREA_ID_NO_BB("default-cost", area_id, format,
1682 argv[idx_ipv4_number]->arg);
1683 cost = strtoul(argv[idx_number]->arg, NULL, 10);
1684
1685 area = ospf_area_get(ospf, area_id);
1686 ospf_area_display_format_set(ospf, area, format);
1687
1688 if (area->external_routing == OSPF_AREA_DEFAULT) {
1689 vty_out(vty, "The area is neither stub, nor NSSA\n");
1690 return CMD_WARNING_CONFIG_FAILED;
1691 }
1692
1693 area->default_cost = cost;
1694
1695 p.family = AF_INET;
1696 p.prefix.s_addr = OSPF_DEFAULT_DESTINATION;
1697 p.prefixlen = 0;
1698 if (IS_DEBUG_OSPF_EVENT)
1699 zlog_debug(
1700 "ospf_abr_announce_stub_defaults(): announcing 0.0.0.0/0 to area %pI4",
1701 &area->area_id);
1702 ospf_abr_announce_network_to_area(&p, area->default_cost, area);
1703
1704 return CMD_SUCCESS;
1705 }
1706
1707 DEFUN (no_ospf_area_default_cost,
1708 no_ospf_area_default_cost_cmd,
1709 "no area <A.B.C.D|(0-4294967295)> default-cost (0-16777215)",
1710 NO_STR
1711 "OSPF area parameters\n"
1712 "OSPF area ID in IP address format\n"
1713 "OSPF area ID as a decimal value\n"
1714 "Set the summary-default cost of a NSSA or stub area\n"
1715 "Stub's advertised default summary cost\n")
1716 {
1717 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1718 int idx_ipv4_number = 2;
1719 struct ospf_area *area;
1720 struct in_addr area_id;
1721 int format;
1722 struct prefix_ipv4 p;
1723
1724 VTY_GET_OSPF_AREA_ID_NO_BB("default-cost", area_id, format,
1725 argv[idx_ipv4_number]->arg);
1726
1727 area = ospf_area_lookup_by_area_id(ospf, area_id);
1728 if (area == NULL)
1729 return CMD_SUCCESS;
1730
1731 if (area->external_routing == OSPF_AREA_DEFAULT) {
1732 vty_out(vty, "The area is neither stub, nor NSSA\n");
1733 return CMD_WARNING_CONFIG_FAILED;
1734 }
1735
1736 area->default_cost = 1;
1737
1738 p.family = AF_INET;
1739 p.prefix.s_addr = OSPF_DEFAULT_DESTINATION;
1740 p.prefixlen = 0;
1741 if (IS_DEBUG_OSPF_EVENT)
1742 zlog_debug(
1743 "ospf_abr_announce_stub_defaults(): announcing 0.0.0.0/0 to area %pI4",
1744 &area->area_id);
1745 ospf_abr_announce_network_to_area(&p, area->default_cost, area);
1746
1747
1748 ospf_area_check_free(ospf, area_id);
1749
1750 return CMD_SUCCESS;
1751 }
1752
1753 DEFUN (ospf_area_export_list,
1754 ospf_area_export_list_cmd,
1755 "area <A.B.C.D|(0-4294967295)> export-list ACCESSLIST4_NAME",
1756 "OSPF area parameters\n"
1757 "OSPF area ID in IP address format\n"
1758 "OSPF area ID as a decimal value\n"
1759 "Set the filter for networks announced to other areas\n"
1760 "Name of the access-list\n")
1761 {
1762 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1763 int idx_ipv4_number = 1;
1764 struct ospf_area *area;
1765 struct in_addr area_id;
1766 int format;
1767
1768 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1769
1770 area = ospf_area_get(ospf, area_id);
1771 ospf_area_display_format_set(ospf, area, format);
1772 ospf_area_export_list_set(ospf, area, argv[3]->arg);
1773
1774 return CMD_SUCCESS;
1775 }
1776
1777 DEFUN (no_ospf_area_export_list,
1778 no_ospf_area_export_list_cmd,
1779 "no area <A.B.C.D|(0-4294967295)> export-list ACCESSLIST4_NAME",
1780 NO_STR
1781 "OSPF area parameters\n"
1782 "OSPF area ID in IP address format\n"
1783 "OSPF area ID as a decimal value\n"
1784 "Unset the filter for networks announced to other areas\n"
1785 "Name of the access-list\n")
1786 {
1787 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1788 int idx_ipv4_number = 2;
1789 struct ospf_area *area;
1790 struct in_addr area_id;
1791 int format;
1792
1793 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1794
1795 area = ospf_area_lookup_by_area_id(ospf, area_id);
1796 if (area == NULL)
1797 return CMD_SUCCESS;
1798
1799 ospf_area_export_list_unset(ospf, area);
1800
1801 return CMD_SUCCESS;
1802 }
1803
1804
1805 DEFUN (ospf_area_import_list,
1806 ospf_area_import_list_cmd,
1807 "area <A.B.C.D|(0-4294967295)> import-list ACCESSLIST4_NAME",
1808 "OSPF area parameters\n"
1809 "OSPF area ID in IP address format\n"
1810 "OSPF area ID as a decimal value\n"
1811 "Set the filter for networks from other areas announced to the specified one\n"
1812 "Name of the access-list\n")
1813 {
1814 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1815 int idx_ipv4_number = 1;
1816 struct ospf_area *area;
1817 struct in_addr area_id;
1818 int format;
1819
1820 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1821
1822 area = ospf_area_get(ospf, area_id);
1823 ospf_area_display_format_set(ospf, area, format);
1824 ospf_area_import_list_set(ospf, area, argv[3]->arg);
1825
1826 return CMD_SUCCESS;
1827 }
1828
1829 DEFUN (no_ospf_area_import_list,
1830 no_ospf_area_import_list_cmd,
1831 "no area <A.B.C.D|(0-4294967295)> import-list ACCESSLIST4_NAME",
1832 NO_STR
1833 "OSPF area parameters\n"
1834 "OSPF area ID in IP address format\n"
1835 "OSPF area ID as a decimal value\n"
1836 "Unset the filter for networks announced to other areas\n"
1837 "Name of the access-list\n")
1838 {
1839 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1840 int idx_ipv4_number = 2;
1841 struct ospf_area *area;
1842 struct in_addr area_id;
1843 int format;
1844
1845 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1846
1847 area = ospf_area_lookup_by_area_id(ospf, area_id);
1848 if (area == NULL)
1849 return CMD_SUCCESS;
1850
1851 ospf_area_import_list_unset(ospf, area);
1852
1853 return CMD_SUCCESS;
1854 }
1855
1856 DEFUN (ospf_area_filter_list,
1857 ospf_area_filter_list_cmd,
1858 "area <A.B.C.D|(0-4294967295)> filter-list prefix PREFIXLIST_NAME <in|out>",
1859 "OSPF area parameters\n"
1860 "OSPF area ID in IP address format\n"
1861 "OSPF area ID as a decimal value\n"
1862 "Filter networks between OSPF areas\n"
1863 "Filter prefixes between OSPF areas\n"
1864 "Name of an IP prefix-list\n"
1865 "Filter networks sent to this area\n"
1866 "Filter networks sent from this area\n")
1867 {
1868 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1869 int idx_ipv4_number = 1;
1870 int idx_word = 4;
1871 int idx_in_out = 5;
1872 struct ospf_area *area;
1873 struct in_addr area_id;
1874 struct prefix_list *plist;
1875 int format;
1876
1877 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1878
1879 area = ospf_area_get(ospf, area_id);
1880 ospf_area_display_format_set(ospf, area, format);
1881 plist = prefix_list_lookup(AFI_IP, argv[idx_word]->arg);
1882 if (strncmp(argv[idx_in_out]->arg, "in", 2) == 0) {
1883 PREFIX_LIST_IN(area) = plist;
1884 if (PREFIX_NAME_IN(area))
1885 free(PREFIX_NAME_IN(area));
1886
1887 PREFIX_NAME_IN(area) = strdup(argv[idx_word]->arg);
1888 ospf_schedule_abr_task(ospf);
1889 } else {
1890 PREFIX_LIST_OUT(area) = plist;
1891 if (PREFIX_NAME_OUT(area))
1892 free(PREFIX_NAME_OUT(area));
1893
1894 PREFIX_NAME_OUT(area) = strdup(argv[idx_word]->arg);
1895 ospf_schedule_abr_task(ospf);
1896 }
1897
1898 return CMD_SUCCESS;
1899 }
1900
1901 DEFUN (no_ospf_area_filter_list,
1902 no_ospf_area_filter_list_cmd,
1903 "no area <A.B.C.D|(0-4294967295)> filter-list prefix PREFIXLIST_NAME <in|out>",
1904 NO_STR
1905 "OSPF area parameters\n"
1906 "OSPF area ID in IP address format\n"
1907 "OSPF area ID as a decimal value\n"
1908 "Filter networks between OSPF areas\n"
1909 "Filter prefixes between OSPF areas\n"
1910 "Name of an IP prefix-list\n"
1911 "Filter networks sent to this area\n"
1912 "Filter networks sent from this area\n")
1913 {
1914 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1915 int idx_ipv4_number = 2;
1916 int idx_word = 5;
1917 int idx_in_out = 6;
1918 struct ospf_area *area;
1919 struct in_addr area_id;
1920 int format;
1921
1922 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
1923
1924 if ((area = ospf_area_lookup_by_area_id(ospf, area_id)) == NULL)
1925 return CMD_SUCCESS;
1926
1927 if (strncmp(argv[idx_in_out]->arg, "in", 2) == 0) {
1928 if (PREFIX_NAME_IN(area))
1929 if (strcmp(PREFIX_NAME_IN(area), argv[idx_word]->arg)
1930 != 0)
1931 return CMD_SUCCESS;
1932
1933 PREFIX_LIST_IN(area) = NULL;
1934 if (PREFIX_NAME_IN(area))
1935 free(PREFIX_NAME_IN(area));
1936
1937 PREFIX_NAME_IN(area) = NULL;
1938
1939 ospf_schedule_abr_task(ospf);
1940 } else {
1941 if (PREFIX_NAME_OUT(area))
1942 if (strcmp(PREFIX_NAME_OUT(area), argv[idx_word]->arg)
1943 != 0)
1944 return CMD_SUCCESS;
1945
1946 PREFIX_LIST_OUT(area) = NULL;
1947 if (PREFIX_NAME_OUT(area))
1948 free(PREFIX_NAME_OUT(area));
1949
1950 PREFIX_NAME_OUT(area) = NULL;
1951
1952 ospf_schedule_abr_task(ospf);
1953 }
1954
1955 return CMD_SUCCESS;
1956 }
1957
1958
1959 DEFUN (ospf_area_authentication_message_digest,
1960 ospf_area_authentication_message_digest_cmd,
1961 "[no] area <A.B.C.D|(0-4294967295)> authentication message-digest",
1962 NO_STR
1963 "OSPF area parameters\n"
1964 "OSPF area ID in IP address format\n"
1965 "OSPF area ID as a decimal value\n"
1966 "Enable authentication\n"
1967 "Use message-digest authentication\n")
1968 {
1969 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1970 int idx = 0;
1971 struct ospf_area *area;
1972 struct in_addr area_id;
1973 int format;
1974
1975 argv_find(argv, argc, "area", &idx);
1976 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx + 1]->arg);
1977
1978 area = ospf_area_get(ospf, area_id);
1979 ospf_area_display_format_set(ospf, area, format);
1980 area->auth_type = strmatch(argv[0]->text, "no")
1981 ? OSPF_AUTH_NULL
1982 : OSPF_AUTH_CRYPTOGRAPHIC;
1983
1984 return CMD_SUCCESS;
1985 }
1986
1987 DEFUN (ospf_area_authentication,
1988 ospf_area_authentication_cmd,
1989 "area <A.B.C.D|(0-4294967295)> authentication",
1990 "OSPF area parameters\n"
1991 "OSPF area ID in IP address format\n"
1992 "OSPF area ID as a decimal value\n"
1993 "Enable authentication\n")
1994 {
1995 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
1996 int idx_ipv4_number = 1;
1997 struct ospf_area *area;
1998 struct in_addr area_id;
1999 int format;
2000
2001 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
2002
2003 area = ospf_area_get(ospf, area_id);
2004 ospf_area_display_format_set(ospf, area, format);
2005 area->auth_type = OSPF_AUTH_SIMPLE;
2006
2007 return CMD_SUCCESS;
2008 }
2009
2010 DEFUN (no_ospf_area_authentication,
2011 no_ospf_area_authentication_cmd,
2012 "no area <A.B.C.D|(0-4294967295)> authentication",
2013 NO_STR
2014 "OSPF area parameters\n"
2015 "OSPF area ID in IP address format\n"
2016 "OSPF area ID as a decimal value\n"
2017 "Enable authentication\n")
2018 {
2019 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2020 int idx_ipv4_number = 2;
2021 struct ospf_area *area;
2022 struct in_addr area_id;
2023 int format;
2024
2025 VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
2026
2027 area = ospf_area_lookup_by_area_id(ospf, area_id);
2028 if (area == NULL)
2029 return CMD_SUCCESS;
2030
2031 area->auth_type = OSPF_AUTH_NULL;
2032
2033 ospf_area_check_free(ospf, area_id);
2034
2035 return CMD_SUCCESS;
2036 }
2037
2038
2039 DEFUN (ospf_abr_type,
2040 ospf_abr_type_cmd,
2041 "ospf abr-type <cisco|ibm|shortcut|standard>",
2042 "OSPF specific commands\n"
2043 "Set OSPF ABR type\n"
2044 "Alternative ABR, cisco implementation\n"
2045 "Alternative ABR, IBM implementation\n"
2046 "Shortcut ABR\n"
2047 "Standard behavior (RFC2328)\n")
2048 {
2049 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2050 int idx_vendor = 2;
2051 uint8_t abr_type = OSPF_ABR_UNKNOWN;
2052
2053 if (strncmp(argv[idx_vendor]->arg, "c", 1) == 0)
2054 abr_type = OSPF_ABR_CISCO;
2055 else if (strncmp(argv[idx_vendor]->arg, "i", 1) == 0)
2056 abr_type = OSPF_ABR_IBM;
2057 else if (strncmp(argv[idx_vendor]->arg, "sh", 2) == 0)
2058 abr_type = OSPF_ABR_SHORTCUT;
2059 else if (strncmp(argv[idx_vendor]->arg, "st", 2) == 0)
2060 abr_type = OSPF_ABR_STAND;
2061 else
2062 return CMD_WARNING_CONFIG_FAILED;
2063
2064 /* If ABR type value is changed, schedule ABR task. */
2065 if (ospf->abr_type != abr_type) {
2066 ospf->abr_type = abr_type;
2067 ospf_schedule_abr_task(ospf);
2068 }
2069
2070 return CMD_SUCCESS;
2071 }
2072
2073 DEFUN (no_ospf_abr_type,
2074 no_ospf_abr_type_cmd,
2075 "no ospf abr-type <cisco|ibm|shortcut|standard>",
2076 NO_STR
2077 "OSPF specific commands\n"
2078 "Set OSPF ABR type\n"
2079 "Alternative ABR, cisco implementation\n"
2080 "Alternative ABR, IBM implementation\n"
2081 "Shortcut ABR\n"
2082 "Standard ABR\n")
2083 {
2084 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2085 int idx_vendor = 3;
2086 uint8_t abr_type = OSPF_ABR_UNKNOWN;
2087
2088 if (strncmp(argv[idx_vendor]->arg, "c", 1) == 0)
2089 abr_type = OSPF_ABR_CISCO;
2090 else if (strncmp(argv[idx_vendor]->arg, "i", 1) == 0)
2091 abr_type = OSPF_ABR_IBM;
2092 else if (strncmp(argv[idx_vendor]->arg, "sh", 2) == 0)
2093 abr_type = OSPF_ABR_SHORTCUT;
2094 else if (strncmp(argv[idx_vendor]->arg, "st", 2) == 0)
2095 abr_type = OSPF_ABR_STAND;
2096 else
2097 return CMD_WARNING_CONFIG_FAILED;
2098
2099 /* If ABR type value is changed, schedule ABR task. */
2100 if (ospf->abr_type == abr_type) {
2101 ospf->abr_type = OSPF_ABR_DEFAULT;
2102 ospf_schedule_abr_task(ospf);
2103 }
2104
2105 return CMD_SUCCESS;
2106 }
2107
2108 DEFUN (ospf_log_adjacency_changes,
2109 ospf_log_adjacency_changes_cmd,
2110 "log-adjacency-changes",
2111 "Log changes in adjacency state\n")
2112 {
2113 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2114
2115 SET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES);
2116 UNSET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL);
2117 return CMD_SUCCESS;
2118 }
2119
2120 DEFUN (ospf_log_adjacency_changes_detail,
2121 ospf_log_adjacency_changes_detail_cmd,
2122 "log-adjacency-changes detail",
2123 "Log changes in adjacency state\n"
2124 "Log all state changes\n")
2125 {
2126 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2127
2128 SET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES);
2129 SET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL);
2130 return CMD_SUCCESS;
2131 }
2132
2133 DEFUN (no_ospf_log_adjacency_changes,
2134 no_ospf_log_adjacency_changes_cmd,
2135 "no log-adjacency-changes",
2136 NO_STR
2137 "Log changes in adjacency state\n")
2138 {
2139 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2140
2141 UNSET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL);
2142 UNSET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES);
2143 return CMD_SUCCESS;
2144 }
2145
2146 DEFUN (no_ospf_log_adjacency_changes_detail,
2147 no_ospf_log_adjacency_changes_detail_cmd,
2148 "no log-adjacency-changes detail",
2149 NO_STR
2150 "Log changes in adjacency state\n"
2151 "Log all state changes\n")
2152 {
2153 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2154
2155 UNSET_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL);
2156 return CMD_SUCCESS;
2157 }
2158
2159 DEFUN (ospf_compatible_rfc1583,
2160 ospf_compatible_rfc1583_cmd,
2161 "compatible rfc1583",
2162 "OSPF compatibility list\n"
2163 "compatible with RFC 1583\n")
2164 {
2165 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2166
2167 if (!CHECK_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE)) {
2168 SET_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE);
2169 ospf_spf_calculate_schedule(ospf, SPF_FLAG_CONFIG_CHANGE);
2170 }
2171 return CMD_SUCCESS;
2172 }
2173
2174 DEFUN (no_ospf_compatible_rfc1583,
2175 no_ospf_compatible_rfc1583_cmd,
2176 "no compatible rfc1583",
2177 NO_STR
2178 "OSPF compatibility list\n"
2179 "compatible with RFC 1583\n")
2180 {
2181 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2182
2183 if (CHECK_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE)) {
2184 UNSET_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE);
2185 ospf_spf_calculate_schedule(ospf, SPF_FLAG_CONFIG_CHANGE);
2186 }
2187 return CMD_SUCCESS;
2188 }
2189
2190 ALIAS(ospf_compatible_rfc1583, ospf_rfc1583_flag_cmd,
2191 "ospf rfc1583compatibility",
2192 "OSPF specific commands\n"
2193 "Enable the RFC1583Compatibility flag\n")
2194
2195 ALIAS(no_ospf_compatible_rfc1583, no_ospf_rfc1583_flag_cmd,
2196 "no ospf rfc1583compatibility", NO_STR
2197 "OSPF specific commands\n"
2198 "Disable the RFC1583Compatibility flag\n")
2199
2200 static void ospf_table_reinstall_routes(struct ospf *ospf,
2201 struct route_table *rt)
2202 {
2203 struct route_node *rn;
2204
2205 if (!rt)
2206 return;
2207
2208 for (rn = route_top(rt); rn; rn = route_next(rn)) {
2209 struct ospf_route *or;
2210
2211 or = rn->info;
2212 if (!or)
2213 continue;
2214
2215 if (or->type == OSPF_DESTINATION_NETWORK)
2216 ospf_zebra_add(ospf, (struct prefix_ipv4 *)&rn->p, or);
2217 else if (or->type == OSPF_DESTINATION_DISCARD)
2218 ospf_zebra_add_discard(ospf,
2219 (struct prefix_ipv4 *)&rn->p);
2220 }
2221 }
2222
2223 static void ospf_reinstall_routes(struct ospf *ospf)
2224 {
2225 ospf_table_reinstall_routes(ospf, ospf->new_table);
2226 ospf_table_reinstall_routes(ospf, ospf->new_external_route);
2227 }
2228
2229 DEFPY (ospf_send_extra_data,
2230 ospf_send_extra_data_cmd,
2231 "[no] ospf send-extra-data zebra",
2232 NO_STR
2233 OSPF_STR
2234 "Extra data to Zebra for display/use\n"
2235 "To zebra\n")
2236 {
2237 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2238
2239 if (no && CHECK_FLAG(ospf->config, OSPF_SEND_EXTRA_DATA_TO_ZEBRA)) {
2240 UNSET_FLAG(ospf->config, OSPF_SEND_EXTRA_DATA_TO_ZEBRA);
2241 ospf_reinstall_routes(ospf);
2242 } else if (!CHECK_FLAG(ospf->config, OSPF_SEND_EXTRA_DATA_TO_ZEBRA)) {
2243 SET_FLAG(ospf->config, OSPF_SEND_EXTRA_DATA_TO_ZEBRA);
2244 ospf_reinstall_routes(ospf);
2245 }
2246
2247 return CMD_SUCCESS;
2248 }
2249
2250 static int ospf_timers_spf_set(struct vty *vty, unsigned int delay,
2251 unsigned int hold, unsigned int max)
2252 {
2253 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2254
2255 ospf->spf_delay = delay;
2256 ospf->spf_holdtime = hold;
2257 ospf->spf_max_holdtime = max;
2258
2259 return CMD_SUCCESS;
2260 }
2261
2262 DEFUN (ospf_timers_min_ls_interval,
2263 ospf_timers_min_ls_interval_cmd,
2264 "timers throttle lsa all (0-5000)",
2265 "Adjust routing timers\n"
2266 "Throttling adaptive timer\n"
2267 "LSA delay between transmissions\n"
2268 "All LSA types\n"
2269 "Delay (msec) between sending LSAs\n")
2270 {
2271 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2272 int idx_number = 4;
2273 unsigned int interval;
2274
2275 if (argc < 5) {
2276 vty_out(vty, "Insufficient arguments\n");
2277 return CMD_WARNING_CONFIG_FAILED;
2278 }
2279
2280 interval = strtoul(argv[idx_number]->arg, NULL, 10);
2281
2282 ospf->min_ls_interval = interval;
2283
2284 return CMD_SUCCESS;
2285 }
2286
2287 DEFUN (no_ospf_timers_min_ls_interval,
2288 no_ospf_timers_min_ls_interval_cmd,
2289 "no timers throttle lsa all [(0-5000)]",
2290 NO_STR
2291 "Adjust routing timers\n"
2292 "Throttling adaptive timer\n"
2293 "LSA delay between transmissions\n"
2294 "All LSA types\n"
2295 "Delay (msec) between sending LSAs\n")
2296 {
2297 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2298 ospf->min_ls_interval = OSPF_MIN_LS_INTERVAL;
2299
2300 return CMD_SUCCESS;
2301 }
2302
2303 DEFUN (ospf_timers_throttle_spf,
2304 ospf_timers_throttle_spf_cmd,
2305 "timers throttle spf (0-600000) (0-600000) (0-600000)",
2306 "Adjust routing timers\n"
2307 "Throttling adaptive timer\n"
2308 "OSPF SPF timers\n"
2309 "Delay (msec) from first change received till SPF calculation\n"
2310 "Initial hold time (msec) between consecutive SPF calculations\n"
2311 "Maximum hold time (msec)\n")
2312 {
2313 int idx_number = 3;
2314 int idx_number_2 = 4;
2315 int idx_number_3 = 5;
2316 unsigned int delay, hold, max;
2317
2318 if (argc < 6) {
2319 vty_out(vty, "Insufficient arguments\n");
2320 return CMD_WARNING_CONFIG_FAILED;
2321 }
2322
2323 delay = strtoul(argv[idx_number]->arg, NULL, 10);
2324 hold = strtoul(argv[idx_number_2]->arg, NULL, 10);
2325 max = strtoul(argv[idx_number_3]->arg, NULL, 10);
2326
2327 return ospf_timers_spf_set(vty, delay, hold, max);
2328 }
2329
2330 DEFUN (no_ospf_timers_throttle_spf,
2331 no_ospf_timers_throttle_spf_cmd,
2332 "no timers throttle spf [(0-600000)(0-600000)(0-600000)]",
2333 NO_STR
2334 "Adjust routing timers\n"
2335 "Throttling adaptive timer\n"
2336 "OSPF SPF timers\n"
2337 "Delay (msec) from first change received till SPF calculation\n"
2338 "Initial hold time (msec) between consecutive SPF calculations\n"
2339 "Maximum hold time (msec)\n")
2340 {
2341 return ospf_timers_spf_set(vty, OSPF_SPF_DELAY_DEFAULT,
2342 OSPF_SPF_HOLDTIME_DEFAULT,
2343 OSPF_SPF_MAX_HOLDTIME_DEFAULT);
2344 }
2345
2346
2347 DEFUN (ospf_timers_lsa_min_arrival,
2348 ospf_timers_lsa_min_arrival_cmd,
2349 "timers lsa min-arrival (0-600000)",
2350 "Adjust routing timers\n"
2351 "OSPF LSA timers\n"
2352 "Minimum delay in receiving new version of a LSA\n"
2353 "Delay in milliseconds\n")
2354 {
2355 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2356 ospf->min_ls_arrival = strtoul(argv[argc - 1]->arg, NULL, 10);
2357 return CMD_SUCCESS;
2358 }
2359
2360 DEFUN (no_ospf_timers_lsa_min_arrival,
2361 no_ospf_timers_lsa_min_arrival_cmd,
2362 "no timers lsa min-arrival [(0-600000)]",
2363 NO_STR
2364 "Adjust routing timers\n"
2365 "OSPF LSA timers\n"
2366 "Minimum delay in receiving new version of a LSA\n"
2367 "Delay in milliseconds\n")
2368 {
2369 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2370 unsigned int minarrival;
2371
2372 if (argc > 4) {
2373 minarrival = strtoul(argv[argc - 1]->arg, NULL, 10);
2374
2375 if (ospf->min_ls_arrival != minarrival
2376 || minarrival == OSPF_MIN_LS_ARRIVAL)
2377 return CMD_SUCCESS;
2378 }
2379
2380 ospf->min_ls_arrival = OSPF_MIN_LS_ARRIVAL;
2381
2382 return CMD_SUCCESS;
2383 }
2384
2385 DEFUN (ospf_neighbor,
2386 ospf_neighbor_cmd,
2387 "neighbor A.B.C.D [priority (0-255) [poll-interval (1-65535)]]",
2388 NEIGHBOR_STR
2389 "Neighbor IP address\n"
2390 "Neighbor Priority\n"
2391 "Priority\n"
2392 "Dead Neighbor Polling interval\n"
2393 "Seconds\n")
2394 {
2395 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2396 int idx_ipv4 = 1;
2397 int idx_pri = 3;
2398 int idx_poll = 5;
2399 struct in_addr nbr_addr;
2400 unsigned int priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
2401 unsigned int interval = OSPF_POLL_INTERVAL_DEFAULT;
2402
2403 if (!inet_aton(argv[idx_ipv4]->arg, &nbr_addr)) {
2404 vty_out(vty, "Please specify Neighbor ID by A.B.C.D\n");
2405 return CMD_WARNING_CONFIG_FAILED;
2406 }
2407
2408 if (argc > 2)
2409 priority = strtoul(argv[idx_pri]->arg, NULL, 10);
2410
2411 if (argc > 4)
2412 interval = strtoul(argv[idx_poll]->arg, NULL, 10);
2413
2414 ospf_nbr_nbma_set(ospf, nbr_addr);
2415
2416 if (argc > 2)
2417 ospf_nbr_nbma_priority_set(ospf, nbr_addr, priority);
2418
2419 if (argc > 4)
2420 ospf_nbr_nbma_poll_interval_set(ospf, nbr_addr, interval);
2421
2422 return CMD_SUCCESS;
2423 }
2424
2425 DEFUN (ospf_neighbor_poll_interval,
2426 ospf_neighbor_poll_interval_cmd,
2427 "neighbor A.B.C.D poll-interval (1-65535) [priority (0-255)]",
2428 NEIGHBOR_STR
2429 "Neighbor IP address\n"
2430 "Dead Neighbor Polling interval\n"
2431 "Seconds\n"
2432 "OSPF priority of non-broadcast neighbor\n"
2433 "Priority\n")
2434 {
2435 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2436 int idx_ipv4 = 1;
2437 int idx_poll = 3;
2438 int idx_pri = 5;
2439 struct in_addr nbr_addr;
2440 unsigned int priority;
2441 unsigned int interval;
2442
2443 if (!inet_aton(argv[idx_ipv4]->arg, &nbr_addr)) {
2444 vty_out(vty, "Please specify Neighbor ID by A.B.C.D\n");
2445 return CMD_WARNING_CONFIG_FAILED;
2446 }
2447
2448 interval = strtoul(argv[idx_poll]->arg, NULL, 10);
2449
2450 priority = argc > 4 ? strtoul(argv[idx_pri]->arg, NULL, 10)
2451 : OSPF_NEIGHBOR_PRIORITY_DEFAULT;
2452
2453 ospf_nbr_nbma_set(ospf, nbr_addr);
2454 ospf_nbr_nbma_poll_interval_set(ospf, nbr_addr, interval);
2455
2456 if (argc > 4)
2457 ospf_nbr_nbma_priority_set(ospf, nbr_addr, priority);
2458
2459 return CMD_SUCCESS;
2460 }
2461
2462 DEFUN (no_ospf_neighbor,
2463 no_ospf_neighbor_cmd,
2464 "no neighbor A.B.C.D [priority (0-255) [poll-interval (1-65525)]]",
2465 NO_STR
2466 NEIGHBOR_STR
2467 "Neighbor IP address\n"
2468 "Neighbor Priority\n"
2469 "Priority\n"
2470 "Dead Neighbor Polling interval\n"
2471 "Seconds\n")
2472 {
2473 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2474 int idx_ipv4 = 2;
2475 struct in_addr nbr_addr;
2476
2477 if (!inet_aton(argv[idx_ipv4]->arg, &nbr_addr)) {
2478 vty_out(vty, "Please specify Neighbor ID by A.B.C.D\n");
2479 return CMD_WARNING_CONFIG_FAILED;
2480 }
2481
2482 (void)ospf_nbr_nbma_unset(ospf, nbr_addr);
2483
2484 return CMD_SUCCESS;
2485 }
2486
2487 DEFUN (no_ospf_neighbor_poll,
2488 no_ospf_neighbor_poll_cmd,
2489 "no neighbor A.B.C.D poll-interval (1-65535) [priority (0-255)]",
2490 NO_STR
2491 NEIGHBOR_STR
2492 "Neighbor IP address\n"
2493 "Dead Neighbor Polling interval\n"
2494 "Seconds\n"
2495 "Neighbor Priority\n"
2496 "Priority\n")
2497 {
2498 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2499 int idx_ipv4 = 2;
2500 struct in_addr nbr_addr;
2501
2502 if (!inet_aton(argv[idx_ipv4]->arg, &nbr_addr)) {
2503 vty_out(vty, "Please specify Neighbor ID by A.B.C.D\n");
2504 return CMD_WARNING_CONFIG_FAILED;
2505 }
2506
2507 (void)ospf_nbr_nbma_unset(ospf, nbr_addr);
2508
2509 return CMD_SUCCESS;
2510 }
2511
2512 DEFUN (ospf_refresh_timer,
2513 ospf_refresh_timer_cmd,
2514 "refresh timer (10-1800)",
2515 "Adjust refresh parameters\n"
2516 "Set refresh timer\n"
2517 "Timer value in seconds\n")
2518 {
2519 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2520 int idx_number = 2;
2521 unsigned int interval;
2522
2523 interval = strtoul(argv[idx_number]->arg, NULL, 10);
2524 interval = (interval / OSPF_LSA_REFRESHER_GRANULARITY)
2525 * OSPF_LSA_REFRESHER_GRANULARITY;
2526
2527 ospf_timers_refresh_set(ospf, interval);
2528
2529 return CMD_SUCCESS;
2530 }
2531
2532 DEFUN (no_ospf_refresh_timer,
2533 no_ospf_refresh_timer_val_cmd,
2534 "no refresh timer [(10-1800)]",
2535 NO_STR
2536 "Adjust refresh parameters\n"
2537 "Unset refresh timer\n"
2538 "Timer value in seconds\n")
2539 {
2540 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2541 int idx_number = 3;
2542 unsigned int interval;
2543
2544 if (argc == 1) {
2545 interval = strtoul(argv[idx_number]->arg, NULL, 10);
2546
2547 if (ospf->lsa_refresh_interval != interval
2548 || interval == OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
2549 return CMD_SUCCESS;
2550 }
2551
2552 ospf_timers_refresh_unset(ospf);
2553
2554 return CMD_SUCCESS;
2555 }
2556
2557
2558 DEFUN (ospf_auto_cost_reference_bandwidth,
2559 ospf_auto_cost_reference_bandwidth_cmd,
2560 "auto-cost reference-bandwidth (1-4294967)",
2561 "Calculate OSPF interface cost according to bandwidth\n"
2562 "Use reference bandwidth method to assign OSPF cost\n"
2563 "The reference bandwidth in terms of Mbits per second\n")
2564 {
2565 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2566 struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
2567 int idx_number = 2;
2568 uint32_t refbw;
2569 struct interface *ifp;
2570
2571 refbw = strtol(argv[idx_number]->arg, NULL, 10);
2572 if (refbw < 1 || refbw > 4294967) {
2573 vty_out(vty, "reference-bandwidth value is invalid\n");
2574 return CMD_WARNING_CONFIG_FAILED;
2575 }
2576
2577 /* If reference bandwidth is changed. */
2578 if ((refbw) == ospf->ref_bandwidth)
2579 return CMD_SUCCESS;
2580
2581 ospf->ref_bandwidth = refbw;
2582 FOR_ALL_INTERFACES (vrf, ifp)
2583 ospf_if_recalculate_output_cost(ifp);
2584
2585 return CMD_SUCCESS;
2586 }
2587
2588 DEFUN (no_ospf_auto_cost_reference_bandwidth,
2589 no_ospf_auto_cost_reference_bandwidth_cmd,
2590 "no auto-cost reference-bandwidth [(1-4294967)]",
2591 NO_STR
2592 "Calculate OSPF interface cost according to bandwidth\n"
2593 "Use reference bandwidth method to assign OSPF cost\n"
2594 "The reference bandwidth in terms of Mbits per second\n")
2595 {
2596 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2597 struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
2598 struct interface *ifp;
2599
2600 if (ospf->ref_bandwidth == OSPF_DEFAULT_REF_BANDWIDTH)
2601 return CMD_SUCCESS;
2602
2603 ospf->ref_bandwidth = OSPF_DEFAULT_REF_BANDWIDTH;
2604 vty_out(vty, "%% OSPF: Reference bandwidth is changed.\n");
2605 vty_out(vty,
2606 " Please ensure reference bandwidth is consistent across all routers\n");
2607
2608 FOR_ALL_INTERFACES (vrf, ifp)
2609 ospf_if_recalculate_output_cost(ifp);
2610
2611 return CMD_SUCCESS;
2612 }
2613
2614 DEFUN (ospf_write_multiplier,
2615 ospf_write_multiplier_cmd,
2616 "ospf write-multiplier (1-100)",
2617 "OSPF specific commands\n"
2618 "Write multiplier\n"
2619 "Maximum number of interface serviced per write\n")
2620 {
2621 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2622 int idx_number;
2623 uint32_t write_oi_count;
2624
2625 if (argc == 3)
2626 idx_number = 2;
2627 else
2628 idx_number = 1;
2629
2630 write_oi_count = strtol(argv[idx_number]->arg, NULL, 10);
2631 if (write_oi_count < 1 || write_oi_count > 100) {
2632 vty_out(vty, "write-multiplier value is invalid\n");
2633 return CMD_WARNING_CONFIG_FAILED;
2634 }
2635
2636 ospf->write_oi_count = write_oi_count;
2637 return CMD_SUCCESS;
2638 }
2639
2640 ALIAS(ospf_write_multiplier, write_multiplier_cmd, "write-multiplier (1-100)",
2641 "Write multiplier\n"
2642 "Maximum number of interface serviced per write\n")
2643
2644 DEFUN (no_ospf_write_multiplier,
2645 no_ospf_write_multiplier_cmd,
2646 "no ospf write-multiplier (1-100)",
2647 NO_STR
2648 "OSPF specific commands\n"
2649 "Write multiplier\n"
2650 "Maximum number of interface serviced per write\n")
2651 {
2652 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2653
2654 ospf->write_oi_count = OSPF_WRITE_INTERFACE_COUNT_DEFAULT;
2655 return CMD_SUCCESS;
2656 }
2657
2658 ALIAS(no_ospf_write_multiplier, no_write_multiplier_cmd,
2659 "no write-multiplier (1-100)", NO_STR
2660 "Write multiplier\n"
2661 "Maximum number of interface serviced per write\n")
2662
2663 DEFUN(ospf_ti_lfa, ospf_ti_lfa_cmd, "fast-reroute ti-lfa [node-protection]",
2664 "Fast Reroute for MPLS and IP resilience\n"
2665 "Topology Independent LFA (Loop-Free Alternate)\n"
2666 "TI-LFA node protection (default is link protection)\n")
2667 {
2668 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2669
2670 ospf->ti_lfa_enabled = true;
2671
2672 if (argc == 3)
2673 ospf->ti_lfa_protection_type = OSPF_TI_LFA_NODE_PROTECTION;
2674 else
2675 ospf->ti_lfa_protection_type = OSPF_TI_LFA_LINK_PROTECTION;
2676
2677 ospf_spf_calculate_schedule(ospf, SPF_FLAG_CONFIG_CHANGE);
2678
2679 return CMD_SUCCESS;
2680 }
2681
2682 DEFUN(no_ospf_ti_lfa, no_ospf_ti_lfa_cmd,
2683 "no fast-reroute ti-lfa [node-protection]",
2684 NO_STR
2685 "Fast Reroute for MPLS and IP resilience\n"
2686 "Topology Independent LFA (Loop-Free Alternate)\n"
2687 "TI-LFA node protection (default is link protection)\n")
2688 {
2689 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2690
2691 ospf->ti_lfa_enabled = false;
2692
2693 ospf->ti_lfa_protection_type = OSPF_TI_LFA_UNDEFINED_PROTECTION;
2694
2695 ospf_spf_calculate_schedule(ospf, SPF_FLAG_CONFIG_CHANGE);
2696
2697 return CMD_SUCCESS;
2698 }
2699
2700 static void ospf_maxpath_set(struct vty *vty, struct ospf *ospf, uint16_t paths)
2701 {
2702 if (ospf->max_multipath == paths)
2703 return;
2704
2705 ospf->max_multipath = paths;
2706
2707 /* Send deletion notification to zebra to delete all
2708 * ospf specific routes and reinitiat SPF to reflect
2709 * the new max multipath.
2710 */
2711 ospf_restart_spf(ospf);
2712 }
2713
2714 /* Ospf Maximum multiple paths config support */
2715 DEFUN (ospf_max_multipath,
2716 ospf_max_multipath_cmd,
2717 "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
2718 "Max no of multiple paths for ECMP support\n"
2719 "Number of paths\n")
2720 {
2721 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2722 int idx_number = 1;
2723 uint16_t maxpaths;
2724
2725 maxpaths = strtol(argv[idx_number]->arg, NULL, 10);
2726
2727 ospf_maxpath_set(vty, ospf, maxpaths);
2728 return CMD_SUCCESS;
2729 }
2730
2731 DEFUN (no_ospf_max_multipath,
2732 no_ospf_max_multipath_cmd,
2733 "no maximum-paths",
2734 NO_STR
2735 "Max no of multiple paths for ECMP support\n")
2736 {
2737 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
2738 uint16_t maxpaths = MULTIPATH_NUM;
2739
2740 ospf_maxpath_set(vty, ospf, maxpaths);
2741 return CMD_SUCCESS;
2742 }
2743
2744 static const char *const ospf_abr_type_descr_str[] = {
2745 "Unknown", "Standard (RFC2328)", "Alternative IBM",
2746 "Alternative Cisco", "Alternative Shortcut"
2747 };
2748
2749 static const char *const ospf_shortcut_mode_descr_str[] = {
2750 "Default", "Enabled", "Disabled"
2751 };
2752
2753 static void show_ip_ospf_area(struct vty *vty, struct ospf_area *area,
2754 json_object *json_areas, bool use_json)
2755 {
2756 json_object *json_area = NULL;
2757 char buf[PREFIX_STRLEN];
2758
2759 if (use_json)
2760 json_area = json_object_new_object();
2761
2762 /* Show Area ID. */
2763 if (!use_json)
2764 vty_out(vty, " Area ID: %pI4", &area->area_id);
2765
2766 /* Show Area type/mode. */
2767 if (OSPF_IS_AREA_BACKBONE(area)) {
2768 if (use_json)
2769 json_object_boolean_true_add(json_area, "backbone");
2770 else
2771 vty_out(vty, " (Backbone)\n");
2772 } else {
2773 if (use_json) {
2774 if (area->external_routing == OSPF_AREA_STUB) {
2775 if (area->no_summary)
2776 json_object_boolean_true_add(
2777 json_area, "stubNoSummary");
2778 if (area->shortcut_configured)
2779 json_object_boolean_true_add(
2780 json_area, "stubShortcut");
2781 } else if (area->external_routing == OSPF_AREA_NSSA) {
2782 if (area->no_summary)
2783 json_object_boolean_true_add(
2784 json_area, "nssaNoSummary");
2785 if (area->shortcut_configured)
2786 json_object_boolean_true_add(
2787 json_area, "nssaShortcut");
2788 }
2789
2790 json_object_string_add(
2791 json_area, "shortcuttingMode",
2792 ospf_shortcut_mode_descr_str
2793 [area->shortcut_configured]);
2794 if (area->shortcut_capability)
2795 json_object_boolean_true_add(json_area,
2796 "sBitConcensus");
2797 } else {
2798 if (area->external_routing == OSPF_AREA_STUB)
2799 vty_out(vty, " (Stub%s%s)",
2800 area->no_summary ? ", no summary" : "",
2801 area->shortcut_configured ? "; " : "");
2802 else if (area->external_routing == OSPF_AREA_NSSA)
2803 vty_out(vty, " (NSSA%s%s)",
2804 area->no_summary ? ", no summary" : "",
2805 area->shortcut_configured ? "; " : "");
2806
2807 vty_out(vty, "\n");
2808 vty_out(vty, " Shortcutting mode: %s",
2809 ospf_shortcut_mode_descr_str
2810 [area->shortcut_configured]);
2811 vty_out(vty, ", S-bit consensus: %s\n",
2812 area->shortcut_capability ? "ok" : "no");
2813 }
2814 }
2815
2816 /* Show number of interfaces */
2817 if (use_json) {
2818 json_object_int_add(json_area, "areaIfTotalCounter",
2819 listcount(area->oiflist));
2820 json_object_int_add(json_area, "areaIfActiveCounter",
2821 area->act_ints);
2822 } else
2823 vty_out(vty,
2824 " Number of interfaces in this area: Total: %d, Active: %d\n",
2825 listcount(area->oiflist), area->act_ints);
2826
2827 if (area->external_routing == OSPF_AREA_NSSA) {
2828 if (use_json) {
2829 json_object_boolean_true_add(json_area, "nssa");
2830 if (!IS_OSPF_ABR(area->ospf))
2831 json_object_boolean_false_add(json_area, "abr");
2832 else if (area->NSSATranslatorState) {
2833 json_object_boolean_true_add(json_area, "abr");
2834 if (area->NSSATranslatorRole
2835 == OSPF_NSSA_ROLE_CANDIDATE)
2836 json_object_boolean_true_add(
2837 json_area,
2838 "nssaTranslatorElected");
2839 else if (area->NSSATranslatorRole
2840 == OSPF_NSSA_ROLE_ALWAYS)
2841 json_object_boolean_true_add(
2842 json_area,
2843 "nssaTranslatorAlways");
2844 else
2845 json_object_boolean_true_add(
2846 json_area,
2847 "nssaTranslatorNever");
2848 } else {
2849 json_object_boolean_true_add(json_area, "abr");
2850 if (area->NSSATranslatorRole
2851 == OSPF_NSSA_ROLE_CANDIDATE)
2852 json_object_boolean_false_add(
2853 json_area,
2854 "nssaTranslatorElected");
2855 else
2856 json_object_boolean_true_add(
2857 json_area,
2858 "nssaTranslatorNever");
2859 }
2860 } else {
2861 vty_out(vty,
2862 " It is an NSSA configuration.\n Elected NSSA/ABR performs type-7/type-5 LSA translation.\n");
2863 if (!IS_OSPF_ABR(area->ospf))
2864 vty_out(vty,
2865 " It is not ABR, therefore not Translator.\n");
2866 else if (area->NSSATranslatorState) {
2867 vty_out(vty, " We are an ABR and ");
2868 if (area->NSSATranslatorRole
2869 == OSPF_NSSA_ROLE_CANDIDATE)
2870 vty_out(vty,
2871 "the NSSA Elected Translator.\n");
2872 else if (area->NSSATranslatorRole
2873 == OSPF_NSSA_ROLE_ALWAYS)
2874 vty_out(vty,
2875 "always an NSSA Translator.\n");
2876 else
2877 vty_out(vty,
2878 "never an NSSA Translator.\n");
2879 } else {
2880 vty_out(vty, " We are an ABR, but ");
2881 if (area->NSSATranslatorRole
2882 == OSPF_NSSA_ROLE_CANDIDATE)
2883 vty_out(vty,
2884 "not the NSSA Elected Translator.\n");
2885 else
2886 vty_out(vty,
2887 "never an NSSA Translator.\n");
2888 }
2889 }
2890 }
2891
2892 /* Stub-router state for this area */
2893 if (CHECK_FLAG(area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED)) {
2894 char timebuf[OSPF_TIME_DUMP_SIZE];
2895
2896 if (use_json) {
2897 json_object_boolean_true_add(
2898 json_area, "originStubMaxDistRouterLsa");
2899 if (CHECK_FLAG(area->stub_router_state,
2900 OSPF_AREA_ADMIN_STUB_ROUTED))
2901 json_object_boolean_true_add(
2902 json_area, "indefiniteActiveAdmin");
2903 if (area->t_stub_router) {
2904 long time_store;
2905 time_store =
2906 monotime_until(
2907 &area->t_stub_router->u.sands,
2908 NULL)
2909 / 1000LL;
2910 json_object_int_add(
2911 json_area,
2912 "activeStartupRemainderMsecs",
2913 time_store);
2914 }
2915 } else {
2916 vty_out(vty,
2917 " Originating stub / maximum-distance Router-LSA\n");
2918 if (CHECK_FLAG(area->stub_router_state,
2919 OSPF_AREA_ADMIN_STUB_ROUTED))
2920 vty_out(vty,
2921 " Administratively activated (indefinitely)\n");
2922 if (area->t_stub_router)
2923 vty_out(vty,
2924 " Active from startup, %s remaining\n",
2925 ospf_timer_dump(area->t_stub_router,
2926 timebuf,
2927 sizeof(timebuf)));
2928 }
2929 }
2930
2931 if (use_json) {
2932 /* Show number of fully adjacent neighbors. */
2933 json_object_int_add(json_area, "nbrFullAdjacentCounter",
2934 area->full_nbrs);
2935
2936 /* Show authentication type. */
2937 if (area->auth_type == OSPF_AUTH_NULL)
2938 json_object_string_add(json_area, "authentication",
2939 "authenticationNone");
2940 else if (area->auth_type == OSPF_AUTH_SIMPLE)
2941 json_object_string_add(json_area, "authentication",
2942 "authenticationSimplePassword");
2943 else if (area->auth_type == OSPF_AUTH_CRYPTOGRAPHIC)
2944 json_object_string_add(json_area, "authentication",
2945 "authenticationMessageDigest");
2946
2947 if (!OSPF_IS_AREA_BACKBONE(area))
2948 json_object_int_add(json_area,
2949 "virtualAdjacenciesPassingCounter",
2950 area->full_vls);
2951
2952 /* Show SPF calculation times. */
2953 json_object_int_add(json_area, "spfExecutedCounter",
2954 area->spf_calculation);
2955 json_object_int_add(json_area, "lsaNumber", area->lsdb->total);
2956 json_object_int_add(
2957 json_area, "lsaRouterNumber",
2958 ospf_lsdb_count(area->lsdb, OSPF_ROUTER_LSA));
2959 json_object_int_add(
2960 json_area, "lsaRouterChecksum",
2961 ospf_lsdb_checksum(area->lsdb, OSPF_ROUTER_LSA));
2962 json_object_int_add(
2963 json_area, "lsaNetworkNumber",
2964 ospf_lsdb_count(area->lsdb, OSPF_NETWORK_LSA));
2965 json_object_int_add(
2966 json_area, "lsaNetworkChecksum",
2967 ospf_lsdb_checksum(area->lsdb, OSPF_NETWORK_LSA));
2968 json_object_int_add(
2969 json_area, "lsaSummaryNumber",
2970 ospf_lsdb_count(area->lsdb, OSPF_SUMMARY_LSA));
2971 json_object_int_add(
2972 json_area, "lsaSummaryChecksum",
2973 ospf_lsdb_checksum(area->lsdb, OSPF_SUMMARY_LSA));
2974 json_object_int_add(
2975 json_area, "lsaAsbrNumber",
2976 ospf_lsdb_count(area->lsdb, OSPF_ASBR_SUMMARY_LSA));
2977 json_object_int_add(
2978 json_area, "lsaAsbrChecksum",
2979 ospf_lsdb_checksum(area->lsdb, OSPF_ASBR_SUMMARY_LSA));
2980 json_object_int_add(
2981 json_area, "lsaNssaNumber",
2982 ospf_lsdb_count(area->lsdb, OSPF_AS_NSSA_LSA));
2983 json_object_int_add(
2984 json_area, "lsaNssaChecksum",
2985 ospf_lsdb_checksum(area->lsdb, OSPF_AS_NSSA_LSA));
2986 } else {
2987 /* Show number of fully adjacent neighbors. */
2988 vty_out(vty,
2989 " Number of fully adjacent neighbors in this area: %d\n",
2990 area->full_nbrs);
2991
2992 /* Show authentication type. */
2993 vty_out(vty, " Area has ");
2994 if (area->auth_type == OSPF_AUTH_NULL)
2995 vty_out(vty, "no authentication\n");
2996 else if (area->auth_type == OSPF_AUTH_SIMPLE)
2997 vty_out(vty, "simple password authentication\n");
2998 else if (area->auth_type == OSPF_AUTH_CRYPTOGRAPHIC)
2999 vty_out(vty, "message digest authentication\n");
3000
3001 if (!OSPF_IS_AREA_BACKBONE(area))
3002 vty_out(vty,
3003 " Number of full virtual adjacencies going through this area: %d\n",
3004 area->full_vls);
3005
3006 /* Show SPF calculation times. */
3007 vty_out(vty, " SPF algorithm executed %d times\n",
3008 area->spf_calculation);
3009
3010 /* Show number of LSA. */
3011 vty_out(vty, " Number of LSA %ld\n", area->lsdb->total);
3012 vty_out(vty,
3013 " Number of router LSA %ld. Checksum Sum 0x%08x\n",
3014 ospf_lsdb_count(area->lsdb, OSPF_ROUTER_LSA),
3015 ospf_lsdb_checksum(area->lsdb, OSPF_ROUTER_LSA));
3016 vty_out(vty,
3017 " Number of network LSA %ld. Checksum Sum 0x%08x\n",
3018 ospf_lsdb_count(area->lsdb, OSPF_NETWORK_LSA),
3019 ospf_lsdb_checksum(area->lsdb, OSPF_NETWORK_LSA));
3020 vty_out(vty,
3021 " Number of summary LSA %ld. Checksum Sum 0x%08x\n",
3022 ospf_lsdb_count(area->lsdb, OSPF_SUMMARY_LSA),
3023 ospf_lsdb_checksum(area->lsdb, OSPF_SUMMARY_LSA));
3024 vty_out(vty,
3025 " Number of ASBR summary LSA %ld. Checksum Sum 0x%08x\n",
3026 ospf_lsdb_count(area->lsdb, OSPF_ASBR_SUMMARY_LSA),
3027 ospf_lsdb_checksum(area->lsdb, OSPF_ASBR_SUMMARY_LSA));
3028 vty_out(vty, " Number of NSSA LSA %ld. Checksum Sum 0x%08x\n",
3029 ospf_lsdb_count(area->lsdb, OSPF_AS_NSSA_LSA),
3030 ospf_lsdb_checksum(area->lsdb, OSPF_AS_NSSA_LSA));
3031 }
3032
3033 if (use_json) {
3034 json_object_int_add(
3035 json_area, "lsaOpaqueLinkNumber",
3036 ospf_lsdb_count(area->lsdb, OSPF_OPAQUE_LINK_LSA));
3037 json_object_int_add(
3038 json_area, "lsaOpaqueLinkChecksum",
3039 ospf_lsdb_checksum(area->lsdb, OSPF_OPAQUE_LINK_LSA));
3040 json_object_int_add(
3041 json_area, "lsaOpaqueAreaNumber",
3042 ospf_lsdb_count(area->lsdb, OSPF_OPAQUE_AREA_LSA));
3043 json_object_int_add(
3044 json_area, "lsaOpaqueAreaChecksum",
3045 ospf_lsdb_checksum(area->lsdb, OSPF_OPAQUE_AREA_LSA));
3046 } else {
3047 vty_out(vty,
3048 " Number of opaque link LSA %ld. Checksum Sum 0x%08x\n",
3049 ospf_lsdb_count(area->lsdb, OSPF_OPAQUE_LINK_LSA),
3050 ospf_lsdb_checksum(area->lsdb, OSPF_OPAQUE_LINK_LSA));
3051 vty_out(vty,
3052 " Number of opaque area LSA %ld. Checksum Sum 0x%08x\n",
3053 ospf_lsdb_count(area->lsdb, OSPF_OPAQUE_AREA_LSA),
3054 ospf_lsdb_checksum(area->lsdb, OSPF_OPAQUE_AREA_LSA));
3055 }
3056
3057 if (use_json)
3058 json_object_object_add(json_areas,
3059 inet_ntop(AF_INET, &area->area_id,
3060 buf, sizeof(buf)),
3061 json_area);
3062 else
3063 vty_out(vty, "\n");
3064 }
3065
3066 static int show_ip_ospf_common(struct vty *vty, struct ospf *ospf,
3067 json_object *json, uint8_t use_vrf)
3068 {
3069 struct listnode *node, *nnode;
3070 struct ospf_area *area;
3071 struct timeval result;
3072 char timebuf[OSPF_TIME_DUMP_SIZE];
3073 json_object *json_vrf = NULL;
3074 json_object *json_areas = NULL;
3075
3076 if (json) {
3077 if (use_vrf)
3078 json_vrf = json_object_new_object();
3079 else
3080 json_vrf = json;
3081 json_areas = json_object_new_object();
3082 }
3083
3084 if (ospf->instance) {
3085 if (json) {
3086 json_object_int_add(json, "ospfInstance",
3087 ospf->instance);
3088 } else {
3089 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
3090 }
3091 }
3092
3093 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
3094
3095 /* Show Router ID. */
3096 if (json) {
3097 json_object_string_addf(json_vrf, "routerId", "%pI4",
3098 &ospf->router_id);
3099 } else {
3100 vty_out(vty, " OSPF Routing Process, Router ID: %pI4\n",
3101 &ospf->router_id);
3102 }
3103
3104 /* Graceful shutdown */
3105 if (ospf->t_deferred_shutdown) {
3106 if (json) {
3107 long time_store;
3108 time_store =
3109 monotime_until(
3110 &ospf->t_deferred_shutdown->u.sands,
3111 NULL)
3112 / 1000LL;
3113 json_object_int_add(json_vrf, "deferredShutdownMsecs",
3114 time_store);
3115 } else {
3116 vty_out(vty,
3117 " Deferred shutdown in progress, %s remaining\n",
3118 ospf_timer_dump(ospf->t_deferred_shutdown,
3119 timebuf, sizeof(timebuf)));
3120 }
3121 }
3122
3123 /* Show capability. */
3124 if (json) {
3125 json_object_boolean_true_add(json_vrf, "tosRoutesOnly");
3126 json_object_boolean_true_add(json_vrf, "rfc2328Conform");
3127 if (CHECK_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE)) {
3128 json_object_boolean_true_add(json_vrf,
3129 "rfc1583Compatibility");
3130 }
3131 } else {
3132 vty_out(vty, " Supports only single TOS (TOS0) routes\n");
3133 vty_out(vty, " This implementation conforms to RFC2328\n");
3134 vty_out(vty, " RFC1583Compatibility flag is %s\n",
3135 CHECK_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE)
3136 ? "enabled"
3137 : "disabled");
3138 }
3139
3140 if (json) {
3141 if (CHECK_FLAG(ospf->config, OSPF_OPAQUE_CAPABLE)) {
3142 json_object_boolean_true_add(json_vrf, "opaqueCapable");
3143 }
3144 } else {
3145 vty_out(vty, " OpaqueCapability flag is %s\n",
3146 CHECK_FLAG(ospf->config, OSPF_OPAQUE_CAPABLE)
3147 ? "enabled"
3148 : "disabled");
3149 }
3150
3151 /* Show stub-router configuration */
3152 if (ospf->stub_router_startup_time != OSPF_STUB_ROUTER_UNCONFIGURED
3153 || ospf->stub_router_shutdown_time
3154 != OSPF_STUB_ROUTER_UNCONFIGURED) {
3155 if (json) {
3156 json_object_boolean_true_add(json_vrf,
3157 "stubAdvertisement");
3158 if (ospf->stub_router_startup_time
3159 != OSPF_STUB_ROUTER_UNCONFIGURED)
3160 json_object_int_add(
3161 json_vrf, "postStartEnabledSecs",
3162 ospf->stub_router_startup_time);
3163 if (ospf->stub_router_shutdown_time
3164 != OSPF_STUB_ROUTER_UNCONFIGURED)
3165 json_object_int_add(
3166 json_vrf, "preShutdownEnabledSecs",
3167 ospf->stub_router_shutdown_time);
3168 } else {
3169 vty_out(vty,
3170 " Stub router advertisement is configured\n");
3171 if (ospf->stub_router_startup_time
3172 != OSPF_STUB_ROUTER_UNCONFIGURED)
3173 vty_out(vty,
3174 " Enabled for %us after start-up\n",
3175 ospf->stub_router_startup_time);
3176 if (ospf->stub_router_shutdown_time
3177 != OSPF_STUB_ROUTER_UNCONFIGURED)
3178 vty_out(vty,
3179 " Enabled for %us prior to full shutdown\n",
3180 ospf->stub_router_shutdown_time);
3181 }
3182 }
3183
3184 /* Show SPF timers. */
3185 if (json) {
3186 json_object_int_add(json_vrf, "spfScheduleDelayMsecs",
3187 ospf->spf_delay);
3188 json_object_int_add(json_vrf, "holdtimeMinMsecs",
3189 ospf->spf_holdtime);
3190 json_object_int_add(json_vrf, "holdtimeMaxMsecs",
3191 ospf->spf_max_holdtime);
3192 json_object_int_add(json_vrf, "holdtimeMultplier",
3193 ospf->spf_hold_multiplier);
3194 } else {
3195 vty_out(vty,
3196 " Initial SPF scheduling delay %d millisec(s)\n"
3197 " Minimum hold time between consecutive SPFs %d millisec(s)\n"
3198 " Maximum hold time between consecutive SPFs %d millisec(s)\n"
3199 " Hold time multiplier is currently %d\n",
3200 ospf->spf_delay, ospf->spf_holdtime,
3201 ospf->spf_max_holdtime, ospf->spf_hold_multiplier);
3202 }
3203
3204 if (json) {
3205 if (ospf->ts_spf.tv_sec || ospf->ts_spf.tv_usec) {
3206 long time_store = 0;
3207
3208 time_store =
3209 monotime_since(&ospf->ts_spf, NULL) / 1000LL;
3210 json_object_int_add(json_vrf, "spfLastExecutedMsecs",
3211 time_store);
3212
3213 time_store = (1000 * ospf->ts_spf_duration.tv_sec)
3214 + (ospf->ts_spf_duration.tv_usec / 1000);
3215 json_object_int_add(json_vrf, "spfLastDurationMsecs",
3216 time_store);
3217 } else
3218 json_object_boolean_true_add(json_vrf, "spfHasNotRun");
3219 } else {
3220 vty_out(vty, " SPF algorithm ");
3221 if (ospf->ts_spf.tv_sec || ospf->ts_spf.tv_usec) {
3222 monotime_since(&ospf->ts_spf, &result);
3223 vty_out(vty, "last executed %s ago\n",
3224 ospf_timeval_dump(&result, timebuf,
3225 sizeof(timebuf)));
3226 vty_out(vty, " Last SPF duration %s\n",
3227 ospf_timeval_dump(&ospf->ts_spf_duration,
3228 timebuf, sizeof(timebuf)));
3229 } else
3230 vty_out(vty, "has not been run\n");
3231 }
3232
3233 if (json) {
3234 if (ospf->t_spf_calc) {
3235 long time_store;
3236 time_store =
3237 monotime_until(&ospf->t_spf_calc->u.sands, NULL)
3238 / 1000LL;
3239 json_object_int_add(json_vrf, "spfTimerDueInMsecs",
3240 time_store);
3241 }
3242
3243 json_object_int_add(json_vrf, "lsaMinIntervalMsecs",
3244 ospf->min_ls_interval);
3245 json_object_int_add(json_vrf, "lsaMinArrivalMsecs",
3246 ospf->min_ls_arrival);
3247 /* Show write multiplier values */
3248 json_object_int_add(json_vrf, "writeMultiplier",
3249 ospf->write_oi_count);
3250 /* Show refresh parameters. */
3251 json_object_int_add(json_vrf, "refreshTimerMsecs",
3252 ospf->lsa_refresh_interval * 1000);
3253
3254 /* show max multipath */
3255 json_object_int_add(json_vrf, "maximumPaths",
3256 ospf->max_multipath);
3257
3258 /* show administrative distance */
3259 json_object_int_add(json_vrf, "preference",
3260 ospf->distance_all
3261 ? ospf->distance_all
3262 : ZEBRA_OSPF_DISTANCE_DEFAULT);
3263 } else {
3264 vty_out(vty, " SPF timer %s%s\n",
3265 (ospf->t_spf_calc ? "due in " : "is "),
3266 ospf_timer_dump(ospf->t_spf_calc, timebuf,
3267 sizeof(timebuf)));
3268
3269 vty_out(vty, " LSA minimum interval %d msecs\n",
3270 ospf->min_ls_interval);
3271 vty_out(vty, " LSA minimum arrival %d msecs\n",
3272 ospf->min_ls_arrival);
3273
3274 /* Show write multiplier values */
3275 vty_out(vty, " Write Multiplier set to %d \n",
3276 ospf->write_oi_count);
3277
3278 /* Show refresh parameters. */
3279 vty_out(vty, " Refresh timer %d secs\n",
3280 ospf->lsa_refresh_interval);
3281
3282 /* show max multipath */
3283 vty_out(vty, " Maximum multiple paths(ECMP) supported %d\n",
3284 ospf->max_multipath);
3285
3286 /* show administrative distance */
3287 vty_out(vty, " Administrative distance %u\n",
3288 ospf->distance_all ? ospf->distance_all
3289 : ZEBRA_OSPF_DISTANCE_DEFAULT);
3290 }
3291
3292 /* Show ABR/ASBR flags. */
3293 if (CHECK_FLAG(ospf->flags, OSPF_FLAG_ABR)) {
3294 if (json)
3295 json_object_string_add(
3296 json_vrf, "abrType",
3297 ospf_abr_type_descr_str[ospf->abr_type]);
3298 else
3299 vty_out(vty,
3300 " This router is an ABR, ABR type is: %s\n",
3301 ospf_abr_type_descr_str[ospf->abr_type]);
3302 }
3303 if (CHECK_FLAG(ospf->flags, OSPF_FLAG_ASBR)) {
3304 if (json)
3305 json_object_string_add(
3306 json_vrf, "asbrRouter",
3307 "injectingExternalRoutingInformation");
3308 else
3309 vty_out(vty,
3310 " This router is an ASBR (injecting external routing information)\n");
3311 }
3312
3313 /* Show Number of AS-external-LSAs. */
3314 if (json) {
3315 json_object_int_add(
3316 json_vrf, "lsaExternalCounter",
3317 ospf_lsdb_count(ospf->lsdb, OSPF_AS_EXTERNAL_LSA));
3318 json_object_int_add(
3319 json_vrf, "lsaExternalChecksum",
3320 ospf_lsdb_checksum(ospf->lsdb, OSPF_AS_EXTERNAL_LSA));
3321 } else {
3322 vty_out(vty,
3323 " Number of external LSA %ld. Checksum Sum 0x%08x\n",
3324 ospf_lsdb_count(ospf->lsdb, OSPF_AS_EXTERNAL_LSA),
3325 ospf_lsdb_checksum(ospf->lsdb, OSPF_AS_EXTERNAL_LSA));
3326 }
3327
3328 if (json) {
3329 json_object_int_add(
3330 json_vrf, "lsaAsopaqueCounter",
3331 ospf_lsdb_count(ospf->lsdb, OSPF_OPAQUE_AS_LSA));
3332 json_object_int_add(
3333 json_vrf, "lsaAsOpaqueChecksum",
3334 ospf_lsdb_checksum(ospf->lsdb, OSPF_OPAQUE_AS_LSA));
3335 } else {
3336 vty_out(vty,
3337 " Number of opaque AS LSA %ld. Checksum Sum 0x%08x\n",
3338 ospf_lsdb_count(ospf->lsdb, OSPF_OPAQUE_AS_LSA),
3339 ospf_lsdb_checksum(ospf->lsdb, OSPF_OPAQUE_AS_LSA));
3340 }
3341
3342 /* Show number of areas attached. */
3343 if (json)
3344 json_object_int_add(json_vrf, "attachedAreaCounter",
3345 listcount(ospf->areas));
3346 else
3347 vty_out(vty, " Number of areas attached to this router: %d\n",
3348 listcount(ospf->areas));
3349
3350 if (CHECK_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES)) {
3351 if (CHECK_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL)) {
3352 if (json)
3353 json_object_boolean_true_add(
3354 json_vrf, "adjacencyChangesLoggedAll");
3355 else
3356 vty_out(vty,
3357 " All adjacency changes are logged\n");
3358 } else {
3359 if (json)
3360 json_object_boolean_true_add(
3361 json_vrf, "adjacencyChangesLogged");
3362 else
3363 vty_out(vty, " Adjacency changes are logged\n");
3364 }
3365 }
3366
3367 /* show LDP-Sync status */
3368 ospf_ldp_sync_show_info(vty, ospf, json_vrf, json ? 1 : 0);
3369
3370 /* Show each area status. */
3371 for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area))
3372 show_ip_ospf_area(vty, area, json_areas, json ? 1 : 0);
3373
3374 if (json) {
3375 if (use_vrf) {
3376 json_object_object_add(json_vrf, "areas", json_areas);
3377 json_object_object_add(json, ospf_get_name(ospf),
3378 json_vrf);
3379 } else {
3380 json_object_object_add(json, "areas", json_areas);
3381 }
3382 } else
3383 vty_out(vty, "\n");
3384
3385 return CMD_SUCCESS;
3386 }
3387
3388 DEFUN (show_ip_ospf,
3389 show_ip_ospf_cmd,
3390 "show ip ospf [vrf <NAME|all>] [json]",
3391 SHOW_STR
3392 IP_STR
3393 "OSPF information\n"
3394 VRF_CMD_HELP_STR
3395 "All VRFs\n"
3396 JSON_STR)
3397 {
3398 struct ospf *ospf;
3399 bool uj = use_json(argc, argv);
3400 struct listnode *node = NULL;
3401 char *vrf_name = NULL;
3402 bool all_vrf = false;
3403 int ret = CMD_SUCCESS;
3404 int inst = 0;
3405 int idx_vrf = 0;
3406 json_object *json = NULL;
3407 uint8_t use_vrf = 0;
3408
3409 if (listcount(om->ospf) == 0)
3410 return CMD_SUCCESS;
3411
3412 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
3413
3414 if (uj)
3415 json = json_object_new_object();
3416
3417 /* vrf input is provided could be all or specific vrf*/
3418 if (vrf_name) {
3419 bool ospf_output = false;
3420
3421 use_vrf = 1;
3422
3423 if (all_vrf) {
3424 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
3425 if (!ospf->oi_running)
3426 continue;
3427 ospf_output = true;
3428 ret = show_ip_ospf_common(vty, ospf, json,
3429 use_vrf);
3430 }
3431 if (uj)
3432 vty_json(vty, json);
3433 else if (!ospf_output)
3434 vty_out(vty, "%% OSPF is not enabled\n");
3435 return ret;
3436 }
3437 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
3438 if ((ospf == NULL) || !ospf->oi_running) {
3439 if (uj)
3440 vty_json(vty, json);
3441 else
3442 vty_out(vty,
3443 "%% OSPF is not enabled in vrf %s\n",
3444 vrf_name);
3445
3446 return CMD_SUCCESS;
3447 }
3448 } else {
3449 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
3450 /* Display default ospf (instance 0) info */
3451 if (ospf == NULL || !ospf->oi_running) {
3452 if (uj)
3453 vty_json(vty, json);
3454 else
3455 vty_out(vty,
3456 "%% OSPF is not enabled in vrf default\n");
3457
3458 return CMD_SUCCESS;
3459 }
3460 }
3461
3462 if (ospf) {
3463 show_ip_ospf_common(vty, ospf, json, use_vrf);
3464 if (uj)
3465 vty_out(vty, "%s\n",
3466 json_object_to_json_string_ext(
3467 json, JSON_C_TO_STRING_PRETTY));
3468 }
3469
3470 if (uj)
3471 json_object_free(json);
3472
3473 return ret;
3474 }
3475
3476 DEFUN (show_ip_ospf_instance,
3477 show_ip_ospf_instance_cmd,
3478 "show ip ospf (1-65535) [json]",
3479 SHOW_STR
3480 IP_STR
3481 "OSPF information\n"
3482 "Instance ID\n"
3483 JSON_STR)
3484 {
3485 int idx_number = 3;
3486 struct ospf *ospf;
3487 unsigned short instance = 0;
3488 bool uj = use_json(argc, argv);
3489 int ret = CMD_SUCCESS;
3490 json_object *json = NULL;
3491
3492 instance = strtoul(argv[idx_number]->arg, NULL, 10);
3493 if (instance != ospf_instance)
3494 return CMD_NOT_MY_INSTANCE;
3495
3496 ospf = ospf_lookup_instance(instance);
3497 if (!ospf || !ospf->oi_running)
3498 return CMD_SUCCESS;
3499
3500 if (uj)
3501 json = json_object_new_object();
3502
3503 ret = show_ip_ospf_common(vty, ospf, json, 0);
3504
3505 if (uj)
3506 vty_json(vty, json);
3507
3508 return ret;
3509 }
3510
3511 static void ospf_interface_auth_show(struct vty *vty, struct ospf_interface *oi,
3512 json_object *json, bool use_json)
3513 {
3514 int auth_type;
3515
3516 auth_type = OSPF_IF_PARAM(oi, auth_type);
3517
3518 switch (auth_type) {
3519 case OSPF_AUTH_NULL:
3520 if (use_json)
3521 json_object_string_add(json, "authentication",
3522 "authenticationNone");
3523 else
3524 vty_out(vty, " Authentication NULL is enabled\n");
3525 break;
3526 case OSPF_AUTH_SIMPLE: {
3527 if (use_json)
3528 json_object_string_add(json, "authentication",
3529 "authenticationSimplePassword");
3530 else
3531 vty_out(vty,
3532 " Simple password authentication enabled\n");
3533 break;
3534 }
3535 case OSPF_AUTH_CRYPTOGRAPHIC: {
3536 struct crypt_key *ckey;
3537
3538 if (list_isempty(OSPF_IF_PARAM(oi, auth_crypt)))
3539 return;
3540
3541 ckey = listgetdata(listtail(OSPF_IF_PARAM(oi, auth_crypt)));
3542 if (ckey) {
3543 if (use_json) {
3544 json_object_string_add(json, "authentication",
3545 "authenticationMessageDigest");
3546 } else {
3547 vty_out(vty,
3548 " Cryptographic authentication enabled\n");
3549 vty_out(vty, " Algorithm:MD5\n");
3550 }
3551 }
3552 break;
3553 }
3554 default:
3555 break;
3556 }
3557 }
3558
3559 static void show_ip_ospf_interface_sub(struct vty *vty, struct ospf *ospf,
3560 struct interface *ifp,
3561 json_object *json_interface_sub,
3562 bool use_json)
3563 {
3564 int is_up;
3565 struct ospf_neighbor *nbr;
3566 struct route_node *rn;
3567 uint32_t bandwidth = ifp->bandwidth ? ifp->bandwidth : ifp->speed;
3568
3569 /* Is interface up? */
3570 if (use_json) {
3571 is_up = if_is_operative(ifp);
3572 if (is_up)
3573 json_object_boolean_true_add(json_interface_sub,
3574 "ifUp");
3575 else
3576 json_object_boolean_false_add(json_interface_sub,
3577 "ifDown");
3578
3579 json_object_int_add(json_interface_sub, "ifIndex",
3580 ifp->ifindex);
3581 json_object_int_add(json_interface_sub, "mtuBytes", ifp->mtu);
3582 json_object_int_add(json_interface_sub, "bandwidthMbit",
3583 bandwidth);
3584 json_object_string_add(json_interface_sub, "ifFlags",
3585 if_flag_dump(ifp->flags));
3586 } else {
3587 vty_out(vty, "%s is %s\n", ifp->name,
3588 ((is_up = if_is_operative(ifp)) ? "up" : "down"));
3589 vty_out(vty, " ifindex %u, MTU %u bytes, BW %u Mbit %s\n",
3590 ifp->ifindex, ifp->mtu, bandwidth,
3591 if_flag_dump(ifp->flags));
3592 }
3593
3594 /* Is interface OSPF enabled? */
3595 if (use_json) {
3596 if (ospf_oi_count(ifp) == 0) {
3597 json_object_boolean_false_add(json_interface_sub,
3598 "ospfEnabled");
3599 return;
3600 } else if (!is_up) {
3601 json_object_boolean_false_add(json_interface_sub,
3602 "ospfRunning");
3603 return;
3604 } else
3605 json_object_boolean_true_add(json_interface_sub,
3606 "ospfEnabled");
3607 } else {
3608 if (ospf_oi_count(ifp) == 0) {
3609 vty_out(vty, " OSPF not enabled on this interface\n");
3610 return;
3611 } else if (!is_up) {
3612 vty_out(vty,
3613 " OSPF is enabled, but not running on this interface\n");
3614 return;
3615 }
3616 }
3617
3618 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
3619 struct ospf_interface *oi = rn->info;
3620
3621 if (oi == NULL)
3622 continue;
3623
3624 if (CHECK_FLAG(oi->connected->flags, ZEBRA_IFA_UNNUMBERED)) {
3625 if (use_json)
3626 json_object_boolean_true_add(json_interface_sub,
3627 "ifUnnumbered");
3628 else
3629 vty_out(vty, " This interface is UNNUMBERED,");
3630 } else {
3631 struct in_addr dest;
3632 const char *dstr;
3633
3634 /* Show OSPF interface information. */
3635 if (use_json) {
3636 json_object_string_addf(
3637 json_interface_sub, "ipAddress", "%pI4",
3638 &oi->address->u.prefix4);
3639 json_object_int_add(json_interface_sub,
3640 "ipAddressPrefixlen",
3641 oi->address->prefixlen);
3642 } else
3643 vty_out(vty, " Internet Address %pFX,",
3644 oi->address);
3645
3646 /* For Vlinks, showing the peer address is
3647 * probably more informative than the local
3648 * interface that is being used */
3649 if (oi->type == OSPF_IFTYPE_VIRTUALLINK) {
3650 dstr = "Peer";
3651 dest = oi->vl_data->peer_addr;
3652 } else if (CONNECTED_PEER(oi->connected)
3653 && oi->connected->destination) {
3654 dstr = "Peer";
3655 dest = oi->connected->destination->u.prefix4;
3656 } else {
3657 dstr = "Broadcast";
3658 dest.s_addr = ipv4_broadcast_addr(
3659 oi->connected->address->u.prefix4.s_addr,
3660 oi->connected->address->prefixlen);
3661 }
3662
3663 if (use_json) {
3664 json_object_string_add(
3665 json_interface_sub,
3666 "ospfIfType", dstr);
3667 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
3668 json_object_string_addf(
3669 json_interface_sub, "vlinkPeer",
3670 "%pI4", &dest);
3671 else
3672 json_object_string_addf(
3673 json_interface_sub,
3674 "localIfUsed", "%pI4", &dest);
3675 } else
3676 vty_out(vty, " %s %pI4,", dstr,
3677 &dest);
3678 }
3679 if (use_json) {
3680 json_object_string_add(json_interface_sub, "area",
3681 ospf_area_desc_string(oi->area));
3682 if (OSPF_IF_PARAM(oi, mtu_ignore))
3683 json_object_boolean_true_add(
3684 json_interface_sub,
3685 "mtuMismatchDetect");
3686 json_object_string_addf(json_interface_sub, "routerId",
3687 "%pI4", &ospf->router_id);
3688 json_object_string_add(json_interface_sub,
3689 "networkType",
3690 ospf_network_type_str[oi->type]);
3691 json_object_int_add(json_interface_sub, "cost",
3692 oi->output_cost);
3693 json_object_int_add(
3694 json_interface_sub, "transmitDelaySecs",
3695 OSPF_IF_PARAM(oi, transmit_delay));
3696 json_object_string_add(json_interface_sub, "state",
3697 lookup_msg(ospf_ism_state_msg,
3698 oi->state, NULL));
3699 json_object_int_add(json_interface_sub, "priority",
3700 PRIORITY(oi));
3701 } else {
3702 vty_out(vty, " Area %s\n",
3703 ospf_area_desc_string(oi->area));
3704
3705 vty_out(vty, " MTU mismatch detection: %s\n",
3706 OSPF_IF_PARAM(oi, mtu_ignore) ? "disabled"
3707 : "enabled");
3708
3709 vty_out(vty,
3710 " Router ID %pI4, Network Type %s, Cost: %d\n",
3711 &ospf->router_id,
3712 ospf_network_type_str[oi->type],
3713 oi->output_cost);
3714
3715 vty_out(vty,
3716 " Transmit Delay is %d sec, State %s, Priority %d\n",
3717 OSPF_IF_PARAM(oi, transmit_delay),
3718 lookup_msg(ospf_ism_state_msg, oi->state, NULL),
3719 PRIORITY(oi));
3720 }
3721
3722 /* Show DR information. */
3723 if (DR(oi).s_addr == INADDR_ANY) {
3724 if (!use_json)
3725 vty_out(vty,
3726 " No backup designated router on this network\n");
3727 } else {
3728 nbr = ospf_nbr_lookup_by_addr(oi->nbrs, &DR(oi));
3729 if (nbr) {
3730 if (use_json) {
3731 json_object_string_addf(
3732 json_interface_sub, "drId",
3733 "%pI4", &nbr->router_id);
3734 json_object_string_addf(
3735 json_interface_sub, "drAddress",
3736 "%pI4",
3737 &nbr->address.u.prefix4);
3738 } else {
3739 vty_out(vty,
3740 " Designated Router (ID) %pI4",
3741 &nbr->router_id);
3742 vty_out(vty,
3743 " Interface Address %pFX\n",
3744 &nbr->address);
3745 }
3746 }
3747 nbr = NULL;
3748
3749 nbr = ospf_nbr_lookup_by_addr(oi->nbrs, &BDR(oi));
3750 if (nbr == NULL) {
3751 if (!use_json)
3752 vty_out(vty,
3753 " No backup designated router on this network\n");
3754 } else {
3755 if (use_json) {
3756 json_object_string_addf(
3757 json_interface_sub, "bdrId",
3758 "%pI4", &nbr->router_id);
3759 json_object_string_addf(
3760 json_interface_sub,
3761 "bdrAddress", "%pI4",
3762 &nbr->address.u.prefix4);
3763 } else {
3764 vty_out(vty,
3765 " Backup Designated Router (ID) %pI4,",
3766 &nbr->router_id);
3767 vty_out(vty, " Interface Address %pI4\n",
3768 &nbr->address.u.prefix4);
3769 }
3770 }
3771 }
3772
3773 /* Next network-LSA sequence number we'll use, if we're elected
3774 * DR */
3775 if (oi->params
3776 && ntohl(oi->params->network_lsa_seqnum)
3777 != OSPF_INITIAL_SEQUENCE_NUMBER) {
3778 if (use_json)
3779 json_object_int_add(
3780 json_interface_sub,
3781 "networkLsaSequence",
3782 ntohl(oi->params->network_lsa_seqnum));
3783 else
3784 vty_out(vty,
3785 " Saved Network-LSA sequence number 0x%x\n",
3786 ntohl(oi->params->network_lsa_seqnum));
3787 }
3788
3789 if (use_json) {
3790 if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS)
3791 || OI_MEMBER_CHECK(oi, MEMBER_DROUTERS)) {
3792 if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS))
3793 json_object_boolean_true_add(
3794 json_interface_sub,
3795 "mcastMemberOspfAllRouters");
3796 if (OI_MEMBER_CHECK(oi, MEMBER_DROUTERS))
3797 json_object_boolean_true_add(
3798 json_interface_sub,
3799 "mcastMemberOspfDesignatedRouters");
3800 }
3801 } else {
3802 vty_out(vty, " Multicast group memberships:");
3803 if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS)
3804 || OI_MEMBER_CHECK(oi, MEMBER_DROUTERS)) {
3805 if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS))
3806 vty_out(vty, " OSPFAllRouters");
3807 if (OI_MEMBER_CHECK(oi, MEMBER_DROUTERS))
3808 vty_out(vty, " OSPFDesignatedRouters");
3809 } else
3810 vty_out(vty, " <None>");
3811 vty_out(vty, "\n");
3812 }
3813
3814 if (use_json) {
3815 if (OSPF_IF_PARAM(oi, fast_hello) == 0)
3816 json_object_int_add(
3817 json_interface_sub, "timerMsecs",
3818 OSPF_IF_PARAM(oi, v_hello) * 1000);
3819 else
3820 json_object_int_add(
3821 json_interface_sub, "timerMsecs",
3822 1000 / OSPF_IF_PARAM(oi, fast_hello));
3823 json_object_int_add(json_interface_sub,
3824 "timerDeadSecs",
3825 OSPF_IF_PARAM(oi, v_wait));
3826 json_object_int_add(json_interface_sub,
3827 "timerWaitSecs",
3828 OSPF_IF_PARAM(oi, v_wait));
3829 json_object_int_add(
3830 json_interface_sub, "timerRetransmitSecs",
3831 OSPF_IF_PARAM(oi, retransmit_interval));
3832 } else {
3833 vty_out(vty, " Timer intervals configured,");
3834 vty_out(vty, " Hello ");
3835 if (OSPF_IF_PARAM(oi, fast_hello) == 0)
3836 vty_out(vty, "%ds,",
3837 OSPF_IF_PARAM(oi, v_hello));
3838 else
3839 vty_out(vty, "%dms,",
3840 1000 / OSPF_IF_PARAM(oi, fast_hello));
3841 vty_out(vty, " Dead %ds, Wait %ds, Retransmit %d\n",
3842 OSPF_IF_PARAM(oi, v_wait),
3843 OSPF_IF_PARAM(oi, v_wait),
3844 OSPF_IF_PARAM(oi, retransmit_interval));
3845 }
3846
3847 if (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_ACTIVE) {
3848 char timebuf[OSPF_TIME_DUMP_SIZE];
3849 if (use_json) {
3850 long time_store = 0;
3851 if (oi->t_hello)
3852 time_store =
3853 monotime_until(
3854 &oi->t_hello->u.sands,
3855 NULL)
3856 / 1000LL;
3857 json_object_int_add(json_interface_sub,
3858 "timerHelloInMsecs",
3859 time_store);
3860 } else
3861 vty_out(vty, " Hello due in %s\n",
3862 ospf_timer_dump(oi->t_hello, timebuf,
3863 sizeof(timebuf)));
3864 } else /* passive-interface is set */
3865 {
3866 if (use_json)
3867 json_object_boolean_true_add(
3868 json_interface_sub,
3869 "timerPassiveIface");
3870 else
3871 vty_out(vty,
3872 " No Hellos (Passive interface)\n");
3873 }
3874
3875 if (use_json) {
3876 json_object_int_add(json_interface_sub, "nbrCount",
3877 ospf_nbr_count(oi, 0));
3878 json_object_int_add(json_interface_sub,
3879 "nbrAdjacentCount",
3880 ospf_nbr_count(oi, NSM_Full));
3881 } else
3882 vty_out(vty,
3883 " Neighbor Count is %d, Adjacent neighbor count is %d\n",
3884 ospf_nbr_count(oi, 0),
3885 ospf_nbr_count(oi, NSM_Full));
3886
3887 ospf_interface_bfd_show(vty, ifp, json_interface_sub);
3888
3889 /* OSPF Authentication information */
3890 ospf_interface_auth_show(vty, oi, json_interface_sub, use_json);
3891 }
3892 }
3893
3894 static int show_ip_ospf_interface_common(struct vty *vty, struct ospf *ospf,
3895 char *intf_name, uint8_t use_vrf,
3896 json_object *json, bool use_json)
3897 {
3898 struct interface *ifp;
3899 struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
3900 json_object *json_vrf = NULL;
3901 json_object *json_interface_sub = NULL, *json_interface = NULL;
3902
3903 if (use_json) {
3904 if (use_vrf)
3905 json_vrf = json_object_new_object();
3906 else
3907 json_vrf = json;
3908 json_interface = json_object_new_object();
3909 }
3910
3911 if (ospf->instance) {
3912 if (use_json)
3913 json_object_int_add(json, "ospfInstance",
3914 ospf->instance);
3915 else
3916 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
3917 }
3918
3919 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
3920
3921 if (intf_name == NULL) {
3922 /* Show All Interfaces.*/
3923 FOR_ALL_INTERFACES (vrf, ifp) {
3924 if (ospf_oi_count(ifp)) {
3925 if (use_json) {
3926 json_interface_sub =
3927 json_object_new_object();
3928 }
3929 show_ip_ospf_interface_sub(vty, ospf, ifp,
3930 json_interface_sub,
3931 use_json);
3932
3933 if (use_json) {
3934 json_object_object_add(
3935 json_interface, ifp->name,
3936 json_interface_sub);
3937 }
3938 }
3939 }
3940 if (use_json)
3941 json_object_object_add(json_vrf, "interfaces",
3942 json_interface);
3943 } else {
3944 /* Interface name is specified. */
3945 ifp = if_lookup_by_name(intf_name, ospf->vrf_id);
3946 if (ifp == NULL) {
3947 if (use_json)
3948 json_object_boolean_true_add(json_vrf,
3949 "noSuchIface");
3950 else
3951 vty_out(vty, "No such interface name\n");
3952 } else {
3953 if (use_json) {
3954 json_interface_sub = json_object_new_object();
3955 json_interface = json_object_new_object();
3956 }
3957
3958 show_ip_ospf_interface_sub(
3959 vty, ospf, ifp, json_interface_sub, use_json);
3960
3961 if (use_json) {
3962 json_object_object_add(json_interface,
3963 ifp->name,
3964 json_interface_sub);
3965 json_object_object_add(json_vrf, "interfaces",
3966 json_interface);
3967 }
3968 }
3969 }
3970
3971 if (use_json) {
3972 if (use_vrf) {
3973 json_object_object_add(json, ospf_get_name(ospf),
3974 json_vrf);
3975 }
3976 } else
3977 vty_out(vty, "\n");
3978
3979 return CMD_SUCCESS;
3980 }
3981
3982 static void show_ip_ospf_interface_traffic_sub(struct vty *vty,
3983 struct ospf_interface *oi,
3984 json_object *json_interface_sub,
3985 bool use_json)
3986 {
3987 if (use_json) {
3988 json_object_int_add(json_interface_sub, "ifIndex",
3989 oi->ifp->ifindex);
3990 json_object_int_add(json_interface_sub, "helloIn",
3991 oi->hello_in);
3992 json_object_int_add(json_interface_sub, "helloOut",
3993 oi->hello_out);
3994 json_object_int_add(json_interface_sub, "dbDescIn",
3995 oi->db_desc_in);
3996 json_object_int_add(json_interface_sub, "dbDescOut",
3997 oi->db_desc_out);
3998 json_object_int_add(json_interface_sub, "lsReqIn",
3999 oi->ls_req_in);
4000 json_object_int_add(json_interface_sub, "lsReqOut",
4001 oi->ls_req_out);
4002 json_object_int_add(json_interface_sub, "lsUpdIn",
4003 oi->ls_upd_in);
4004 json_object_int_add(json_interface_sub, "lsUpdOut",
4005 oi->ls_upd_out);
4006 json_object_int_add(json_interface_sub, "lsAckIn",
4007 oi->ls_ack_in);
4008 json_object_int_add(json_interface_sub, "lsAckOut",
4009 oi->ls_ack_out);
4010 json_object_int_add(json_interface_sub, "packetsQueued",
4011 listcount(oi->obuf));
4012 } else {
4013 vty_out(vty,
4014 "%-10s %8u/%-8u %7u/%-7u %7u/%-7u %7u/%-7u %7u/%-7u %12lu\n",
4015 oi->ifp->name, oi->hello_in, oi->hello_out,
4016 oi->db_desc_in, oi->db_desc_out, oi->ls_req_in,
4017 oi->ls_req_out, oi->ls_upd_in, oi->ls_upd_out,
4018 oi->ls_ack_in, oi->ls_ack_out, listcount(oi->obuf));
4019 }
4020 }
4021
4022 /* OSPFv2 Packet Counters */
4023 static int show_ip_ospf_interface_traffic_common(
4024 struct vty *vty, struct ospf *ospf, char *intf_name, json_object *json,
4025 int display_once, uint8_t use_vrf, bool use_json)
4026 {
4027 struct vrf *vrf = NULL;
4028 struct interface *ifp = NULL;
4029 json_object *json_vrf = NULL;
4030 json_object *json_interface_sub = NULL;
4031
4032 if (!use_json && !display_once) {
4033 vty_out(vty, "\n");
4034 vty_out(vty, "%-12s%-17s%-17s%-17s%-17s%-17s%-17s\n",
4035 "Interface", " HELLO", " DB-Desc", " LS-Req",
4036 " LS-Update", " LS-Ack", " Packets");
4037 vty_out(vty, "%-10s%-18s%-18s%-17s%-17s%-17s%-17s\n", "",
4038 " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx",
4039 " Rx/Tx", " Queued");
4040 vty_out(vty,
4041 "-------------------------------------------------------------------------------------------------------------\n");
4042 } else if (use_json) {
4043 if (use_vrf)
4044 json_vrf = json_object_new_object();
4045 else
4046 json_vrf = json;
4047 }
4048
4049 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
4050
4051 if (intf_name == NULL) {
4052 vrf = vrf_lookup_by_id(ospf->vrf_id);
4053 FOR_ALL_INTERFACES (vrf, ifp) {
4054 struct route_node *rn;
4055 struct ospf_interface *oi;
4056
4057 if (ospf_oi_count(ifp) == 0)
4058 continue;
4059
4060 for (rn = route_top(IF_OIFS(ifp)); rn;
4061 rn = route_next(rn)) {
4062 oi = rn->info;
4063
4064 if (oi == NULL)
4065 continue;
4066
4067 if (use_json) {
4068 json_interface_sub =
4069 json_object_new_object();
4070 }
4071
4072 show_ip_ospf_interface_traffic_sub(
4073 vty, oi, json_interface_sub, use_json);
4074 if (use_json) {
4075 json_object_object_add(
4076 json_vrf, ifp->name,
4077 json_interface_sub);
4078 }
4079 }
4080 }
4081 } else {
4082 /* Interface name is specified. */
4083 ifp = if_lookup_by_name(intf_name, ospf->vrf_id);
4084 if (ifp != NULL) {
4085 struct route_node *rn;
4086 struct ospf_interface *oi;
4087
4088 if (ospf_oi_count(ifp) == 0) {
4089 vty_out(vty,
4090 " OSPF not enabled on this interface %s\n",
4091 ifp->name);
4092 return CMD_SUCCESS;
4093 }
4094
4095 for (rn = route_top(IF_OIFS(ifp)); rn;
4096 rn = route_next(rn)) {
4097 oi = rn->info;
4098
4099 if (use_json) {
4100 json_interface_sub =
4101 json_object_new_object();
4102 }
4103
4104 show_ip_ospf_interface_traffic_sub(
4105 vty, oi, json_interface_sub, use_json);
4106 if (use_json) {
4107 json_object_object_add(
4108 json_vrf, ifp->name,
4109 json_interface_sub);
4110 }
4111 }
4112 }
4113 }
4114
4115 if (use_json) {
4116 if (use_vrf)
4117 json_object_object_add(json, ospf_get_name(ospf),
4118 json_vrf);
4119 } else
4120 vty_out(vty, "\n");
4121
4122 return CMD_SUCCESS;
4123 }
4124
4125 DEFUN (show_ip_ospf_interface,
4126 show_ip_ospf_interface_cmd,
4127 "show ip ospf [vrf <NAME|all>] interface [INTERFACE] [json]",
4128 SHOW_STR
4129 IP_STR
4130 "OSPF information\n"
4131 VRF_CMD_HELP_STR
4132 "All VRFs\n"
4133 "Interface information\n"
4134 "Interface name\n"
4135 JSON_STR)
4136 {
4137 struct ospf *ospf;
4138 bool uj = use_json(argc, argv);
4139 struct listnode *node = NULL;
4140 char *vrf_name = NULL, *intf_name = NULL;
4141 bool all_vrf = false;
4142 int ret = CMD_SUCCESS;
4143 int inst = 0;
4144 int idx_vrf = 0, idx_intf = 0;
4145 uint8_t use_vrf = 0;
4146 json_object *json = NULL;
4147
4148 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
4149
4150 if (argv_find(argv, argc, "INTERFACE", &idx_intf))
4151 intf_name = argv[idx_intf]->arg;
4152
4153 if (uj)
4154 json = json_object_new_object();
4155
4156 /* vrf input is provided could be all or specific vrf*/
4157 if (vrf_name) {
4158 use_vrf = 1;
4159 if (all_vrf) {
4160 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
4161 if (!ospf->oi_running)
4162 continue;
4163 ret = show_ip_ospf_interface_common(
4164 vty, ospf, intf_name, use_vrf, json,
4165 uj);
4166 }
4167
4168 if (uj)
4169 vty_json(vty, json);
4170 else if (!ospf)
4171 vty_out(vty, "%% OSPF is not enabled\n");
4172
4173 return ret;
4174 }
4175 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
4176 if (ospf == NULL || !ospf->oi_running) {
4177 if (uj)
4178 vty_json(vty, json);
4179 else
4180 vty_out(vty,
4181 "%% OSPF is not enabled in vrf %s\n",
4182 vrf_name);
4183
4184 return CMD_SUCCESS;
4185 }
4186 ret = show_ip_ospf_interface_common(vty, ospf, intf_name,
4187 use_vrf, json, uj);
4188
4189 } else {
4190 /* Display default ospf (instance 0) info */
4191 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
4192 if (ospf == NULL || !ospf->oi_running) {
4193 if (uj)
4194 vty_json(vty, json);
4195 else
4196 vty_out(vty,
4197 "%% OSPF is not enabled in vrf default\n");
4198
4199 return CMD_SUCCESS;
4200 }
4201 ret = show_ip_ospf_interface_common(vty, ospf, intf_name,
4202 use_vrf, json, uj);
4203 }
4204
4205 if (uj)
4206 vty_json(vty, json);
4207
4208 return ret;
4209 }
4210
4211 DEFUN (show_ip_ospf_instance_interface,
4212 show_ip_ospf_instance_interface_cmd,
4213 "show ip ospf (1-65535) interface [INTERFACE] [json]",
4214 SHOW_STR
4215 IP_STR
4216 "OSPF information\n"
4217 "Instance ID\n"
4218 "Interface information\n"
4219 "Interface name\n"
4220 JSON_STR)
4221 {
4222 int idx_number = 3;
4223 int idx_intf = 0;
4224 struct ospf *ospf;
4225 unsigned short instance = 0;
4226 bool uj = use_json(argc, argv);
4227 char *intf_name = NULL;
4228 int ret = CMD_SUCCESS;
4229 json_object *json = NULL;
4230
4231 instance = strtoul(argv[idx_number]->arg, NULL, 10);
4232 if (instance != ospf_instance)
4233 return CMD_NOT_MY_INSTANCE;
4234
4235 ospf = ospf_lookup_instance(instance);
4236 if (!ospf || !ospf->oi_running)
4237 return CMD_SUCCESS;
4238
4239 if (uj)
4240 json = json_object_new_object();
4241
4242 if (argv_find(argv, argc, "INTERFACE", &idx_intf))
4243 intf_name = argv[idx_intf]->arg;
4244
4245 ret = show_ip_ospf_interface_common(vty, ospf, intf_name, 0, json, uj);
4246
4247 if (uj)
4248 vty_json(vty, json);
4249
4250 return ret;
4251 }
4252
4253 DEFUN (show_ip_ospf_interface_traffic,
4254 show_ip_ospf_interface_traffic_cmd,
4255 "show ip ospf [vrf <NAME|all>] interface traffic [INTERFACE] [json]",
4256 SHOW_STR
4257 IP_STR
4258 "OSPF information\n"
4259 VRF_CMD_HELP_STR
4260 "All VRFs\n"
4261 "Interface information\n"
4262 "Protocol Packet counters\n"
4263 "Interface name\n"
4264 JSON_STR)
4265 {
4266 struct ospf *ospf = NULL;
4267 struct listnode *node = NULL;
4268 char *vrf_name = NULL, *intf_name = NULL;
4269 bool all_vrf = false;
4270 int inst = 0;
4271 int idx_vrf = 0, idx_intf = 0;
4272 bool uj = use_json(argc, argv);
4273 json_object *json = NULL;
4274 int ret = CMD_SUCCESS;
4275 int display_once = 0;
4276 uint8_t use_vrf = 0;
4277
4278 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
4279
4280 if (argv_find(argv, argc, "INTERFACE", &idx_intf))
4281 intf_name = argv[idx_intf]->arg;
4282
4283 if (uj)
4284 json = json_object_new_object();
4285
4286 if (vrf_name) {
4287 use_vrf = 1;
4288 if (all_vrf) {
4289 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
4290 if (!ospf->oi_running)
4291 continue;
4292
4293 ret = show_ip_ospf_interface_traffic_common(
4294 vty, ospf, intf_name, json,
4295 display_once, use_vrf, uj);
4296 display_once = 1;
4297 }
4298
4299 if (uj)
4300 vty_json(vty, json);
4301
4302 return ret;
4303 }
4304 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
4305 if (ospf == NULL || !ospf->oi_running) {
4306 if (uj)
4307 json_object_free(json);
4308 return CMD_SUCCESS;
4309 }
4310
4311 ret = show_ip_ospf_interface_traffic_common(
4312 vty, ospf, intf_name, json, display_once, use_vrf, uj);
4313 } else {
4314 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
4315 if (ospf == NULL || !ospf->oi_running) {
4316 if (uj)
4317 json_object_free(json);
4318 return CMD_SUCCESS;
4319 }
4320
4321 ret = show_ip_ospf_interface_traffic_common(
4322 vty, ospf, intf_name, json, display_once, use_vrf, uj);
4323 }
4324
4325 if (uj)
4326 vty_json(vty, json);
4327
4328 return ret;
4329 }
4330
4331
4332 static void show_ip_ospf_neighbour_header(struct vty *vty)
4333 {
4334 vty_out(vty, "\n%-15s %-3s %-15s %-15s %-9s %-15s %-32s %5s %5s %5s\n",
4335 "Neighbor ID", "Pri", "State", "Up Time", "Dead Time",
4336 "Address", "Interface", "RXmtL", "RqstL", "DBsmL");
4337 }
4338
4339 static void show_ip_ospf_neighbour_brief(struct vty *vty,
4340 struct ospf_neighbor *nbr,
4341 struct ospf_neighbor *prev_nbr,
4342 json_object *json, bool use_json)
4343 {
4344 char msgbuf[16];
4345 char timebuf[OSPF_TIME_DUMP_SIZE];
4346 json_object *json_neighbor = NULL, *json_neigh_array = NULL;
4347 struct timeval res = {.tv_sec = 0, .tv_usec = 0};
4348 long time_val = 0;
4349 char uptime[OSPF_TIME_DUMP_SIZE];
4350
4351 if (nbr->ts_last_progress.tv_sec || nbr->ts_last_progress.tv_usec)
4352 time_val =
4353 monotime_since(&nbr->ts_last_progress, &res) / 1000LL;
4354
4355 if (use_json) {
4356 char neigh_str[INET_ADDRSTRLEN];
4357
4358 if (prev_nbr && !IPV4_ADDR_SAME(&prev_nbr->src, &nbr->src)) {
4359 /* Start new neigh list */
4360 json_neigh_array = NULL;
4361 }
4362
4363 if (nbr->state == NSM_Attempt &&
4364 nbr->router_id.s_addr == INADDR_ANY)
4365 strlcpy(neigh_str, "neighbor", sizeof(neigh_str));
4366 else
4367 inet_ntop(AF_INET, &nbr->router_id, neigh_str,
4368 sizeof(neigh_str));
4369
4370 json_object_object_get_ex(json, neigh_str, &json_neigh_array);
4371
4372 if (!json_neigh_array) {
4373 json_neigh_array = json_object_new_array();
4374 json_object_object_add(json, neigh_str,
4375 json_neigh_array);
4376 }
4377
4378 json_neighbor = json_object_new_object();
4379
4380 ospf_nbr_ism_state_message(nbr, msgbuf, sizeof(msgbuf));
4381 #if CONFDATE > 20230321
4382 CPP_NOTICE(
4383 "Remove show_ip_ospf_neighbor_sub() JSON keys: priority, state, deadTimeMsecs, address, retransmitCounter, requestCounter, dbSummaryCounter")
4384 #endif
4385 json_object_int_add(json_neighbor, "priority", nbr->priority);
4386 json_object_string_add(json_neighbor, "state", msgbuf);
4387 json_object_int_add(json_neighbor, "nbrPriority",
4388 nbr->priority);
4389 json_object_string_add(json_neighbor, "nbrState", msgbuf);
4390
4391 json_object_string_add(
4392 json_neighbor, "converged",
4393 lookup_msg(ospf_nsm_state_msg, nbr->state, NULL));
4394 json_object_string_add(json_neighbor, "role",
4395 lookup_msg(ospf_ism_state_msg,
4396 ospf_nbr_ism_state(nbr),
4397 NULL));
4398 if (nbr->t_inactivity) {
4399 long time_store;
4400
4401 time_store = monotime_until(&nbr->t_inactivity->u.sands,
4402 NULL) /
4403 1000LL;
4404 json_object_int_add(json_neighbor, "upTimeInMsec",
4405 time_val);
4406 json_object_int_add(json_neighbor, "deadTimeMsecs",
4407 time_store);
4408 json_object_int_add(json_neighbor,
4409 "routerDeadIntervalTimerDueMsec",
4410 time_store);
4411 json_object_string_add(
4412 json_neighbor, "upTime",
4413 ospf_timeval_dump(&res, uptime,
4414 sizeof(uptime)));
4415 json_object_string_add(
4416 json_neighbor, "deadTime",
4417 ospf_timer_dump(nbr->t_inactivity, timebuf,
4418 sizeof(timebuf)));
4419 } else {
4420 json_object_string_add(json_neighbor, "deadTimeMsecs",
4421 "inactive");
4422 json_object_string_add(json_neighbor,
4423 "routerDeadIntervalTimerDueMsec",
4424 "inactive");
4425 }
4426 json_object_string_addf(json_neighbor, "address", "%pI4",
4427 &nbr->src);
4428 json_object_string_addf(json_neighbor, "ifaceAddress", "%pI4",
4429 &nbr->src);
4430 json_object_string_add(json_neighbor, "ifaceName",
4431 IF_NAME(nbr->oi));
4432 json_object_int_add(json_neighbor, "retransmitCounter",
4433 ospf_ls_retransmit_count(nbr));
4434 json_object_int_add(json_neighbor,
4435 "linkStateRetransmissionListCounter",
4436 ospf_ls_retransmit_count(nbr));
4437 json_object_int_add(json_neighbor, "requestCounter",
4438 ospf_ls_request_count(nbr));
4439 json_object_int_add(json_neighbor,
4440 "linkStateRequestListCounter",
4441 ospf_ls_request_count(nbr));
4442 json_object_int_add(json_neighbor, "dbSummaryCounter",
4443 ospf_db_summary_count(nbr));
4444 json_object_int_add(json_neighbor, "databaseSummaryListCounter",
4445 ospf_db_summary_count(nbr));
4446
4447 json_object_array_add(json_neigh_array, json_neighbor);
4448 } else {
4449 ospf_nbr_ism_state_message(nbr, msgbuf, sizeof(msgbuf));
4450
4451 if (nbr->state == NSM_Attempt &&
4452 nbr->router_id.s_addr == INADDR_ANY)
4453 vty_out(vty, "%-15s %3d %-15s ", "-", nbr->priority,
4454 msgbuf);
4455 else
4456 vty_out(vty, "%-15pI4 %3d %-15s ", &nbr->router_id,
4457 nbr->priority, msgbuf);
4458
4459 vty_out(vty, "%-15s ",
4460 ospf_timeval_dump(&res, uptime, sizeof(uptime)));
4461
4462 vty_out(vty, "%9s ",
4463 ospf_timer_dump(nbr->t_inactivity, timebuf,
4464 sizeof(timebuf)));
4465 vty_out(vty, "%-15pI4 ", &nbr->src);
4466 vty_out(vty, "%-32s %5ld %5ld %5d\n", IF_NAME(nbr->oi),
4467 ospf_ls_retransmit_count(nbr),
4468 ospf_ls_request_count(nbr), ospf_db_summary_count(nbr));
4469 }
4470 }
4471
4472 static void show_ip_ospf_neighbor_sub(struct vty *vty,
4473 struct ospf_interface *oi,
4474 json_object *json, bool use_json)
4475 {
4476 struct route_node *rn;
4477 struct ospf_neighbor *nbr, *prev_nbr = NULL;
4478
4479 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn)) {
4480 nbr = rn->info;
4481
4482 if (!nbr)
4483 continue;
4484
4485 /* Do not show myself. */
4486 if (nbr == oi->nbr_self)
4487 continue;
4488 /* Down state is not shown. */
4489 if (nbr->state == NSM_Down)
4490 continue;
4491
4492 prev_nbr = nbr;
4493
4494 show_ip_ospf_neighbour_brief(vty, nbr, prev_nbr, json,
4495 use_json);
4496 }
4497 }
4498
4499 static int show_ip_ospf_neighbor_common(struct vty *vty, struct ospf *ospf,
4500 json_object *json, bool use_json,
4501 uint8_t use_vrf)
4502 {
4503 struct ospf_interface *oi;
4504 struct listnode *node;
4505 json_object *json_vrf = NULL;
4506 json_object *json_nbr_sub = NULL;
4507
4508 if (use_json) {
4509 if (use_vrf)
4510 json_vrf = json_object_new_object();
4511 else
4512 json_vrf = json;
4513 json_nbr_sub = json_object_new_object();
4514 }
4515
4516 if (ospf->instance) {
4517 if (use_json)
4518 json_object_int_add(json, "ospfInstance",
4519 ospf->instance);
4520 else
4521 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
4522 }
4523
4524 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
4525 if (!use_json)
4526 show_ip_ospf_neighbour_header(vty);
4527
4528 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
4529 if (ospf_interface_neighbor_count(oi) == 0)
4530 continue;
4531 show_ip_ospf_neighbor_sub(vty, oi, json_nbr_sub, use_json);
4532 }
4533
4534 if (use_json) {
4535 json_object_object_add(json_vrf, "neighbors", json_nbr_sub);
4536 if (use_vrf)
4537 json_object_object_add(json, ospf_get_name(ospf),
4538 json_vrf);
4539 } else
4540 vty_out(vty, "\n");
4541
4542 return CMD_SUCCESS;
4543 }
4544
4545 DEFUN (show_ip_ospf_neighbor,
4546 show_ip_ospf_neighbor_cmd,
4547 "show ip ospf [vrf <NAME|all>] neighbor [json]",
4548 SHOW_STR
4549 IP_STR
4550 "OSPF information\n"
4551 VRF_CMD_HELP_STR
4552 "All VRFs\n"
4553 "Neighbor list\n"
4554 JSON_STR)
4555 {
4556 struct ospf *ospf;
4557 bool uj = use_json(argc, argv);
4558 struct listnode *node = NULL;
4559 char *vrf_name = NULL;
4560 bool all_vrf = false;
4561 int ret = CMD_SUCCESS;
4562 int inst = 0;
4563 int idx_vrf = 0;
4564 uint8_t use_vrf = 0;
4565 json_object *json = NULL;
4566
4567 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
4568
4569 if (uj)
4570 json = json_object_new_object();
4571
4572 /* vrf input is provided could be all or specific vrf*/
4573 if (vrf_name) {
4574 use_vrf = 1;
4575 if (all_vrf) {
4576 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
4577 if (!ospf->oi_running)
4578 continue;
4579 ret = show_ip_ospf_neighbor_common(
4580 vty, ospf, json, uj, use_vrf);
4581 }
4582
4583 if (uj)
4584 vty_json(vty, json);
4585 else if (!ospf)
4586 vty_out(vty, "OSPF is not enabled\n");
4587
4588 return ret;
4589 }
4590
4591 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
4592 if (ospf == NULL || !ospf->oi_running) {
4593 if (uj)
4594 vty_json(vty, json);
4595 else
4596 vty_out(vty,
4597 "%% OSPF is not enabled in vrf %s\n",
4598 vrf_name);
4599
4600 return CMD_SUCCESS;
4601 }
4602 } else {
4603 /* Display default ospf (instance 0) info */
4604 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
4605 if (ospf == NULL || !ospf->oi_running) {
4606 if (uj)
4607 vty_json(vty, json);
4608 else
4609 vty_out(vty,
4610 "%% OSPF is not enabled in vrf default\n");
4611
4612 return CMD_SUCCESS;
4613 }
4614 }
4615
4616 if (ospf) {
4617 ret = show_ip_ospf_neighbor_common(vty, ospf, json, uj,
4618 use_vrf);
4619
4620 if (uj) {
4621 vty_out(vty, "%s\n",
4622 json_object_to_json_string_ext(
4623 json, JSON_C_TO_STRING_PRETTY));
4624 }
4625 }
4626
4627 if (uj)
4628 json_object_free(json);
4629
4630 return ret;
4631 }
4632
4633
4634 DEFUN (show_ip_ospf_instance_neighbor,
4635 show_ip_ospf_instance_neighbor_cmd,
4636 "show ip ospf (1-65535) neighbor [json]",
4637 SHOW_STR
4638 IP_STR
4639 "OSPF information\n"
4640 "Instance ID\n"
4641 "Neighbor list\n"
4642 JSON_STR)
4643 {
4644 int idx_number = 3;
4645 struct ospf *ospf;
4646 unsigned short instance = 0;
4647 bool uj = use_json(argc, argv);
4648 json_object *json = NULL;
4649 int ret = CMD_SUCCESS;
4650
4651 instance = strtoul(argv[idx_number]->arg, NULL, 10);
4652 if (instance != ospf_instance)
4653 return CMD_NOT_MY_INSTANCE;
4654
4655 ospf = ospf_lookup_instance(instance);
4656 if (!ospf || !ospf->oi_running)
4657 return CMD_SUCCESS;
4658
4659 if (uj)
4660 json = json_object_new_object();
4661
4662 ret = show_ip_ospf_neighbor_common(vty, ospf, json, uj, 0);
4663
4664 if (uj)
4665 vty_json(vty, json);
4666
4667 return ret;
4668 }
4669
4670 static int show_ip_ospf_neighbor_all_common(struct vty *vty, struct ospf *ospf,
4671 json_object *json, bool use_json,
4672 uint8_t use_vrf)
4673 {
4674 struct listnode *node;
4675 struct ospf_interface *oi;
4676 char buf[PREFIX_STRLEN];
4677 json_object *json_vrf = NULL;
4678 json_object *json_neighbor_sub = NULL;
4679
4680 if (use_json) {
4681 if (use_vrf)
4682 json_vrf = json_object_new_object();
4683 else
4684 json_vrf = json;
4685 }
4686
4687 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
4688 if (!use_json)
4689 show_ip_ospf_neighbour_header(vty);
4690
4691 if (ospf->instance) {
4692 if (use_json)
4693 json_object_int_add(json_vrf, "ospfInstance",
4694 ospf->instance);
4695 else
4696 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
4697 }
4698
4699 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
4700 struct listnode *nbr_node;
4701 struct ospf_nbr_nbma *nbr_nbma;
4702
4703 show_ip_ospf_neighbor_sub(vty, oi, json_vrf, use_json);
4704
4705 /* print Down neighbor status */
4706 for (ALL_LIST_ELEMENTS_RO(oi->nbr_nbma, nbr_node, nbr_nbma)) {
4707 if (nbr_nbma->nbr == NULL
4708 || nbr_nbma->nbr->state == NSM_Down) {
4709 if (use_json) {
4710 json_neighbor_sub =
4711 json_object_new_object();
4712 json_object_int_add(json_neighbor_sub,
4713 "nbrNbmaPriority",
4714 nbr_nbma->priority);
4715 json_object_boolean_true_add(
4716 json_neighbor_sub,
4717 "nbrNbmaDown");
4718 json_object_string_add(
4719 json_neighbor_sub,
4720 "nbrNbmaIfaceName",
4721 IF_NAME(oi));
4722 json_object_int_add(
4723 json_neighbor_sub,
4724 "nbrNbmaRetransmitCounter", 0);
4725 json_object_int_add(
4726 json_neighbor_sub,
4727 "nbrNbmaRequestCounter", 0);
4728 json_object_int_add(
4729 json_neighbor_sub,
4730 "nbrNbmaDbSummaryCounter", 0);
4731 json_object_object_add(
4732 json_vrf,
4733 inet_ntop(AF_INET,
4734 &nbr_nbma->addr, buf,
4735 sizeof(buf)),
4736 json_neighbor_sub);
4737 } else {
4738 vty_out(vty, "%-15s %3d %-15s %9s ",
4739 "-", nbr_nbma->priority, "Down",
4740 "-");
4741 vty_out(vty,
4742 "%-32pI4 %-20s %5d %5d %5d\n",
4743 &nbr_nbma->addr,
4744 IF_NAME(oi), 0, 0, 0);
4745 }
4746 }
4747 }
4748 }
4749
4750 if (use_json) {
4751 if (use_vrf)
4752 json_object_object_add(json, ospf_get_name(ospf),
4753 json_vrf);
4754 } else
4755 vty_out(vty, "\n");
4756
4757 return CMD_SUCCESS;
4758 }
4759
4760 DEFUN (show_ip_ospf_neighbor_all,
4761 show_ip_ospf_neighbor_all_cmd,
4762 "show ip ospf [vrf <NAME|all>] neighbor all [json]",
4763 SHOW_STR
4764 IP_STR
4765 "OSPF information\n"
4766 VRF_CMD_HELP_STR
4767 "All VRFs\n"
4768 "Neighbor list\n"
4769 "include down status neighbor\n"
4770 JSON_STR)
4771 {
4772 struct ospf *ospf;
4773 bool uj = use_json(argc, argv);
4774 struct listnode *node = NULL;
4775 char *vrf_name = NULL;
4776 bool all_vrf = false;
4777 int ret = CMD_SUCCESS;
4778 int inst = 0;
4779 int idx_vrf = 0;
4780 uint8_t use_vrf = 0;
4781 json_object *json = NULL;
4782
4783 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
4784
4785 if (uj)
4786 json = json_object_new_object();
4787
4788 /* vrf input is provided could be all or specific vrf*/
4789 if (vrf_name) {
4790 use_vrf = 1;
4791 if (all_vrf) {
4792 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
4793 if (!ospf->oi_running)
4794 continue;
4795 ret = show_ip_ospf_neighbor_all_common(
4796 vty, ospf, json, uj, use_vrf);
4797 }
4798
4799 if (uj)
4800 vty_json(vty, json);
4801
4802 return ret;
4803 }
4804
4805 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
4806 if (ospf == NULL || !ospf->oi_running) {
4807 if (uj)
4808 json_object_free(json);
4809 return CMD_SUCCESS;
4810 }
4811 } else {
4812 /* Display default ospf (instance 0) info */
4813 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
4814 if (ospf == NULL || !ospf->oi_running) {
4815 if (uj)
4816 json_object_free(json);
4817 return CMD_SUCCESS;
4818 }
4819 }
4820
4821 if (ospf) {
4822 ret = show_ip_ospf_neighbor_all_common(vty, ospf, json, uj,
4823 use_vrf);
4824 if (uj) {
4825 vty_out(vty, "%s\n",
4826 json_object_to_json_string_ext(
4827 json, JSON_C_TO_STRING_PRETTY));
4828 }
4829 }
4830
4831 if (uj)
4832 json_object_free(json);
4833
4834 return ret;
4835 }
4836
4837 DEFUN (show_ip_ospf_instance_neighbor_all,
4838 show_ip_ospf_instance_neighbor_all_cmd,
4839 "show ip ospf (1-65535) neighbor all [json]",
4840 SHOW_STR
4841 IP_STR
4842 "OSPF information\n"
4843 "Instance ID\n"
4844 "Neighbor list\n"
4845 "include down status neighbor\n"
4846 JSON_STR)
4847 {
4848 int idx_number = 3;
4849 struct ospf *ospf;
4850 unsigned short instance = 0;
4851 bool uj = use_json(argc, argv);
4852 json_object *json = NULL;
4853 int ret = CMD_SUCCESS;
4854
4855 instance = strtoul(argv[idx_number]->arg, NULL, 10);
4856 if (instance != ospf_instance)
4857 return CMD_NOT_MY_INSTANCE;
4858
4859 ospf = ospf_lookup_instance(instance);
4860 if (!ospf || !ospf->oi_running)
4861 return CMD_SUCCESS;
4862 if (uj)
4863 json = json_object_new_object();
4864
4865 ret = show_ip_ospf_neighbor_all_common(vty, ospf, json, uj, 0);
4866
4867 if (uj)
4868 vty_json(vty, json);
4869
4870 return ret;
4871 }
4872
4873 static int show_ip_ospf_neighbor_int_common(struct vty *vty, struct ospf *ospf,
4874 int arg_base,
4875 struct cmd_token **argv,
4876 bool use_json, uint8_t use_vrf)
4877 {
4878 struct interface *ifp;
4879 struct route_node *rn;
4880 json_object *json = NULL;
4881
4882 if (use_json)
4883 json = json_object_new_object();
4884
4885 if (ospf->instance) {
4886 if (use_json)
4887 json_object_int_add(json, "ospfInstance",
4888 ospf->instance);
4889 else
4890 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
4891 }
4892
4893 ospf_show_vrf_name(ospf, vty, json, use_vrf);
4894
4895 ifp = if_lookup_by_name(argv[arg_base]->arg, ospf->vrf_id);
4896 if (!ifp) {
4897 if (use_json)
4898 json_object_boolean_true_add(json, "noSuchIface");
4899 else
4900 vty_out(vty, "No such interface.\n");
4901 return CMD_WARNING;
4902 }
4903
4904 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
4905 struct ospf_interface *oi = rn->info;
4906
4907 if (oi == NULL)
4908 continue;
4909
4910 show_ip_ospf_neighbor_sub(vty, oi, json, use_json);
4911 }
4912
4913 if (use_json)
4914 vty_json(vty, json);
4915 else
4916 vty_out(vty, "\n");
4917
4918 return CMD_SUCCESS;
4919 }
4920
4921 DEFUN (show_ip_ospf_neighbor_int,
4922 show_ip_ospf_neighbor_int_cmd,
4923 "show ip ospf [vrf <NAME>] neighbor IFNAME [json]",
4924 SHOW_STR
4925 IP_STR
4926 "OSPF information\n"
4927 VRF_CMD_HELP_STR
4928 "Neighbor list\n"
4929 "Interface name\n"
4930 JSON_STR)
4931 {
4932 struct ospf *ospf;
4933 int idx_ifname = 0;
4934 int idx_vrf = 0;
4935 bool uj = use_json(argc, argv);
4936 int ret = CMD_SUCCESS;
4937 struct interface *ifp = NULL;
4938 char *vrf_name = NULL;
4939 vrf_id_t vrf_id = VRF_DEFAULT;
4940 struct vrf *vrf = NULL;
4941
4942 if (argv_find(argv, argc, "vrf", &idx_vrf))
4943 vrf_name = argv[idx_vrf + 1]->arg;
4944 if (vrf_name && strmatch(vrf_name, VRF_DEFAULT_NAME))
4945 vrf_name = NULL;
4946 if (vrf_name) {
4947 vrf = vrf_lookup_by_name(vrf_name);
4948 if (vrf)
4949 vrf_id = vrf->vrf_id;
4950 }
4951 ospf = ospf_lookup_by_vrf_id(vrf_id);
4952
4953 if (!ospf || !ospf->oi_running)
4954 return ret;
4955
4956 if (!uj)
4957 show_ip_ospf_neighbour_header(vty);
4958
4959 argv_find(argv, argc, "IFNAME", &idx_ifname);
4960
4961 ifp = if_lookup_by_name(argv[idx_ifname]->arg, vrf_id);
4962 if (!ifp)
4963 return ret;
4964
4965 ret = show_ip_ospf_neighbor_int_common(vty, ospf, idx_ifname,
4966 argv, uj, 0);
4967 return ret;
4968 }
4969
4970 DEFUN (show_ip_ospf_instance_neighbor_int,
4971 show_ip_ospf_instance_neighbor_int_cmd,
4972 "show ip ospf (1-65535) neighbor IFNAME [json]",
4973 SHOW_STR
4974 IP_STR
4975 "OSPF information\n"
4976 "Instance ID\n"
4977 "Neighbor list\n"
4978 "Interface name\n"
4979 JSON_STR)
4980 {
4981 int idx_number = 3;
4982 int idx_ifname = 5;
4983 struct ospf *ospf;
4984 unsigned short instance = 0;
4985 bool uj = use_json(argc, argv);
4986
4987 if (!uj)
4988 show_ip_ospf_neighbour_header(vty);
4989
4990 instance = strtoul(argv[idx_number]->arg, NULL, 10);
4991 if (instance != ospf_instance)
4992 return CMD_NOT_MY_INSTANCE;
4993
4994 ospf = ospf_lookup_instance(instance);
4995 if (!ospf || !ospf->oi_running)
4996 return CMD_SUCCESS;
4997
4998 if (!uj)
4999 show_ip_ospf_neighbour_header(vty);
5000
5001 return show_ip_ospf_neighbor_int_common(vty, ospf, idx_ifname, argv, uj,
5002 0);
5003 }
5004
5005 static void show_ip_ospf_nbr_nbma_detail_sub(struct vty *vty,
5006 struct ospf_interface *oi,
5007 struct ospf_nbr_nbma *nbr_nbma,
5008 bool use_json, json_object *json)
5009 {
5010 char timebuf[OSPF_TIME_DUMP_SIZE];
5011 json_object *json_sub = NULL;
5012
5013 if (use_json)
5014 json_sub = json_object_new_object();
5015 else /* Show neighbor ID. */
5016 vty_out(vty, " Neighbor %s,", "-");
5017
5018 /* Show interface address. */
5019 if (use_json)
5020 json_object_string_addf(json_sub, "ifaceAddress", "%pI4",
5021 &nbr_nbma->addr);
5022 else
5023 vty_out(vty, " interface address %pI4\n",
5024 &nbr_nbma->addr);
5025
5026 /* Show Area ID. */
5027 if (use_json) {
5028 json_object_string_add(json_sub, "areaId",
5029 ospf_area_desc_string(oi->area));
5030 json_object_string_add(json_sub, "iface", IF_NAME(oi));
5031 } else
5032 vty_out(vty, " In the area %s via interface %s\n",
5033 ospf_area_desc_string(oi->area), IF_NAME(oi));
5034
5035 /* Show neighbor priority and state. */
5036 if (use_json) {
5037 json_object_int_add(json_sub, "nbrPriority",
5038 nbr_nbma->priority);
5039 json_object_string_add(json_sub, "nbrState", "down");
5040 } else
5041 vty_out(vty, " Neighbor priority is %d, State is %s,",
5042 nbr_nbma->priority, "Down");
5043
5044 /* Show state changes. */
5045 if (use_json)
5046 json_object_int_add(json_sub, "stateChangeCounter",
5047 nbr_nbma->state_change);
5048 else
5049 vty_out(vty, " %d state changes\n", nbr_nbma->state_change);
5050
5051 /* Show PollInterval */
5052 if (use_json)
5053 json_object_int_add(json_sub, "pollInterval", nbr_nbma->v_poll);
5054 else
5055 vty_out(vty, " Poll interval %d\n", nbr_nbma->v_poll);
5056
5057 /* Show poll-interval timer. */
5058 if (nbr_nbma->t_poll) {
5059 if (use_json) {
5060 long time_store;
5061 time_store = monotime_until(&nbr_nbma->t_poll->u.sands,
5062 NULL) / 1000LL;
5063 json_object_int_add(json_sub,
5064 "pollIntervalTimerDueMsec",
5065 time_store);
5066 } else
5067 vty_out(vty, " Poll timer due in %s\n",
5068 ospf_timer_dump(nbr_nbma->t_poll, timebuf,
5069 sizeof(timebuf)));
5070 }
5071
5072 /* Show poll-interval timer thread. */
5073 if (use_json) {
5074 if (nbr_nbma->t_poll != NULL)
5075 json_object_string_add(json_sub,
5076 "pollIntervalTimerThread", "on");
5077 } else
5078 vty_out(vty, " Thread Poll Timer %s\n",
5079 nbr_nbma->t_poll != NULL ? "on" : "off");
5080
5081 if (use_json)
5082 json_object_object_add(json, "noNbrId", json_sub);
5083 }
5084
5085 static void show_ip_ospf_neighbor_detail_sub(struct vty *vty,
5086 struct ospf_interface *oi,
5087 struct ospf_neighbor *nbr,
5088 struct ospf_neighbor *prev_nbr,
5089 json_object *json, bool use_json)
5090 {
5091 char timebuf[OSPF_TIME_DUMP_SIZE];
5092 json_object *json_neigh = NULL, *json_neigh_array = NULL;
5093 char neigh_str[INET_ADDRSTRLEN] = {0};
5094 char neigh_state[16] = {0};
5095
5096 if (use_json) {
5097 if (prev_nbr &&
5098 !IPV4_ADDR_SAME(&prev_nbr->src, &nbr->src)) {
5099 json_neigh_array = NULL;
5100 }
5101
5102 if (nbr->state == NSM_Attempt
5103 && nbr->router_id.s_addr == INADDR_ANY)
5104 strlcpy(neigh_str, "noNbrId", sizeof(neigh_str));
5105 else
5106 inet_ntop(AF_INET, &nbr->router_id,
5107 neigh_str, sizeof(neigh_str));
5108
5109 json_object_object_get_ex(json, neigh_str, &json_neigh_array);
5110
5111 if (!json_neigh_array) {
5112 json_neigh_array = json_object_new_array();
5113 json_object_object_add(json, neigh_str,
5114 json_neigh_array);
5115 }
5116
5117 json_neigh = json_object_new_object();
5118
5119 } else {
5120 /* Show neighbor ID. */
5121 if (nbr->state == NSM_Attempt
5122 && nbr->router_id.s_addr == INADDR_ANY)
5123 vty_out(vty, " Neighbor %s,", "-");
5124 else
5125 vty_out(vty, " Neighbor %pI4,",
5126 &nbr->router_id);
5127 }
5128
5129 /* Show interface address. */
5130 if (use_json)
5131 json_object_string_addf(json_neigh, "ifaceAddress", "%pI4",
5132 &nbr->address.u.prefix4);
5133 else
5134 vty_out(vty, " interface address %pI4\n",
5135 &nbr->address.u.prefix4);
5136
5137 /* Show Area ID. */
5138 if (use_json) {
5139 json_object_string_add(json_neigh, "areaId",
5140 ospf_area_desc_string(oi->area));
5141 json_object_string_add(json_neigh, "ifaceName", oi->ifp->name);
5142 } else
5143 vty_out(vty, " In the area %s via interface %s\n",
5144 ospf_area_desc_string(oi->area), oi->ifp->name);
5145
5146 /* Show neighbor priority and state. */
5147 ospf_nbr_ism_state_message(nbr, neigh_state, sizeof(neigh_state));
5148 if (use_json) {
5149 json_object_int_add(json_neigh, "nbrPriority", nbr->priority);
5150 json_object_string_add(json_neigh, "nbrState", neigh_state);
5151 } else
5152 vty_out(vty, " Neighbor priority is %d, State is %s,",
5153 nbr->priority, neigh_state);
5154
5155 /* Show state changes. */
5156 if (use_json)
5157 json_object_int_add(json_neigh, "stateChangeCounter",
5158 nbr->state_change);
5159 else
5160 vty_out(vty, " %d state changes\n", nbr->state_change);
5161
5162 if (nbr->ts_last_progress.tv_sec || nbr->ts_last_progress.tv_usec) {
5163 struct timeval res;
5164 long time_store;
5165
5166 time_store =
5167 monotime_since(&nbr->ts_last_progress, &res) / 1000LL;
5168 if (use_json) {
5169 json_object_int_add(json_neigh, "lastPrgrsvChangeMsec",
5170 time_store);
5171 } else {
5172 vty_out(vty,
5173 " Most recent state change statistics:\n");
5174 vty_out(vty, " Progressive change %s ago\n",
5175 ospf_timeval_dump(&res, timebuf,
5176 sizeof(timebuf)));
5177 }
5178 }
5179
5180 if (nbr->ts_last_regress.tv_sec || nbr->ts_last_regress.tv_usec) {
5181 struct timeval res;
5182 long time_store;
5183
5184 time_store =
5185 monotime_since(&nbr->ts_last_regress, &res) / 1000LL;
5186 if (use_json) {
5187 json_object_int_add(json_neigh,
5188 "lastRegressiveChangeMsec",
5189 time_store);
5190 if (nbr->last_regress_str)
5191 json_object_string_add(
5192 json_neigh,
5193 "lastRegressiveChangeReason",
5194 nbr->last_regress_str);
5195 } else {
5196 vty_out(vty,
5197 " Regressive change %s ago, due to %s\n",
5198 ospf_timeval_dump(&res, timebuf,
5199 sizeof(timebuf)),
5200 (nbr->last_regress_str ? nbr->last_regress_str
5201 : "??"));
5202 }
5203 }
5204
5205 /* Show Designated Rotuer ID. */
5206 if (use_json)
5207 json_object_string_addf(json_neigh, "routerDesignatedId",
5208 "%pI4", &nbr->d_router);
5209 else
5210 vty_out(vty, " DR is %pI4,", &nbr->d_router);
5211
5212 /* Show Backup Designated Rotuer ID. */
5213 if (use_json)
5214 json_object_string_addf(json_neigh, "routerDesignatedBackupId",
5215 "%pI4", &nbr->bd_router);
5216 else
5217 vty_out(vty, " BDR is %pI4\n", &nbr->bd_router);
5218
5219 /* Show options. */
5220 if (use_json) {
5221 json_object_int_add(json_neigh, "optionsCounter", nbr->options);
5222 json_object_string_add(json_neigh, "optionsList",
5223 ospf_options_dump(nbr->options));
5224 } else
5225 vty_out(vty, " Options %d %s\n", nbr->options,
5226 ospf_options_dump(nbr->options));
5227
5228 /* Show Router Dead interval timer. */
5229 if (use_json) {
5230 if (nbr->t_inactivity) {
5231 long time_store;
5232 time_store = monotime_until(&nbr->t_inactivity->u.sands,
5233 NULL)
5234 / 1000LL;
5235 json_object_int_add(json_neigh,
5236 "routerDeadIntervalTimerDueMsec",
5237 time_store);
5238 } else
5239 json_object_int_add(
5240 json_neigh,
5241 "routerDeadIntervalTimerDueMsec", -1);
5242 } else
5243 vty_out(vty, " Dead timer due in %s\n",
5244 ospf_timer_dump(nbr->t_inactivity, timebuf,
5245 sizeof(timebuf)));
5246
5247 /* Show Database Summary list. */
5248 if (use_json)
5249 json_object_int_add(json_neigh, "databaseSummaryListCounter",
5250 ospf_db_summary_count(nbr));
5251 else
5252 vty_out(vty, " Database Summary List %d\n",
5253 ospf_db_summary_count(nbr));
5254
5255 /* Show Link State Request list. */
5256 if (use_json)
5257 json_object_int_add(json_neigh, "linkStateRequestListCounter",
5258 ospf_ls_request_count(nbr));
5259 else
5260 vty_out(vty, " Link State Request List %ld\n",
5261 ospf_ls_request_count(nbr));
5262
5263 /* Show Link State Retransmission list. */
5264 if (use_json)
5265 json_object_int_add(json_neigh,
5266 "linkStateRetransmissionListCounter",
5267 ospf_ls_retransmit_count(nbr));
5268 else
5269 vty_out(vty, " Link State Retransmission List %ld\n",
5270 ospf_ls_retransmit_count(nbr));
5271
5272 /* Show inactivity timer thread. */
5273 if (use_json) {
5274 if (nbr->t_inactivity != NULL)
5275 json_object_string_add(json_neigh,
5276 "threadInactivityTimer", "on");
5277 } else
5278 vty_out(vty, " Thread Inactivity Timer %s\n",
5279 nbr->t_inactivity != NULL ? "on" : "off");
5280
5281 /* Show Database Description retransmission thread. */
5282 if (use_json) {
5283 if (nbr->t_db_desc != NULL)
5284 json_object_string_add(
5285 json_neigh,
5286 "threadDatabaseDescriptionRetransmission",
5287 "on");
5288 } else
5289 vty_out(vty,
5290 " Thread Database Description Retransmision %s\n",
5291 nbr->t_db_desc != NULL ? "on" : "off");
5292
5293 /* Show Link State Request Retransmission thread. */
5294 if (use_json) {
5295 if (nbr->t_ls_req != NULL)
5296 json_object_string_add(
5297 json_neigh,
5298 "threadLinkStateRequestRetransmission", "on");
5299 } else
5300 vty_out(vty,
5301 " Thread Link State Request Retransmission %s\n",
5302 nbr->t_ls_req != NULL ? "on" : "off");
5303
5304 /* Show Link State Update Retransmission thread. */
5305 if (use_json) {
5306 if (nbr->t_ls_upd != NULL)
5307 json_object_string_add(
5308 json_neigh,
5309 "threadLinkStateUpdateRetransmission",
5310 "on");
5311 } else
5312 vty_out(vty,
5313 " Thread Link State Update Retransmission %s\n\n",
5314 nbr->t_ls_upd != NULL ? "on" : "off");
5315
5316 if (!use_json) {
5317 vty_out(vty, " Graceful restart Helper info:\n");
5318
5319 if (OSPF_GR_IS_ACTIVE_HELPER(nbr)) {
5320 vty_out(vty,
5321 " Graceful Restart HELPER Status : Inprogress.\n");
5322
5323 vty_out(vty,
5324 " Graceful Restart grace period time: %d (seconds).\n",
5325 nbr->gr_helper_info.recvd_grace_period);
5326 vty_out(vty, " Graceful Restart reason: %s.\n",
5327 ospf_restart_reason2str(
5328 nbr->gr_helper_info.gr_restart_reason));
5329 } else {
5330 vty_out(vty,
5331 " Graceful Restart HELPER Status : None\n");
5332 }
5333
5334 if (nbr->gr_helper_info.rejected_reason
5335 != OSPF_HELPER_REJECTED_NONE)
5336 vty_out(vty, " Helper rejected reason: %s.\n",
5337 ospf_rejected_reason2str(
5338 nbr->gr_helper_info.rejected_reason));
5339
5340 if (nbr->gr_helper_info.helper_exit_reason
5341 != OSPF_GR_HELPER_EXIT_NONE)
5342 vty_out(vty, " Last helper exit reason: %s.\n\n",
5343 ospf_exit_reason2str(
5344 nbr->gr_helper_info.helper_exit_reason));
5345 else
5346 vty_out(vty, "\n");
5347 } else {
5348 json_object_string_add(json_neigh, "grHelperStatus",
5349 OSPF_GR_IS_ACTIVE_HELPER(nbr) ?
5350 "Inprogress"
5351 : "None");
5352 if (OSPF_GR_IS_ACTIVE_HELPER(nbr)) {
5353 json_object_int_add(
5354 json_neigh, "graceInterval",
5355 nbr->gr_helper_info.recvd_grace_period);
5356 json_object_string_add(
5357 json_neigh, "grRestartReason",
5358 ospf_restart_reason2str(
5359 nbr->gr_helper_info.gr_restart_reason));
5360 }
5361
5362 if (nbr->gr_helper_info.rejected_reason
5363 != OSPF_HELPER_REJECTED_NONE)
5364 json_object_string_add(
5365 json_neigh, "helperRejectReason",
5366 ospf_rejected_reason2str(
5367 nbr->gr_helper_info.rejected_reason));
5368
5369 if (nbr->gr_helper_info.helper_exit_reason
5370 != OSPF_GR_HELPER_EXIT_NONE)
5371 json_object_string_add(
5372 json_neigh, "helperExitReason",
5373 ospf_exit_reason2str(
5374 nbr->gr_helper_info
5375 .helper_exit_reason));
5376 }
5377
5378 bfd_sess_show(vty, json_neigh, nbr->bfd_session);
5379
5380 if (use_json)
5381 json_object_array_add(json_neigh_array, json_neigh);
5382
5383 }
5384
5385 static int show_ip_ospf_neighbor_id_common(struct vty *vty, struct ospf *ospf,
5386 struct in_addr *router_id,
5387 bool use_json, uint8_t use_vrf,
5388 bool is_detail)
5389 {
5390 struct listnode *node;
5391 struct ospf_neighbor *nbr;
5392 struct ospf_interface *oi;
5393 json_object *json = NULL;
5394
5395 if (use_json)
5396 json = json_object_new_object();
5397
5398 if (ospf->instance) {
5399 if (use_json)
5400 json_object_int_add(json, "ospfInstance",
5401 ospf->instance);
5402 else
5403 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
5404 }
5405
5406 ospf_show_vrf_name(ospf, vty, json, use_vrf);
5407
5408 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
5409 nbr = ospf_nbr_lookup_by_routerid(oi->nbrs, router_id);
5410
5411 if (!nbr)
5412 continue;
5413
5414 if (is_detail)
5415 show_ip_ospf_neighbor_detail_sub(vty, oi, nbr, NULL,
5416 json, use_json);
5417 else
5418 show_ip_ospf_neighbour_brief(vty, nbr, NULL, json,
5419 use_json);
5420 }
5421
5422 if (use_json)
5423 vty_json(vty, json);
5424 else
5425 vty_out(vty, "\n");
5426
5427 return CMD_SUCCESS;
5428 }
5429
5430 DEFPY(show_ip_ospf_neighbor_id, show_ip_ospf_neighbor_id_cmd,
5431 "show ip ospf neighbor A.B.C.D$router_id [detail$detail] [json$json]",
5432 SHOW_STR IP_STR
5433 "OSPF information\n"
5434 "Neighbor list\n"
5435 "Neighbor ID\n"
5436 "Detailed output\n" JSON_STR)
5437 {
5438 struct ospf *ospf;
5439 struct listnode *node;
5440 int ret = CMD_SUCCESS;
5441
5442 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
5443 if (!ospf->oi_running)
5444 continue;
5445 ret = show_ip_ospf_neighbor_id_common(vty, ospf, &router_id,
5446 !!json, 0, !!detail);
5447 }
5448
5449 return ret;
5450 }
5451
5452 DEFPY(show_ip_ospf_instance_neighbor_id, show_ip_ospf_instance_neighbor_id_cmd,
5453 "show ip ospf (1-65535)$instance neighbor A.B.C.D$router_id [detail$detail] [json$json]",
5454 SHOW_STR IP_STR
5455 "OSPF information\n"
5456 "Instance ID\n"
5457 "Neighbor list\n"
5458 "Neighbor ID\n"
5459 "Detailed output\n" JSON_STR)
5460 {
5461 struct ospf *ospf;
5462
5463 if (instance != ospf_instance)
5464 return CMD_NOT_MY_INSTANCE;
5465
5466 ospf = ospf_lookup_instance(instance);
5467 if (!ospf || !ospf->oi_running)
5468 return CMD_SUCCESS;
5469
5470 return show_ip_ospf_neighbor_id_common(vty, ospf, &router_id, !!json, 0,
5471 !!detail);
5472 }
5473
5474 static int show_ip_ospf_neighbor_detail_common(struct vty *vty,
5475 struct ospf *ospf,
5476 json_object *json, bool use_json,
5477 uint8_t use_vrf)
5478 {
5479 struct ospf_interface *oi;
5480 struct listnode *node;
5481 json_object *json_vrf = NULL;
5482 json_object *json_nbr_sub = NULL;
5483
5484 if (use_json) {
5485 if (use_vrf)
5486 json_vrf = json_object_new_object();
5487 else
5488 json_vrf = json;
5489
5490 json_nbr_sub = json_object_new_object();
5491 }
5492
5493 if (ospf->instance) {
5494 if (use_json)
5495 json_object_int_add(json, "ospfInstance",
5496 ospf->instance);
5497 else
5498 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
5499 }
5500
5501 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
5502
5503 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
5504 struct route_node *rn;
5505 struct ospf_neighbor *nbr, *prev_nbr = NULL;
5506
5507 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn)) {
5508 nbr = rn->info;
5509
5510 if (!nbr)
5511 continue;
5512
5513 if (nbr != oi->nbr_self) {
5514 if (nbr->state != NSM_Down) {
5515 show_ip_ospf_neighbor_detail_sub(
5516 vty, oi, nbr, prev_nbr,
5517 json_nbr_sub, use_json);
5518 }
5519 }
5520 prev_nbr = nbr;
5521 }
5522 }
5523
5524 if (use_json) {
5525 json_object_object_add(json_vrf, "neighbors",
5526 json_nbr_sub);
5527 if (use_vrf)
5528 json_object_object_add(json, ospf_get_name(ospf),
5529 json_vrf);
5530 } else
5531 vty_out(vty, "\n");
5532
5533 return CMD_SUCCESS;
5534 }
5535
5536 DEFUN (show_ip_ospf_neighbor_detail,
5537 show_ip_ospf_neighbor_detail_cmd,
5538 "show ip ospf [vrf <NAME|all>] neighbor detail [json]",
5539 SHOW_STR
5540 IP_STR
5541 "OSPF information\n"
5542 VRF_CMD_HELP_STR
5543 "All VRFs\n"
5544 "Neighbor list\n"
5545 "detail of all neighbors\n"
5546 JSON_STR)
5547 {
5548 struct ospf *ospf;
5549 bool uj = use_json(argc, argv);
5550 struct listnode *node = NULL;
5551 char *vrf_name = NULL;
5552 bool all_vrf = false;
5553 int ret = CMD_SUCCESS;
5554 int inst = 0;
5555 int idx_vrf = 0;
5556 uint8_t use_vrf = 0;
5557 json_object *json = NULL;
5558
5559 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
5560
5561 if (uj)
5562 json = json_object_new_object();
5563
5564 /* vrf input is provided could be all or specific vrf*/
5565 if (vrf_name) {
5566 use_vrf = 1;
5567 if (all_vrf) {
5568 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
5569 if (!ospf->oi_running)
5570 continue;
5571 ret = show_ip_ospf_neighbor_detail_common(
5572 vty, ospf, json, uj, use_vrf);
5573 }
5574 if (uj)
5575 vty_json(vty, json);
5576
5577 return ret;
5578 }
5579 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
5580 if (ospf == NULL || !ospf->oi_running) {
5581 if (uj)
5582 json_object_free(json);
5583 return CMD_SUCCESS;
5584 }
5585 } else {
5586 /* Display default ospf (instance 0) info */
5587 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
5588 if (ospf == NULL || !ospf->oi_running) {
5589 if (uj)
5590 json_object_free(json);
5591 return CMD_SUCCESS;
5592 }
5593 }
5594
5595 if (ospf) {
5596 ret = show_ip_ospf_neighbor_detail_common(vty, ospf, json, uj,
5597 use_vrf);
5598 if (uj) {
5599 vty_out(vty, "%s\n",
5600 json_object_to_json_string_ext(
5601 json, JSON_C_TO_STRING_PRETTY));
5602 }
5603 }
5604
5605 if (uj)
5606 json_object_free(json);
5607
5608 return ret;
5609 }
5610
5611 DEFUN (show_ip_ospf_instance_neighbor_detail,
5612 show_ip_ospf_instance_neighbor_detail_cmd,
5613 "show ip ospf (1-65535) neighbor detail [json]",
5614 SHOW_STR
5615 IP_STR
5616 "OSPF information\n"
5617 "Instance ID\n"
5618 "Neighbor list\n"
5619 "detail of all neighbors\n"
5620 JSON_STR)
5621 {
5622 int idx_number = 3;
5623 struct ospf *ospf;
5624 unsigned short instance = 0;
5625 bool uj = use_json(argc, argv);
5626 json_object *json = NULL;
5627 int ret = CMD_SUCCESS;
5628
5629 instance = strtoul(argv[idx_number]->arg, NULL, 10);
5630 if (instance != ospf_instance)
5631 return CMD_NOT_MY_INSTANCE;
5632
5633 ospf = ospf_lookup_instance(instance);
5634 if (!ospf || !ospf->oi_running)
5635 return CMD_SUCCESS;
5636
5637 if (uj)
5638 json = json_object_new_object();
5639
5640 ret = show_ip_ospf_neighbor_detail_common(vty, ospf, json, uj, 0);
5641
5642 if (uj)
5643 vty_json(vty, json);
5644
5645 return ret;
5646 }
5647
5648 static int show_ip_ospf_neighbor_detail_all_common(struct vty *vty,
5649 struct ospf *ospf,
5650 json_object *json,
5651 bool use_json,
5652 uint8_t use_vrf)
5653 {
5654 struct listnode *node;
5655 struct ospf_interface *oi;
5656 json_object *json_vrf = NULL;
5657
5658 if (use_json) {
5659 if (use_vrf)
5660 json_vrf = json_object_new_object();
5661 else
5662 json_vrf = json;
5663 }
5664
5665 if (ospf->instance) {
5666 if (use_json)
5667 json_object_int_add(json, "ospfInstance",
5668 ospf->instance);
5669 else
5670 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
5671 }
5672
5673 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
5674
5675 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
5676 struct route_node *rn;
5677 struct ospf_neighbor *nbr, *prev_nbr = NULL;
5678 struct ospf_nbr_nbma *nbr_nbma;
5679
5680 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn)) {
5681 nbr = rn->info;
5682
5683 if (!nbr)
5684 continue;
5685
5686 if (nbr != oi->nbr_self)
5687 if (nbr->state != NSM_Down)
5688 show_ip_ospf_neighbor_detail_sub(
5689 vty, oi, rn->info, prev_nbr,
5690 json_vrf, use_json);
5691 prev_nbr = nbr;
5692 }
5693
5694 if (oi->type != OSPF_IFTYPE_NBMA)
5695 continue;
5696
5697 struct listnode *nd;
5698
5699 for (ALL_LIST_ELEMENTS_RO(oi->nbr_nbma, nd, nbr_nbma)) {
5700 if (nbr_nbma->nbr == NULL ||
5701 nbr_nbma->nbr->state == NSM_Down)
5702 show_ip_ospf_nbr_nbma_detail_sub(
5703 vty, oi, nbr_nbma, use_json, json_vrf);
5704 }
5705 }
5706
5707 if (use_json) {
5708 if (use_vrf)
5709 json_object_object_add(json, ospf_get_name(ospf),
5710 json_vrf);
5711 } else {
5712 vty_out(vty, "\n");
5713 }
5714
5715 return CMD_SUCCESS;
5716 }
5717
5718 DEFUN (show_ip_ospf_neighbor_detail_all,
5719 show_ip_ospf_neighbor_detail_all_cmd,
5720 "show ip ospf [vrf <NAME|all>] neighbor detail all [json]",
5721 SHOW_STR
5722 IP_STR
5723 "OSPF information\n"
5724 VRF_CMD_HELP_STR
5725 "All VRFs\n"
5726 "Neighbor list\n"
5727 "detail of all neighbors\n"
5728 "include down status neighbor\n"
5729 JSON_STR)
5730 {
5731 struct ospf *ospf;
5732 bool uj = use_json(argc, argv);
5733 struct listnode *node = NULL;
5734 char *vrf_name = NULL;
5735 bool all_vrf = false;
5736 int ret = CMD_SUCCESS;
5737 int inst = 0;
5738 int idx_vrf = 0;
5739 uint8_t use_vrf = 0;
5740 json_object *json = NULL;
5741
5742 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
5743
5744 if (uj)
5745 json = json_object_new_object();
5746
5747 /* vrf input is provided could be all or specific vrf*/
5748 if (vrf_name) {
5749 use_vrf = 1;
5750 if (all_vrf) {
5751 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
5752 if (!ospf->oi_running)
5753 continue;
5754 ret = show_ip_ospf_neighbor_detail_all_common(
5755 vty, ospf, json, uj, use_vrf);
5756 }
5757
5758 if (uj)
5759 vty_json(vty, json);
5760
5761 return ret;
5762 }
5763 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
5764 if (ospf == NULL || !ospf->oi_running) {
5765 if (uj)
5766 json_object_free(json);
5767 return CMD_SUCCESS;
5768 }
5769 } else {
5770 /* Display default ospf (instance 0) info */
5771 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
5772 if (ospf == NULL || !ospf->oi_running) {
5773 if (uj)
5774 json_object_free(json);
5775 return CMD_SUCCESS;
5776 }
5777 }
5778
5779 if (ospf) {
5780 ret = show_ip_ospf_neighbor_detail_all_common(vty, ospf, json,
5781 uj, use_vrf);
5782 if (uj) {
5783 vty_out(vty, "%s\n",
5784 json_object_to_json_string_ext(
5785 json, JSON_C_TO_STRING_PRETTY));
5786 }
5787 }
5788
5789 if (uj)
5790 json_object_free(json);
5791
5792 return ret;
5793 }
5794
5795 DEFUN (show_ip_ospf_instance_neighbor_detail_all,
5796 show_ip_ospf_instance_neighbor_detail_all_cmd,
5797 "show ip ospf (1-65535) neighbor detail all [json]",
5798 SHOW_STR
5799 IP_STR
5800 "OSPF information\n"
5801 "Instance ID\n"
5802 "Neighbor list\n"
5803 "detail of all neighbors\n"
5804 "include down status neighbor\n"
5805 JSON_STR)
5806 {
5807 int idx_number = 3;
5808 struct ospf *ospf;
5809 unsigned short instance = 0;
5810 bool uj = use_json(argc, argv);
5811 json_object *json = NULL;
5812 int ret = CMD_SUCCESS;
5813
5814 instance = strtoul(argv[idx_number]->arg, NULL, 10);
5815 if (instance != ospf_instance)
5816 return CMD_NOT_MY_INSTANCE;
5817
5818 ospf = ospf_lookup_instance(instance);
5819 if (!ospf || !ospf->oi_running)
5820 return CMD_SUCCESS;
5821
5822 if (uj)
5823 json = json_object_new_object();
5824
5825 ret = show_ip_ospf_neighbor_detail_all_common(vty, ospf, json, uj, 0);
5826
5827 if (uj)
5828 vty_json(vty, json);
5829
5830 return ret;
5831 }
5832
5833 static int show_ip_ospf_neighbor_int_detail_common(struct vty *vty,
5834 struct ospf *ospf,
5835 int arg_base,
5836 struct cmd_token **argv,
5837 bool use_json)
5838 {
5839 struct ospf_interface *oi;
5840 struct interface *ifp;
5841 struct route_node *rn, *nrn;
5842 struct ospf_neighbor *nbr;
5843 json_object *json = NULL;
5844
5845 if (use_json)
5846 json = json_object_new_object();
5847
5848 if (ospf->instance) {
5849 if (use_json)
5850 json_object_int_add(json, "ospfInstance",
5851 ospf->instance);
5852 else
5853 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
5854 }
5855
5856 ifp = if_lookup_by_name(argv[arg_base]->arg, ospf->vrf_id);
5857 if (!ifp) {
5858 if (!use_json)
5859 vty_out(vty, "No such interface.\n");
5860 else {
5861 vty_out(vty, "{}\n");
5862 json_object_free(json);
5863 }
5864 return CMD_WARNING;
5865 }
5866
5867 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
5868 oi = rn->info;
5869
5870 if (!oi)
5871 continue;
5872
5873 for (nrn = route_top(oi->nbrs); nrn; nrn = route_next(nrn)) {
5874 nbr = nrn->info;
5875
5876 if (!nbr)
5877 continue;
5878
5879 if (nbr == oi->nbr_self)
5880 continue;
5881
5882 if (nbr->state == NSM_Down)
5883 continue;
5884
5885 show_ip_ospf_neighbor_detail_sub(vty, oi, nbr, NULL,
5886 json, use_json);
5887 }
5888 }
5889
5890 if (use_json)
5891 vty_json(vty, json);
5892 else
5893 vty_out(vty, "\n");
5894
5895 return CMD_SUCCESS;
5896 }
5897
5898 DEFUN (show_ip_ospf_neighbor_int_detail,
5899 show_ip_ospf_neighbor_int_detail_cmd,
5900 "show ip ospf neighbor IFNAME detail [json]",
5901 SHOW_STR
5902 IP_STR
5903 "OSPF information\n"
5904 "Neighbor list\n"
5905 "Interface name\n"
5906 "detail of all neighbors\n"
5907 JSON_STR)
5908 {
5909 struct ospf *ospf;
5910 bool uj = use_json(argc, argv);
5911 struct listnode *node = NULL;
5912 int ret = CMD_SUCCESS;
5913 bool ospf_output = false;
5914
5915 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
5916 if (!ospf->oi_running)
5917 continue;
5918 ospf_output = true;
5919 ret = show_ip_ospf_neighbor_int_detail_common(vty, ospf, 4,
5920 argv, uj);
5921 }
5922
5923 if (!ospf_output)
5924 vty_out(vty, "%% OSPF instance not found\n");
5925
5926 return ret;
5927 }
5928
5929 DEFUN (show_ip_ospf_instance_neighbor_int_detail,
5930 show_ip_ospf_instance_neighbor_int_detail_cmd,
5931 "show ip ospf (1-65535) neighbor IFNAME detail [json]",
5932 SHOW_STR
5933 IP_STR
5934 "OSPF information\n"
5935 "Instance ID\n"
5936 "Neighbor list\n"
5937 "Interface name\n"
5938 "detail of all neighbors\n"
5939 JSON_STR)
5940 {
5941 int idx_number = 3;
5942 int idx_ifname = 5;
5943 struct ospf *ospf;
5944 unsigned short instance = 0;
5945 bool uj = use_json(argc, argv);
5946
5947 instance = strtoul(argv[idx_number]->arg, NULL, 10);
5948 if (instance != ospf_instance)
5949 return CMD_NOT_MY_INSTANCE;
5950
5951 ospf = ospf_lookup_instance(instance);
5952 if (!ospf || !ospf->oi_running)
5953 return CMD_SUCCESS;
5954
5955 return show_ip_ospf_neighbor_int_detail_common(vty, ospf, idx_ifname,
5956 argv, uj);
5957 }
5958
5959 /* Show functions */
5960 static int show_lsa_summary(struct vty *vty, struct ospf_lsa *lsa, int self,
5961 json_object *json_lsa)
5962 {
5963 struct router_lsa *rl;
5964 struct summary_lsa *sl;
5965 struct as_external_lsa *asel;
5966 struct prefix_ipv4 p;
5967
5968 if (lsa != NULL) {
5969 /* If self option is set, check LSA self flag. */
5970 if (self == 0 || IS_LSA_SELF(lsa)) {
5971
5972 if (!json_lsa) {
5973 /* LSA common part show. */
5974 vty_out(vty, "%-15pI4",
5975 &lsa->data->id);
5976 vty_out(vty, "%-15pI4 %4d 0x%08lx 0x%04x",
5977 &lsa->data->adv_router, LS_AGE(lsa),
5978 (unsigned long)ntohl(
5979 lsa->data->ls_seqnum),
5980 ntohs(lsa->data->checksum));
5981 } else {
5982 char seqnum[10];
5983 char checksum[10];
5984
5985 snprintf(seqnum, sizeof(seqnum), "%x",
5986 ntohl(lsa->data->ls_seqnum));
5987 snprintf(checksum, sizeof(checksum), "%x",
5988 ntohs(lsa->data->checksum));
5989 json_object_string_addf(json_lsa, "lsId",
5990 "%pI4", &lsa->data->id);
5991 json_object_string_addf(
5992 json_lsa, "advertisedRouter", "%pI4",
5993 &lsa->data->adv_router);
5994 json_object_int_add(json_lsa, "lsaAge",
5995 LS_AGE(lsa));
5996 json_object_string_add(
5997 json_lsa, "sequenceNumber", seqnum);
5998 json_object_string_add(json_lsa, "checksum",
5999 checksum);
6000 }
6001
6002 /* LSA specific part show. */
6003 switch (lsa->data->type) {
6004 case OSPF_ROUTER_LSA:
6005 rl = (struct router_lsa *)lsa->data;
6006
6007 if (!json_lsa)
6008 vty_out(vty, " %-d", ntohs(rl->links));
6009 else
6010 json_object_int_add(json_lsa,
6011 "numOfRouterLinks",
6012 ntohs(rl->links));
6013 break;
6014 case OSPF_SUMMARY_LSA:
6015 sl = (struct summary_lsa *)lsa->data;
6016
6017 p.family = AF_INET;
6018 p.prefix = sl->header.id;
6019 p.prefixlen = ip_masklen(sl->mask);
6020 apply_mask_ipv4(&p);
6021
6022 if (!json_lsa)
6023 vty_out(vty, " %pFX", &p);
6024 else {
6025 json_object_string_addf(
6026 json_lsa, "summaryAddress",
6027 "%pFX", &p);
6028 }
6029 break;
6030 case OSPF_AS_EXTERNAL_LSA:
6031 case OSPF_AS_NSSA_LSA:
6032 asel = (struct as_external_lsa *)lsa->data;
6033
6034 p.family = AF_INET;
6035 p.prefix = asel->header.id;
6036 p.prefixlen = ip_masklen(asel->mask);
6037 apply_mask_ipv4(&p);
6038
6039 if (!json_lsa)
6040 vty_out(vty, " %s %pFX [0x%lx]",
6041 IS_EXTERNAL_METRIC(
6042 asel->e[0].tos)
6043 ? "E2"
6044 : "E1",
6045 &p,
6046 (unsigned long)ntohl(
6047 asel->e[0].route_tag));
6048 else {
6049 json_object_string_add(
6050 json_lsa, "metricType",
6051 IS_EXTERNAL_METRIC(
6052 asel->e[0].tos)
6053 ? "E2"
6054 : "E1");
6055 json_object_string_addf(
6056 json_lsa, "route", "%pFX", &p);
6057 json_object_int_add(
6058 json_lsa, "tag",
6059 (unsigned long)ntohl(
6060 asel->e[0].route_tag));
6061 }
6062 break;
6063 case OSPF_NETWORK_LSA:
6064 case OSPF_ASBR_SUMMARY_LSA:
6065 case OSPF_OPAQUE_LINK_LSA:
6066 case OSPF_OPAQUE_AREA_LSA:
6067 case OSPF_OPAQUE_AS_LSA:
6068 default:
6069 break;
6070 }
6071
6072 if (!json_lsa)
6073 vty_out(vty, "\n");
6074 }
6075
6076 return 1;
6077 }
6078
6079 return 0;
6080 }
6081
6082 static const char *const show_database_desc[] = {
6083 "unknown",
6084 "Router Link States",
6085 "Net Link States",
6086 "Summary Link States",
6087 "ASBR-Summary Link States",
6088 "AS External Link States",
6089 "Group Membership LSA",
6090 "NSSA-external Link States",
6091 "Type-8 LSA",
6092 "Link-Local Opaque-LSA",
6093 "Area-Local Opaque-LSA",
6094 "AS-external Opaque-LSA",
6095 };
6096
6097 static const char * const show_database_desc_json[] = {
6098 "unknown",
6099 "routerLinkStates",
6100 "networkLinkStates",
6101 "summaryLinkStates",
6102 "asbrSummaryLinkStates",
6103 "asExternalLinkStates",
6104 "groupMembershipLsa",
6105 "nssaExternalLinkStates",
6106 "type8Lsa",
6107 "linkLocalOpaqueLsa",
6108 "areaLocalOpaqueLsa",
6109 "asExternalOpaqueLsa",
6110 };
6111
6112 static const char *const show_database_desc_count_json[] = {
6113 "unknownCount",
6114 "routerLinkStatesCount",
6115 "networkLinkStatesCount",
6116 "summaryLinkStatesCount",
6117 "asbrSummaryLinkStatesCount",
6118 "asExternalLinkStatesCount",
6119 "groupMembershipLsaCount",
6120 "nssaExternalLinkStatesCount",
6121 "type8LsaCount",
6122 "linkLocalOpaqueLsaCount",
6123 "areaLocalOpaqueLsaCount",
6124 "asExternalOpaqueLsaCount",
6125 };
6126
6127 static const char *const show_database_header[] = {
6128 "",
6129 "Link ID ADV Router Age Seq# CkSum Link count",
6130 "Link ID ADV Router Age Seq# CkSum",
6131 "Link ID ADV Router Age Seq# CkSum Route",
6132 "Link ID ADV Router Age Seq# CkSum",
6133 "Link ID ADV Router Age Seq# CkSum Route",
6134 " --- header for Group Member ----",
6135 "Link ID ADV Router Age Seq# CkSum Route",
6136 " --- type-8 ---",
6137 "Opaque-Type/Id ADV Router Age Seq# CkSum",
6138 "Opaque-Type/Id ADV Router Age Seq# CkSum",
6139 "Opaque-Type/Id ADV Router Age Seq# CkSum",
6140 };
6141
6142 static void show_ip_ospf_database_header(struct vty *vty, struct ospf_lsa *lsa,
6143 json_object *json)
6144 {
6145 struct router_lsa *rlsa = (struct router_lsa *)lsa->data;
6146
6147 if (!json) {
6148 vty_out(vty, " LS age: %d\n", LS_AGE(lsa));
6149 vty_out(vty, " Options: 0x%-2x : %s\n", lsa->data->options,
6150 ospf_options_dump(lsa->data->options));
6151 vty_out(vty, " LS Flags: 0x%-2x %s\n", lsa->flags,
6152 ((lsa->flags & OSPF_LSA_LOCAL_XLT)
6153 ? "(Translated from Type-7)"
6154 : ""));
6155
6156 if (lsa->data->type == OSPF_ROUTER_LSA) {
6157 vty_out(vty, " Flags: 0x%x", rlsa->flags);
6158
6159 if (rlsa->flags)
6160 vty_out(vty, " :%s%s%s%s",
6161 IS_ROUTER_LSA_BORDER(rlsa) ? " ABR"
6162 : "",
6163 IS_ROUTER_LSA_EXTERNAL(rlsa) ? " ASBR"
6164 : "",
6165 IS_ROUTER_LSA_VIRTUAL(rlsa)
6166 ? " VL-endpoint"
6167 : "",
6168 IS_ROUTER_LSA_SHORTCUT(rlsa)
6169 ? " Shortcut"
6170 : "");
6171
6172 vty_out(vty, "\n");
6173 }
6174 vty_out(vty, " LS Type: %s\n",
6175 lookup_msg(ospf_lsa_type_msg, lsa->data->type, NULL));
6176 vty_out(vty, " Link State ID: %pI4 %s\n",
6177 &lsa->data->id,
6178 lookup_msg(ospf_link_state_id_type_msg, lsa->data->type,
6179 NULL));
6180 vty_out(vty, " Advertising Router: %pI4\n",
6181 &lsa->data->adv_router);
6182 vty_out(vty, " LS Seq Number: %08lx\n",
6183 (unsigned long)ntohl(lsa->data->ls_seqnum));
6184 vty_out(vty, " Checksum: 0x%04x\n",
6185 ntohs(lsa->data->checksum));
6186 vty_out(vty, " Length: %d\n\n", ntohs(lsa->data->length));
6187 } else {
6188 char seqnum[10];
6189 char checksum[10];
6190
6191 snprintf(seqnum, 10, "%x", ntohl(lsa->data->ls_seqnum));
6192 snprintf(checksum, 10, "%x", ntohs(lsa->data->checksum));
6193
6194 json_object_int_add(json, "lsaAge", LS_AGE(lsa));
6195 json_object_string_add(json, "options",
6196 ospf_options_dump(lsa->data->options));
6197 json_object_int_add(json, "lsaFlags", lsa->flags);
6198
6199 if (lsa->flags & OSPF_LSA_LOCAL_XLT)
6200 json_object_boolean_true_add(json,
6201 "translatedFromType7");
6202
6203 if (lsa->data->type == OSPF_ROUTER_LSA) {
6204 json_object_int_add(json, "flags", rlsa->flags);
6205
6206 if (rlsa->flags) {
6207 if (IS_ROUTER_LSA_BORDER(rlsa))
6208 json_object_boolean_true_add(json,
6209 "abr");
6210 if (IS_ROUTER_LSA_EXTERNAL(rlsa))
6211 json_object_boolean_true_add(json,
6212 "asbr");
6213 if (IS_ROUTER_LSA_VIRTUAL(rlsa))
6214 json_object_boolean_true_add(
6215 json, "vlEndpoint");
6216 if (IS_ROUTER_LSA_SHORTCUT(rlsa))
6217 json_object_boolean_true_add(
6218 json, "shortcut");
6219 }
6220 }
6221
6222 json_object_string_add(
6223 json, "lsaType",
6224 lookup_msg(ospf_lsa_type_msg, lsa->data->type, NULL));
6225 json_object_string_addf(json, "linkStateId", "%pI4",
6226 &lsa->data->id);
6227 json_object_string_addf(json, "advertisingRouter", "%pI4",
6228 &lsa->data->adv_router);
6229 json_object_string_add(json, "lsaSeqNumber", seqnum);
6230 json_object_string_add(json, "checksum", checksum);
6231 json_object_int_add(json, "length", ntohs(lsa->data->length));
6232 }
6233 }
6234
6235 static const char *const link_type_desc[] = {
6236 "(null)",
6237 "another Router (point-to-point)",
6238 "a Transit Network",
6239 "Stub Network",
6240 "a Virtual Link",
6241 };
6242
6243 static const char *const link_id_desc[] = {
6244 "(null)", "Neighboring Router ID", "Designated Router address",
6245 "Net", "Neighboring Router ID",
6246 };
6247
6248 static const char *const link_data_desc[] = {
6249 "(null)", "Router Interface address", "Router Interface address",
6250 "Network Mask", "Router Interface address",
6251 };
6252
6253 static const char *const link_id_desc_json[] = {
6254 "null", "neighborRouterId", "designatedRouterAddress",
6255 "networkAddress", "neighborRouterId",
6256 };
6257
6258 static const char *const link_data_desc_json[] = {
6259 "null", "routerInterfaceAddress", "routerInterfaceAddress",
6260 "networkMask", "routerInterfaceAddress",
6261 };
6262
6263 /* Show router-LSA each Link information. */
6264 static void show_ip_ospf_database_router_links(struct vty *vty,
6265 struct router_lsa *rl,
6266 json_object *json)
6267 {
6268 int len, type;
6269 unsigned short i;
6270 json_object *json_links = NULL;
6271 json_object *json_link = NULL;
6272 int metric = 0;
6273 char buf[PREFIX_STRLEN];
6274
6275 if (json)
6276 json_links = json_object_new_object();
6277
6278 len = ntohs(rl->header.length) - 4;
6279 for (i = 0; i < ntohs(rl->links) && len > 0; len -= 12, i++) {
6280 type = rl->link[i].type;
6281
6282 if (json) {
6283 char link[16];
6284
6285 snprintf(link, sizeof(link), "link%u", i);
6286 json_link = json_object_new_object();
6287 json_object_string_add(json_link, "linkType",
6288 link_type_desc[type]);
6289 json_object_string_add(json_link,
6290 link_id_desc_json[type],
6291 inet_ntop(AF_INET,
6292 &rl->link[i].link_id,
6293 buf, sizeof(buf)));
6294 json_object_string_add(
6295 json_link, link_data_desc_json[type],
6296 inet_ntop(AF_INET, &rl->link[i].link_data,
6297 buf, sizeof(buf)));
6298 json_object_int_add(json_link, "numOfTosMetrics",
6299 metric);
6300 json_object_int_add(json_link, "tos0Metric",
6301 ntohs(rl->link[i].metric));
6302 json_object_object_add(json_links, link, json_link);
6303 } else {
6304 vty_out(vty, " Link connected to: %s\n",
6305 link_type_desc[type]);
6306 vty_out(vty, " (Link ID) %s: %pI4\n",
6307 link_id_desc[type],
6308 &rl->link[i].link_id);
6309 vty_out(vty, " (Link Data) %s: %pI4\n",
6310 link_data_desc[type],
6311 &rl->link[i].link_data);
6312 vty_out(vty, " Number of TOS metrics: 0\n");
6313 vty_out(vty, " TOS 0 Metric: %d\n",
6314 ntohs(rl->link[i].metric));
6315 vty_out(vty, "\n");
6316 }
6317 }
6318 if (json)
6319 json_object_object_add(json, "routerLinks", json_links);
6320 }
6321
6322 /* Show router-LSA detail information. */
6323 static int show_router_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6324 json_object *json)
6325 {
6326 if (lsa != NULL) {
6327 struct router_lsa *rl = (struct router_lsa *)lsa->data;
6328
6329 show_ip_ospf_database_header(vty, lsa, json);
6330
6331 if (!json)
6332 vty_out(vty, " Number of Links: %d\n\n",
6333 ntohs(rl->links));
6334 else
6335 json_object_int_add(json, "numOfLinks",
6336 ntohs(rl->links));
6337
6338 show_ip_ospf_database_router_links(vty, rl, json);
6339
6340 if (!json)
6341 vty_out(vty, "\n");
6342 }
6343
6344 return 0;
6345 }
6346
6347 /* Show network-LSA detail information. */
6348 static int show_network_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6349 json_object *json)
6350 {
6351 int length, i;
6352 char buf[PREFIX_STRLEN];
6353 json_object *json_attached_rt = NULL;
6354 json_object *json_router = NULL;
6355
6356 if (json)
6357 json_attached_rt = json_object_new_object();
6358
6359 if (lsa != NULL) {
6360 struct network_lsa *nl = (struct network_lsa *)lsa->data;
6361 struct in_addr *addr;
6362
6363 show_ip_ospf_database_header(vty, lsa, json);
6364
6365 if (!json)
6366 vty_out(vty, " Network Mask: /%d\n",
6367 ip_masklen(nl->mask));
6368 else
6369 json_object_int_add(json, "networkMask",
6370 ip_masklen(nl->mask));
6371
6372 length = lsa->size - OSPF_LSA_HEADER_SIZE - 4;
6373 addr = &nl->routers[0];
6374 for (i = 0; length > 0 && addr;
6375 length -= 4, addr = &nl->routers[++i])
6376 if (!json) {
6377 vty_out(vty, " Attached Router: %pI4\n",
6378 addr);
6379 vty_out(vty, "\n");
6380 } else {
6381 json_router = json_object_new_object();
6382 json_object_string_add(
6383 json_router, "attachedRouterId",
6384 inet_ntop(AF_INET, addr, buf,
6385 sizeof(buf)));
6386 json_object_object_add(json_attached_rt,
6387 inet_ntop(AF_INET, addr,
6388 buf,
6389 sizeof(buf)),
6390 json_router);
6391 }
6392 }
6393
6394 if (json)
6395 json_object_object_add(json, "attchedRouters",
6396 json_attached_rt);
6397
6398 return 0;
6399 }
6400
6401 /* Show summary-LSA detail information. */
6402 static int show_summary_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6403 json_object *json)
6404 {
6405 if (lsa != NULL) {
6406 struct summary_lsa *sl = (struct summary_lsa *)lsa->data;
6407
6408 show_ip_ospf_database_header(vty, lsa, json);
6409
6410 if (!json) {
6411 vty_out(vty, " Network Mask: /%d\n",
6412 ip_masklen(sl->mask));
6413 vty_out(vty, " TOS: 0 Metric: %d\n",
6414 GET_METRIC(sl->metric));
6415 vty_out(vty, "\n");
6416 } else {
6417 json_object_int_add(json, "networkMask",
6418 ip_masklen(sl->mask));
6419 json_object_int_add(json, "tos0Metric",
6420 GET_METRIC(sl->metric));
6421 }
6422 }
6423
6424 return 0;
6425 }
6426
6427 /* Show summary-ASBR-LSA detail information. */
6428 static int show_summary_asbr_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6429 json_object *json)
6430 {
6431 if (lsa != NULL) {
6432 struct summary_lsa *sl = (struct summary_lsa *)lsa->data;
6433
6434 show_ip_ospf_database_header(vty, lsa, json);
6435
6436 if (!json) {
6437 vty_out(vty, " Network Mask: /%d\n",
6438 ip_masklen(sl->mask));
6439 vty_out(vty, " TOS: 0 Metric: %d\n",
6440 GET_METRIC(sl->metric));
6441 vty_out(vty, "\n");
6442 } else {
6443 json_object_int_add(json, "networkMask",
6444 ip_masklen(sl->mask));
6445 json_object_int_add(json, "tos0Metric",
6446 GET_METRIC(sl->metric));
6447 }
6448 }
6449
6450 return 0;
6451 }
6452
6453 /* Show AS-external-LSA detail information. */
6454 static int show_as_external_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6455 json_object *json)
6456 {
6457 int tos = 0;
6458
6459 if (lsa != NULL) {
6460 struct as_external_lsa *al =
6461 (struct as_external_lsa *)lsa->data;
6462
6463 show_ip_ospf_database_header(vty, lsa, json);
6464
6465 if (!json) {
6466 vty_out(vty, " Network Mask: /%d\n",
6467 ip_masklen(al->mask));
6468 vty_out(vty, " Metric Type: %s\n",
6469 IS_EXTERNAL_METRIC(al->e[0].tos)
6470 ? "2 (Larger than any link state path)"
6471 : "1");
6472 vty_out(vty, " TOS: 0\n");
6473 vty_out(vty, " Metric: %d\n",
6474 GET_METRIC(al->e[0].metric));
6475 vty_out(vty, " Forward Address: %pI4\n",
6476 &al->e[0].fwd_addr);
6477 vty_out(vty,
6478 " External Route Tag: %" ROUTE_TAG_PRI "\n\n",
6479 (route_tag_t)ntohl(al->e[0].route_tag));
6480 } else {
6481 json_object_int_add(json, "networkMask",
6482 ip_masklen(al->mask));
6483 json_object_string_add(
6484 json, "metricType",
6485 IS_EXTERNAL_METRIC(al->e[0].tos)
6486 ? "E2 (Larger than any link state path)"
6487 : "E1");
6488 json_object_int_add(json, "tos", tos);
6489 json_object_int_add(json, "metric",
6490 GET_METRIC(al->e[0].metric));
6491 json_object_string_addf(json, "forwardAddress", "%pI4",
6492 &(al->e[0].fwd_addr));
6493 json_object_int_add(
6494 json, "externalRouteTag",
6495 (route_tag_t)ntohl(al->e[0].route_tag));
6496 }
6497 }
6498
6499 return 0;
6500 }
6501
6502 /* Show AS-NSSA-LSA detail information. */
6503 static int show_as_nssa_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6504 json_object *json)
6505 {
6506 int tos = 0;
6507
6508 if (lsa != NULL) {
6509 struct as_external_lsa *al =
6510 (struct as_external_lsa *)lsa->data;
6511
6512 show_ip_ospf_database_header(vty, lsa, json);
6513
6514 if (!json) {
6515 vty_out(vty, " Network Mask: /%d\n",
6516 ip_masklen(al->mask));
6517 vty_out(vty, " Metric Type: %s\n",
6518 IS_EXTERNAL_METRIC(al->e[0].tos)
6519 ? "2 (Larger than any link state path)"
6520 : "1");
6521 vty_out(vty, " TOS: 0\n");
6522 vty_out(vty, " Metric: %d\n",
6523 GET_METRIC(al->e[0].metric));
6524 vty_out(vty, " NSSA: Forward Address: %pI4\n",
6525 &al->e[0].fwd_addr);
6526 vty_out(vty,
6527 " External Route Tag: %" ROUTE_TAG_PRI
6528 "\n\n",
6529 (route_tag_t)ntohl(al->e[0].route_tag));
6530 } else {
6531 json_object_int_add(json, "networkMask",
6532 ip_masklen(al->mask));
6533 json_object_string_add(
6534 json, "metricType",
6535 IS_EXTERNAL_METRIC(al->e[0].tos)
6536 ? "E2 (Larger than any link state path)"
6537 : "E1");
6538 json_object_int_add(json, "tos", tos);
6539 json_object_int_add(json, "metric",
6540 GET_METRIC(al->e[0].metric));
6541 json_object_string_addf(json, "nssaForwardAddress",
6542 "%pI4", &al->e[0].fwd_addr);
6543 json_object_int_add(
6544 json, "externalRouteTag",
6545 (route_tag_t)ntohl(al->e[0].route_tag));
6546 }
6547 }
6548
6549 return 0;
6550 }
6551
6552 static int show_func_dummy(struct vty *vty, struct ospf_lsa *lsa,
6553 json_object *json)
6554 {
6555 return 0;
6556 }
6557
6558 static int show_opaque_lsa_detail(struct vty *vty, struct ospf_lsa *lsa,
6559 json_object *json)
6560 {
6561 if (lsa != NULL) {
6562 show_ip_ospf_database_header(vty, lsa, json);
6563 show_opaque_info_detail(vty, lsa, json);
6564 if (!json)
6565 vty_out(vty, "\n");
6566 }
6567 return 0;
6568 }
6569
6570 int (*show_function[])(struct vty *, struct ospf_lsa *, json_object *) = {
6571 NULL,
6572 show_router_lsa_detail,
6573 show_network_lsa_detail,
6574 show_summary_lsa_detail,
6575 show_summary_asbr_lsa_detail,
6576 show_as_external_lsa_detail,
6577 show_func_dummy,
6578 show_as_nssa_lsa_detail, /* almost same as external */
6579 NULL, /* type-8 */
6580 show_opaque_lsa_detail,
6581 show_opaque_lsa_detail,
6582 show_opaque_lsa_detail,
6583 };
6584
6585 static void show_lsa_prefix_set(struct vty *vty, struct prefix_ls *lp,
6586 struct in_addr *id, struct in_addr *adv_router)
6587 {
6588 memset(lp, 0, sizeof(struct prefix_ls));
6589 lp->family = AF_UNSPEC;
6590 if (id == NULL)
6591 lp->prefixlen = 0;
6592 else if (adv_router == NULL) {
6593 lp->prefixlen = IPV4_MAX_BITLEN;
6594 lp->id = *id;
6595 } else {
6596 lp->prefixlen = 64;
6597 lp->id = *id;
6598 lp->adv_router = *adv_router;
6599 }
6600 }
6601
6602 static void show_lsa_detail_proc(struct vty *vty, struct route_table *rt,
6603 struct in_addr *id, struct in_addr *adv_router,
6604 json_object *json)
6605 {
6606 struct prefix_ls lp;
6607 struct route_node *rn, *start;
6608 struct ospf_lsa *lsa;
6609 json_object *json_lsa = NULL;
6610
6611 show_lsa_prefix_set(vty, &lp, id, adv_router);
6612 start = route_node_get(rt, (struct prefix *)&lp);
6613 if (start) {
6614 route_lock_node(start);
6615 for (rn = start; rn; rn = route_next_until(rn, start))
6616 if ((lsa = rn->info)) {
6617 if (json) {
6618 json_lsa = json_object_new_object();
6619 json_object_array_add(json, json_lsa);
6620 }
6621
6622 if (show_function[lsa->data->type] != NULL)
6623 show_function[lsa->data->type](
6624 vty, lsa, json_lsa);
6625 }
6626 route_unlock_node(start);
6627 }
6628 }
6629
6630 /* Show detail LSA information
6631 -- if id is NULL then show all LSAs. */
6632 static void show_lsa_detail(struct vty *vty, struct ospf *ospf, int type,
6633 struct in_addr *id, struct in_addr *adv_router,
6634 json_object *json)
6635 {
6636 struct listnode *node;
6637 struct ospf_area *area;
6638 char buf[PREFIX_STRLEN];
6639 json_object *json_lsa_type = NULL;
6640 json_object *json_areas = NULL;
6641 json_object *json_lsa_array = NULL;
6642
6643 if (json)
6644 json_lsa_type = json_object_new_object();
6645
6646 switch (type) {
6647 case OSPF_AS_EXTERNAL_LSA:
6648 case OSPF_OPAQUE_AS_LSA:
6649 if (!json)
6650 vty_out(vty, " %s \n\n",
6651 show_database_desc[type]);
6652 else
6653 json_lsa_array = json_object_new_array();
6654
6655 show_lsa_detail_proc(vty, AS_LSDB(ospf, type), id, adv_router,
6656 json_lsa_array);
6657 if (json)
6658 json_object_object_add(json,
6659 show_database_desc_json[type],
6660 json_lsa_array);
6661
6662 break;
6663 default:
6664 if (json)
6665 json_areas = json_object_new_object();
6666
6667 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
6668 if (!json) {
6669 vty_out(vty,
6670 "\n %s (Area %s)\n\n",
6671 show_database_desc[type],
6672 ospf_area_desc_string(area));
6673 } else {
6674 json_lsa_array = json_object_new_array();
6675 json_object_object_add(json_areas,
6676 inet_ntop(AF_INET,
6677 &area->area_id,
6678 buf,
6679 sizeof(buf)),
6680 json_lsa_array);
6681 }
6682
6683 show_lsa_detail_proc(vty, AREA_LSDB(area, type), id,
6684 adv_router, json_lsa_array);
6685 }
6686
6687 if (json) {
6688 json_object_object_add(json_lsa_type, "areas",
6689 json_areas);
6690 json_object_object_add(json,
6691 show_database_desc_json[type],
6692 json_lsa_type);
6693 }
6694 break;
6695 }
6696 }
6697
6698 static void show_lsa_detail_adv_router_proc(struct vty *vty,
6699 struct route_table *rt,
6700 struct in_addr *adv_router,
6701 json_object *json)
6702 {
6703 char buf[PREFIX_STRLEN];
6704 struct route_node *rn;
6705 struct ospf_lsa *lsa;
6706
6707 for (rn = route_top(rt); rn; rn = route_next(rn))
6708 if ((lsa = rn->info)) {
6709 json_object *json_lsa = NULL;
6710
6711 if (IPV4_ADDR_SAME(adv_router,
6712 &lsa->data->adv_router)) {
6713 if (CHECK_FLAG(lsa->flags, OSPF_LSA_LOCAL_XLT))
6714 continue;
6715 if (json)
6716 json_lsa = json_object_new_object();
6717
6718 if (show_function[lsa->data->type] != NULL)
6719 show_function[lsa->data->type](
6720 vty, lsa, json_lsa);
6721 if (json)
6722 json_object_object_add(
6723 json,
6724 inet_ntop(AF_INET,
6725 &lsa->data->id,
6726 buf, sizeof(buf)),
6727 json_lsa);
6728 }
6729 }
6730 }
6731
6732 /* Show detail LSA information. */
6733 static void show_lsa_detail_adv_router(struct vty *vty, struct ospf *ospf,
6734 int type, struct in_addr *adv_router,
6735 json_object *json)
6736 {
6737 struct listnode *node;
6738 struct ospf_area *area;
6739 char buf[PREFIX_STRLEN];
6740 json_object *json_lstype = NULL;
6741 json_object *json_area = NULL;
6742
6743 if (json)
6744 json_lstype = json_object_new_object();
6745
6746 switch (type) {
6747 case OSPF_AS_EXTERNAL_LSA:
6748 case OSPF_OPAQUE_AS_LSA:
6749 if (!json)
6750 vty_out(vty, " %s \n\n",
6751 show_database_desc[type]);
6752
6753 show_lsa_detail_adv_router_proc(vty, AS_LSDB(ospf, type),
6754 adv_router, json_lstype);
6755 break;
6756 default:
6757
6758 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
6759 if (json)
6760 json_area = json_object_new_object();
6761 else
6762 vty_out(vty,
6763 "\n %s (Area %s)\n\n",
6764 show_database_desc[type],
6765 ospf_area_desc_string(area));
6766 show_lsa_detail_adv_router_proc(vty,
6767 AREA_LSDB(area, type),
6768 adv_router, json_area);
6769
6770 if (json)
6771 json_object_object_add(json_lstype,
6772 inet_ntop(AF_INET,
6773 &area->area_id,
6774 buf,
6775 sizeof(buf)),
6776 json_area);
6777 }
6778 break;
6779 }
6780
6781 if (json)
6782 json_object_object_add(json, show_database_desc[type],
6783 json_lstype);
6784 }
6785
6786 void show_ip_ospf_database_summary(struct vty *vty, struct ospf *ospf, int self,
6787 json_object *json)
6788 {
6789 struct ospf_lsa *lsa;
6790 struct route_node *rn;
6791 struct ospf_area *area;
6792 struct listnode *node;
6793 char buf[PREFIX_STRLEN];
6794 json_object *json_areas = NULL;
6795 json_object *json_area = NULL;
6796 json_object *json_lsa = NULL;
6797 int type;
6798 json_object *json_lsa_array = NULL;
6799 uint32_t count;
6800
6801 if (json)
6802 json_areas = json_object_new_object();
6803
6804 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
6805 if (json)
6806 json_area = json_object_new_object();
6807
6808 for (type = OSPF_MIN_LSA; type < OSPF_MAX_LSA; type++) {
6809 count = 0;
6810 switch (type) {
6811 case OSPF_AS_EXTERNAL_LSA:
6812 case OSPF_OPAQUE_AS_LSA:
6813 continue;
6814 default:
6815 break;
6816 }
6817 if (ospf_lsdb_count_self(area->lsdb, type) > 0
6818 || (!self
6819 && ospf_lsdb_count(area->lsdb, type) > 0)) {
6820
6821 if (!json) {
6822 vty_out(vty,
6823 " %s (Area %s)\n\n",
6824 show_database_desc[type],
6825 ospf_area_desc_string(area));
6826 vty_out(vty, "%s\n",
6827 show_database_header[type]);
6828 } else {
6829 json_lsa_array =
6830 json_object_new_array();
6831 json_object_object_add(
6832 json_area,
6833 show_database_desc_json[type],
6834 json_lsa_array);
6835 }
6836
6837 LSDB_LOOP (AREA_LSDB(area, type), rn, lsa) {
6838 if (json) {
6839 json_lsa =
6840 json_object_new_object();
6841 json_object_array_add(
6842 json_lsa_array,
6843 json_lsa);
6844 }
6845
6846 count += show_lsa_summary(
6847 vty, lsa, self, json_lsa);
6848 }
6849
6850 if (!json)
6851 vty_out(vty, "\n");
6852 else
6853 json_object_int_add(
6854 json_area,
6855
6856 show_database_desc_count_json
6857 [type],
6858 count);
6859 }
6860 }
6861 if (json)
6862 json_object_object_add(json_areas,
6863 inet_ntop(AF_INET,
6864 &area->area_id,
6865 buf, sizeof(buf)),
6866 json_area);
6867 }
6868
6869 if (json)
6870 json_object_object_add(json, "areas", json_areas);
6871
6872 for (type = OSPF_MIN_LSA; type < OSPF_MAX_LSA; type++) {
6873 count = 0;
6874 switch (type) {
6875 case OSPF_AS_EXTERNAL_LSA:
6876 case OSPF_OPAQUE_AS_LSA:
6877 break;
6878 default:
6879 continue;
6880 }
6881 if (ospf_lsdb_count_self(ospf->lsdb, type)
6882 || (!self && ospf_lsdb_count(ospf->lsdb, type))) {
6883 if (!json) {
6884 vty_out(vty, " %s\n\n",
6885 show_database_desc[type]);
6886 vty_out(vty, "%s\n",
6887 show_database_header[type]);
6888 } else {
6889 json_lsa_array = json_object_new_array();
6890 json_object_object_add(
6891 json, show_database_desc_json[type],
6892 json_lsa_array);
6893 }
6894
6895 LSDB_LOOP (AS_LSDB(ospf, type), rn, lsa) {
6896 if (json) {
6897 json_lsa = json_object_new_object();
6898 json_object_array_add(json_lsa_array,
6899 json_lsa);
6900 }
6901
6902 count += show_lsa_summary(vty, lsa, self,
6903 json_lsa);
6904 }
6905
6906 if (!json)
6907 vty_out(vty, "\n");
6908 else
6909 json_object_int_add(
6910 json,
6911 show_database_desc_count_json[type],
6912 count);
6913 }
6914 }
6915
6916 if (!json)
6917 vty_out(vty, "\n");
6918 }
6919
6920 static void show_ip_ospf_database_maxage(struct vty *vty, struct ospf *ospf,
6921 json_object *json)
6922 {
6923 struct route_node *rn;
6924 char buf[PREFIX_STRLEN];
6925 json_object *json_maxage = NULL;
6926
6927 if (!json)
6928 vty_out(vty, "\n MaxAge Link States:\n\n");
6929 else
6930 json_maxage = json_object_new_object();
6931
6932 for (rn = route_top(ospf->maxage_lsa); rn; rn = route_next(rn)) {
6933 struct ospf_lsa *lsa;
6934 json_object *json_lsa = NULL;
6935
6936 if ((lsa = rn->info) != NULL) {
6937 if (!json) {
6938 vty_out(vty, "Link type: %d\n",
6939 lsa->data->type);
6940 vty_out(vty, "Link State ID: %pI4\n",
6941 &lsa->data->id);
6942 vty_out(vty, "Advertising Router: %pI4\n",
6943 &lsa->data->adv_router);
6944 vty_out(vty, "LSA lock count: %d\n", lsa->lock);
6945 vty_out(vty, "\n");
6946 } else {
6947 json_lsa = json_object_new_object();
6948 json_object_int_add(json_lsa, "linkType",
6949 lsa->data->type);
6950 json_object_string_addf(json_lsa, "linkStateId",
6951 "%pI4", &lsa->data->id);
6952 json_object_string_addf(
6953 json_lsa, "advertisingRouter", "%pI4",
6954 &lsa->data->adv_router);
6955 json_object_int_add(json_lsa, "lsaLockCount",
6956 lsa->lock);
6957 json_object_object_add(
6958 json_maxage,
6959 inet_ntop(AF_INET,
6960 &lsa->data->id,
6961 buf, sizeof(buf)),
6962 json_lsa);
6963 }
6964 }
6965 }
6966 if (json)
6967 json_object_object_add(json, "maxAgeLinkStates", json_maxage);
6968 }
6969
6970 #define OSPF_LSA_TYPE_NSSA_DESC "NSSA external link state\n"
6971 #define OSPF_LSA_TYPE_NSSA_CMD_STR "|nssa-external"
6972
6973 #define OSPF_LSA_TYPE_OPAQUE_LINK_DESC "Link local Opaque-LSA\n"
6974 #define OSPF_LSA_TYPE_OPAQUE_AREA_DESC "Link area Opaque-LSA\n"
6975 #define OSPF_LSA_TYPE_OPAQUE_AS_DESC "Link AS Opaque-LSA\n"
6976 #define OSPF_LSA_TYPE_OPAQUE_CMD_STR "|opaque-link|opaque-area|opaque-as"
6977
6978 #define OSPF_LSA_TYPES_DESC \
6979 "ASBR summary link states\n" \
6980 "External link states\n" \
6981 "Network link states\n" \
6982 "Router link states\n" \
6983 "Network summary link states\n" OSPF_LSA_TYPE_NSSA_DESC \
6984 OSPF_LSA_TYPE_OPAQUE_LINK_DESC OSPF_LSA_TYPE_OPAQUE_AREA_DESC \
6985 OSPF_LSA_TYPE_OPAQUE_AS_DESC
6986
6987 static int show_ip_ospf_database_common(struct vty *vty, struct ospf *ospf,
6988 int arg_base, int argc,
6989 struct cmd_token **argv,
6990 uint8_t use_vrf, json_object *json,
6991 bool uj)
6992 {
6993 int idx_type = 4;
6994 int type, ret;
6995 struct in_addr id, adv_router;
6996 json_object *json_vrf = NULL;
6997
6998 if (uj) {
6999 if (use_vrf)
7000 json_vrf = json_object_new_object();
7001 else
7002 json_vrf = json;
7003 }
7004
7005 if (ospf->instance) {
7006 if (uj)
7007 json_object_int_add(json_vrf, "ospfInstance",
7008 ospf->instance);
7009 else
7010 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
7011 }
7012
7013 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
7014
7015 /* Show Router ID. */
7016 if (uj) {
7017 json_object_string_addf(json_vrf, "routerId", "%pI4",
7018 &ospf->router_id);
7019 } else {
7020 vty_out(vty, "\n OSPF Router with ID (%pI4)\n\n",
7021 &ospf->router_id);
7022 }
7023
7024 /* Show all LSA. */
7025 if ((argc == arg_base + 4) || (uj && (argc == arg_base + 5))) {
7026 show_ip_ospf_database_summary(vty, ospf, 0, json_vrf);
7027 if (json) {
7028 if (use_vrf)
7029 json_object_object_add(
7030 json, ospf_get_name(ospf), json_vrf);
7031 }
7032 return CMD_SUCCESS;
7033 }
7034
7035 /* Set database type to show. */
7036 if (strncmp(argv[arg_base + idx_type]->text, "r", 1) == 0)
7037 type = OSPF_ROUTER_LSA;
7038 else if (strncmp(argv[arg_base + idx_type]->text, "ne", 2) == 0)
7039 type = OSPF_NETWORK_LSA;
7040 else if (strncmp(argv[arg_base + idx_type]->text, "ns", 2) == 0)
7041 type = OSPF_AS_NSSA_LSA;
7042 else if (strncmp(argv[arg_base + idx_type]->text, "su", 2) == 0)
7043 type = OSPF_SUMMARY_LSA;
7044 else if (strncmp(argv[arg_base + idx_type]->text, "a", 1) == 0)
7045 type = OSPF_ASBR_SUMMARY_LSA;
7046 else if (strncmp(argv[arg_base + idx_type]->text, "e", 1) == 0)
7047 type = OSPF_AS_EXTERNAL_LSA;
7048 else if (strncmp(argv[arg_base + idx_type]->text, "se", 2) == 0) {
7049 show_ip_ospf_database_summary(vty, ospf, 1, json_vrf);
7050 if (json) {
7051 if (use_vrf)
7052 json_object_object_add(
7053 json, ospf_get_name(ospf), json_vrf);
7054 }
7055 return CMD_SUCCESS;
7056 } else if (strncmp(argv[arg_base + idx_type]->text, "m", 1) == 0) {
7057 show_ip_ospf_database_maxage(vty, ospf, json_vrf);
7058 if (json) {
7059 if (use_vrf)
7060 json_object_object_add(
7061 json, ospf_get_name(ospf), json_vrf);
7062 }
7063 return CMD_SUCCESS;
7064 } else if (strncmp(argv[arg_base + idx_type]->text, "opaque-l", 8) == 0)
7065 type = OSPF_OPAQUE_LINK_LSA;
7066 else if (strncmp(argv[arg_base + idx_type]->text, "opaque-ar", 9) == 0)
7067 type = OSPF_OPAQUE_AREA_LSA;
7068 else if (strncmp(argv[arg_base + idx_type]->text, "opaque-as", 9) == 0)
7069 type = OSPF_OPAQUE_AS_LSA;
7070 else
7071 return CMD_WARNING;
7072
7073 /* `show ip ospf database LSA'. */
7074 if ((argc == arg_base + 5) || (uj && (argc == arg_base + 6)))
7075 show_lsa_detail(vty, ospf, type, NULL, NULL, json_vrf);
7076 else if (argc >= arg_base + 6) {
7077 ret = inet_aton(argv[arg_base + 5]->arg, &id);
7078 if (!ret)
7079 return CMD_WARNING;
7080
7081 /* `show ip ospf database LSA ID'. */
7082 if ((argc == arg_base + 6) || (uj && (argc == arg_base + 7)))
7083 show_lsa_detail(vty, ospf, type, &id, NULL, json_vrf);
7084 /* `show ip ospf database LSA ID adv-router ADV_ROUTER'. */
7085 else if ((argc == arg_base + 7)
7086 || (uj && (argc == arg_base + 8))) {
7087 if (strncmp(argv[arg_base + 6]->text, "s", 1) == 0)
7088 adv_router = ospf->router_id;
7089 else {
7090 ret = inet_aton(argv[arg_base + 7]->arg,
7091 &adv_router);
7092 if (!ret)
7093 return CMD_WARNING;
7094 }
7095 show_lsa_detail(vty, ospf, type, &id, &adv_router,
7096 json_vrf);
7097 }
7098 }
7099
7100 if (json) {
7101 if (use_vrf)
7102 json_object_object_add(json, ospf_get_name(ospf),
7103 json_vrf);
7104 }
7105
7106 return CMD_SUCCESS;
7107 }
7108
7109 DEFUN (show_ip_ospf_database_max,
7110 show_ip_ospf_database_max_cmd,
7111 "show ip ospf [vrf <NAME|all>] database <max-age|self-originate> [json]",
7112 SHOW_STR
7113 IP_STR
7114 "OSPF information\n"
7115 VRF_CMD_HELP_STR
7116 "All VRFs\n"
7117 "Database summary\n"
7118 "LSAs in MaxAge list\n"
7119 "Self-originated link states\n"
7120 JSON_STR)
7121 {
7122 struct ospf *ospf = NULL;
7123 struct listnode *node = NULL;
7124 char *vrf_name = NULL;
7125 bool all_vrf = false;
7126 int ret = CMD_SUCCESS;
7127 int inst = 0;
7128 int idx_vrf = 0;
7129 uint8_t use_vrf = 0;
7130 bool uj = use_json(argc, argv);
7131 json_object *json = NULL;
7132
7133 if (uj)
7134 json = json_object_new_object();
7135
7136 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
7137
7138 if (vrf_name) {
7139 bool ospf_output = false;
7140
7141 use_vrf = 1;
7142
7143 if (all_vrf) {
7144 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
7145 if (!ospf->oi_running)
7146 continue;
7147 ospf_output = true;
7148 ret = show_ip_ospf_database_common(
7149 vty, ospf, idx_vrf ? 2 : 0, argc, argv,
7150 use_vrf, json, uj);
7151 }
7152
7153 if (!ospf_output)
7154 vty_out(vty, "%% OSPF is not enabled\n");
7155 } else {
7156 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
7157 if (ospf == NULL || !ospf->oi_running) {
7158 vty_out(vty,
7159 "%% OSPF is not enabled in vrf %s\n",
7160 vrf_name);
7161 return CMD_SUCCESS;
7162 }
7163 ret = (show_ip_ospf_database_common(
7164 vty, ospf, idx_vrf ? 2 : 0, argc, argv, use_vrf,
7165 json, uj));
7166 }
7167 } else {
7168 /* Display default ospf (instance 0) info */
7169 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
7170 if (ospf == NULL || !ospf->oi_running) {
7171 vty_out(vty, "%% OSPF is not enabled in vrf default\n");
7172 return CMD_SUCCESS;
7173 }
7174
7175 ret = show_ip_ospf_database_common(vty, ospf, 0, argc, argv,
7176 use_vrf, json, uj);
7177 }
7178
7179 if (uj) {
7180 vty_out(vty, "%s\n", json_object_to_json_string(json));
7181 json_object_free(json);
7182 }
7183
7184 return ret;
7185 }
7186
7187 ALIAS (show_ip_ospf_database_max,
7188 show_ip_ospf_database_cmd,
7189 "show ip ospf [vrf <NAME|all>] database [<asbr-summary|external|network|router|summary|nssa-external|opaque-link|opaque-area|opaque-as> [A.B.C.D [<self-originate|adv-router A.B.C.D>]]] [json]",
7190 SHOW_STR
7191 IP_STR
7192 "OSPF information\n"
7193 VRF_CMD_HELP_STR
7194 "All VRFs\n"
7195 "Database summary\n"
7196 OSPF_LSA_TYPES_DESC
7197 "Link State ID (as an IP address)\n"
7198 "Self-originated link states\n"
7199 "Advertising Router link states\n"
7200 "Advertising Router (as an IP address)\n"
7201 JSON_STR)
7202
7203 DEFUN (show_ip_ospf_instance_database_max,
7204 show_ip_ospf_instance_database_max_cmd,
7205 "show ip ospf (1-65535) database <max-age|self-originate> [json]",
7206 SHOW_STR
7207 IP_STR
7208 "OSPF information\n"
7209 "Instance ID\n"
7210 "Database summary\n"
7211 "LSAs in MaxAge list\n"
7212 "Self-originated link states\n"
7213 JSON_STR)
7214 {
7215 int idx_number = 3;
7216 struct ospf *ospf;
7217 unsigned short instance = 0;
7218 bool uj = use_json(argc, argv);
7219 json_object *json = NULL;
7220
7221 if (uj)
7222 json = json_object_new_object();
7223
7224 instance = strtoul(argv[idx_number]->arg, NULL, 10);
7225 if (instance != ospf_instance)
7226 return CMD_NOT_MY_INSTANCE;
7227
7228 ospf = ospf_lookup_instance(instance);
7229 if (!ospf || !ospf->oi_running)
7230 return CMD_SUCCESS;
7231
7232 show_ip_ospf_database_common(vty, ospf, 1, argc, argv, 0, json, uj);
7233
7234 if (uj)
7235 vty_json(vty, json);
7236
7237 return CMD_SUCCESS;
7238 }
7239
7240 ALIAS (show_ip_ospf_instance_database_max,
7241 show_ip_ospf_instance_database_cmd,
7242 "show ip ospf (1-65535) database [<asbr-summary|external|network|router|summary|nssa-external|opaque-link|opaque-area|opaque-as> [A.B.C.D [<self-originate|adv-router A.B.C.D>]]] [json]",
7243 SHOW_STR
7244 IP_STR
7245 "OSPF information\n"
7246 "Instance ID\n"
7247 "Database summary\n"
7248 OSPF_LSA_TYPES_DESC
7249 "Link State ID (as an IP address)\n"
7250 "Self-originated link states\n"
7251 "Advertising Router link states\n"
7252 "Advertising Router (as an IP address)\n"
7253 JSON_STR)
7254
7255 static int show_ip_ospf_database_type_adv_router_common(struct vty *vty,
7256 struct ospf *ospf,
7257 int arg_base, int argc,
7258 struct cmd_token **argv,
7259 uint8_t use_vrf,
7260 json_object *json,
7261 bool uj)
7262 {
7263 int idx_type = 4;
7264 int type, ret;
7265 struct in_addr adv_router;
7266 json_object *json_vrf = NULL;
7267
7268 if (uj) {
7269 if (use_vrf)
7270 json_vrf = json_object_new_object();
7271 else
7272 json_vrf = json;
7273 }
7274
7275 if (ospf->instance) {
7276 if (uj)
7277 json_object_int_add(json, "ospfInstance",
7278 ospf->instance);
7279 else
7280 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
7281 }
7282
7283 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
7284
7285 /* Show Router ID. */
7286 if (uj) {
7287 json_object_string_addf(json_vrf, "routerId", "%pI4",
7288 &ospf->router_id);
7289 } else {
7290 vty_out(vty, "\n OSPF Router with ID (%pI4)\n\n",
7291 &ospf->router_id);
7292 }
7293
7294 /* Set database type to show. */
7295 if (strncmp(argv[arg_base + idx_type]->text, "r", 1) == 0)
7296 type = OSPF_ROUTER_LSA;
7297 else if (strncmp(argv[arg_base + idx_type]->text, "ne", 2) == 0)
7298 type = OSPF_NETWORK_LSA;
7299 else if (strncmp(argv[arg_base + idx_type]->text, "ns", 2) == 0)
7300 type = OSPF_AS_NSSA_LSA;
7301 else if (strncmp(argv[arg_base + idx_type]->text, "s", 1) == 0)
7302 type = OSPF_SUMMARY_LSA;
7303 else if (strncmp(argv[arg_base + idx_type]->text, "a", 1) == 0)
7304 type = OSPF_ASBR_SUMMARY_LSA;
7305 else if (strncmp(argv[arg_base + idx_type]->text, "e", 1) == 0)
7306 type = OSPF_AS_EXTERNAL_LSA;
7307 else if (strncmp(argv[arg_base + idx_type]->text, "opaque-l", 8) == 0)
7308 type = OSPF_OPAQUE_LINK_LSA;
7309 else if (strncmp(argv[arg_base + idx_type]->text, "opaque-ar", 9) == 0)
7310 type = OSPF_OPAQUE_AREA_LSA;
7311 else if (strncmp(argv[arg_base + idx_type]->text, "opaque-as", 9) == 0)
7312 type = OSPF_OPAQUE_AS_LSA;
7313 else
7314 return CMD_WARNING;
7315
7316 /* `show ip ospf database LSA adv-router ADV_ROUTER'. */
7317 if (strncmp(argv[arg_base + 5]->text, "s", 1) == 0)
7318 adv_router = ospf->router_id;
7319 else {
7320 ret = inet_aton(argv[arg_base + 6]->arg, &adv_router);
7321 if (!ret)
7322 return CMD_WARNING;
7323 }
7324
7325 show_lsa_detail_adv_router(vty, ospf, type, &adv_router, json_vrf);
7326
7327 if (json) {
7328 if (use_vrf)
7329 json_object_object_add(json, ospf_get_name(ospf),
7330 json_vrf);
7331 }
7332
7333 return CMD_SUCCESS;
7334 }
7335
7336 DEFUN (show_ip_ospf_database_type_adv_router,
7337 show_ip_ospf_database_type_adv_router_cmd,
7338 "show ip ospf [vrf <NAME|all>] database <asbr-summary|external|network|router|summary|nssa-external|opaque-link|opaque-area|opaque-as> <adv-router A.B.C.D|self-originate> [json]",
7339 SHOW_STR
7340 IP_STR
7341 "OSPF information\n"
7342 VRF_CMD_HELP_STR
7343 "All VRFs\n"
7344 "Database summary\n"
7345 OSPF_LSA_TYPES_DESC
7346 "Advertising Router link states\n"
7347 "Advertising Router (as an IP address)\n"
7348 "Self-originated link states\n"
7349 JSON_STR)
7350 {
7351 struct ospf *ospf = NULL;
7352 struct listnode *node = NULL;
7353 char *vrf_name = NULL;
7354 bool all_vrf = false;
7355 int ret = CMD_SUCCESS;
7356 int inst = 0;
7357 int idx_vrf = 0;
7358 uint8_t use_vrf = 0;
7359 bool uj = use_json(argc, argv);
7360 json_object *json = NULL;
7361
7362 if (uj)
7363 json = json_object_new_object();
7364
7365 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
7366
7367 if (vrf_name) {
7368 bool ospf_output = false;
7369
7370 use_vrf = 1;
7371
7372 if (all_vrf) {
7373 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
7374 if (!ospf->oi_running)
7375 continue;
7376 ospf_output = true;
7377 ret = show_ip_ospf_database_type_adv_router_common(
7378 vty, ospf, 2, argc, argv, use_vrf, json,
7379 uj);
7380 }
7381 if (!ospf_output)
7382 vty_out(vty, "%% OSPF is not enabled\n");
7383 } else {
7384 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
7385 if ((ospf == NULL) || !ospf->oi_running) {
7386 vty_out(vty,
7387 "%% OSPF is not enabled in vrf %s\n",
7388 vrf_name);
7389 return CMD_SUCCESS;
7390 }
7391
7392 ret = show_ip_ospf_database_type_adv_router_common(
7393 vty, ospf, 2, argc, argv, use_vrf, json, uj);
7394 }
7395 } else {
7396 /* Display default ospf (instance 0) info */
7397 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
7398 if (ospf == NULL || !ospf->oi_running) {
7399 vty_out(vty, "%% OSPF is not enabled on vrf default\n");
7400 return CMD_SUCCESS;
7401 }
7402
7403 ret = show_ip_ospf_database_type_adv_router_common(
7404 vty, ospf, 0, argc, argv, use_vrf, json, uj);
7405 }
7406
7407 if (uj) {
7408 vty_out(vty, "%s\n", json_object_to_json_string(json));
7409 json_object_free(json);
7410 }
7411
7412 return ret;
7413 }
7414
7415 DEFUN (show_ip_ospf_instance_database_type_adv_router,
7416 show_ip_ospf_instance_database_type_adv_router_cmd,
7417 "show ip ospf (1-65535) database <asbr-summary|external|network|router|summary|nssa-external|opaque-link|opaque-area|opaque-as> <adv-router A.B.C.D|self-originate> [json]",
7418 SHOW_STR
7419 IP_STR
7420 "OSPF information\n"
7421 "Instance ID\n"
7422 "Database summary\n"
7423 OSPF_LSA_TYPES_DESC
7424 "Advertising Router link states\n"
7425 "Advertising Router (as an IP address)\n"
7426 "Self-originated link states\n"
7427 JSON_STR)
7428 {
7429 int idx_number = 3;
7430 struct ospf *ospf;
7431 unsigned short instance = 0;
7432 bool uj = use_json(argc, argv);
7433 json_object *json = NULL;
7434
7435 if (uj)
7436 json = json_object_new_object();
7437
7438 instance = strtoul(argv[idx_number]->arg, NULL, 10);
7439 if (instance != ospf_instance)
7440 return CMD_NOT_MY_INSTANCE;
7441
7442 ospf = ospf_lookup_instance(instance);
7443 if (!ospf || !ospf->oi_running)
7444 return CMD_SUCCESS;
7445
7446 show_ip_ospf_database_type_adv_router_common(vty, ospf, 1, argc, argv,
7447 0, json, uj);
7448
7449 if (uj)
7450 vty_json(vty, json);
7451
7452 return CMD_SUCCESS;
7453 }
7454
7455 DEFUN (ip_ospf_authentication_args,
7456 ip_ospf_authentication_args_addr_cmd,
7457 "ip ospf authentication <null|message-digest> [A.B.C.D]",
7458 "IP Information\n"
7459 "OSPF interface commands\n"
7460 "Enable authentication on this interface\n"
7461 "Use null authentication\n"
7462 "Use message-digest authentication\n"
7463 "Address of interface\n")
7464 {
7465 VTY_DECLVAR_CONTEXT(interface, ifp);
7466 int idx_encryption = 3;
7467 int idx_ipv4 = 4;
7468 struct in_addr addr;
7469 int ret;
7470 struct ospf_if_params *params;
7471
7472 params = IF_DEF_PARAMS(ifp);
7473
7474 if (argc == 5) {
7475 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
7476 if (!ret) {
7477 vty_out(vty,
7478 "Please specify interface address by A.B.C.D\n");
7479 return CMD_WARNING_CONFIG_FAILED;
7480 }
7481
7482 params = ospf_get_if_params(ifp, addr);
7483 ospf_if_update_params(ifp, addr);
7484 }
7485
7486 /* Handle null authentication */
7487 if (argv[idx_encryption]->arg[0] == 'n') {
7488 SET_IF_PARAM(params, auth_type);
7489 params->auth_type = OSPF_AUTH_NULL;
7490 return CMD_SUCCESS;
7491 }
7492
7493 /* Handle message-digest authentication */
7494 if (argv[idx_encryption]->arg[0] == 'm') {
7495 SET_IF_PARAM(params, auth_type);
7496 params->auth_type = OSPF_AUTH_CRYPTOGRAPHIC;
7497 return CMD_SUCCESS;
7498 }
7499
7500 vty_out(vty, "You shouldn't get here!\n");
7501 return CMD_WARNING_CONFIG_FAILED;
7502 }
7503
7504 DEFUN (ip_ospf_authentication,
7505 ip_ospf_authentication_addr_cmd,
7506 "ip ospf authentication [A.B.C.D]",
7507 "IP Information\n"
7508 "OSPF interface commands\n"
7509 "Enable authentication on this interface\n"
7510 "Address of interface\n")
7511 {
7512 VTY_DECLVAR_CONTEXT(interface, ifp);
7513 int idx_ipv4 = 3;
7514 struct in_addr addr;
7515 int ret;
7516 struct ospf_if_params *params;
7517
7518 params = IF_DEF_PARAMS(ifp);
7519
7520 if (argc == 4) {
7521 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
7522 if (!ret) {
7523 vty_out(vty,
7524 "Please specify interface address by A.B.C.D\n");
7525 return CMD_WARNING_CONFIG_FAILED;
7526 }
7527
7528 params = ospf_get_if_params(ifp, addr);
7529 ospf_if_update_params(ifp, addr);
7530 }
7531
7532 SET_IF_PARAM(params, auth_type);
7533 params->auth_type = OSPF_AUTH_SIMPLE;
7534
7535 return CMD_SUCCESS;
7536 }
7537
7538 DEFUN (no_ip_ospf_authentication_args,
7539 no_ip_ospf_authentication_args_addr_cmd,
7540 "no ip ospf authentication <null|message-digest> [A.B.C.D]",
7541 NO_STR
7542 "IP Information\n"
7543 "OSPF interface commands\n"
7544 "Enable authentication on this interface\n"
7545 "Use null authentication\n"
7546 "Use message-digest authentication\n"
7547 "Address of interface\n")
7548 {
7549 VTY_DECLVAR_CONTEXT(interface, ifp);
7550 int idx_encryption = 4;
7551 int idx_ipv4 = 5;
7552 struct in_addr addr;
7553 int ret;
7554 struct ospf_if_params *params;
7555 struct route_node *rn;
7556 int auth_type;
7557
7558 params = IF_DEF_PARAMS(ifp);
7559
7560 if (argc == 6) {
7561 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
7562 if (!ret) {
7563 vty_out(vty,
7564 "Please specify interface address by A.B.C.D\n");
7565 return CMD_WARNING_CONFIG_FAILED;
7566 }
7567
7568 params = ospf_lookup_if_params(ifp, addr);
7569 if (params == NULL) {
7570 vty_out(vty, "Ip Address specified is unknown\n");
7571 return CMD_WARNING_CONFIG_FAILED;
7572 }
7573 params->auth_type = OSPF_AUTH_NOTSET;
7574 UNSET_IF_PARAM(params, auth_type);
7575 if (params != IF_DEF_PARAMS(ifp)) {
7576 ospf_free_if_params(ifp, addr);
7577 ospf_if_update_params(ifp, addr);
7578 }
7579 } else {
7580 if (argv[idx_encryption]->arg[0] == 'n') {
7581 auth_type = OSPF_AUTH_NULL;
7582 } else if (argv[idx_encryption]->arg[0] == 'm') {
7583 auth_type = OSPF_AUTH_CRYPTOGRAPHIC;
7584 } else {
7585 vty_out(vty, "Unexpected input encountered\n");
7586 return CMD_WARNING_CONFIG_FAILED;
7587 }
7588 /*
7589 * Here we have a case where the user has entered
7590 * 'no ip ospf authentication (null | message_digest )'
7591 * we need to find if we have any ip addresses underneath it
7592 * that
7593 * correspond to the associated type.
7594 */
7595 if (params->auth_type == auth_type) {
7596 params->auth_type = OSPF_AUTH_NOTSET;
7597 UNSET_IF_PARAM(params, auth_type);
7598 }
7599
7600 for (rn = route_top(IF_OIFS_PARAMS(ifp)); rn;
7601 rn = route_next(rn)) {
7602 if ((params = rn->info)) {
7603 if (params->auth_type == auth_type) {
7604 params->auth_type = OSPF_AUTH_NOTSET;
7605 UNSET_IF_PARAM(params, auth_type);
7606 if (params != IF_DEF_PARAMS(ifp)) {
7607 ospf_free_if_params(
7608 ifp, rn->p.u.prefix4);
7609 ospf_if_update_params(
7610 ifp, rn->p.u.prefix4);
7611 }
7612 }
7613 }
7614 }
7615 }
7616
7617 return CMD_SUCCESS;
7618 }
7619
7620 DEFUN (no_ip_ospf_authentication,
7621 no_ip_ospf_authentication_addr_cmd,
7622 "no ip ospf authentication [A.B.C.D]",
7623 NO_STR
7624 "IP Information\n"
7625 "OSPF interface commands\n"
7626 "Enable authentication on this interface\n"
7627 "Address of interface\n")
7628 {
7629 VTY_DECLVAR_CONTEXT(interface, ifp);
7630 int idx_ipv4 = 4;
7631 struct in_addr addr;
7632 int ret;
7633 struct ospf_if_params *params;
7634 struct route_node *rn;
7635
7636 params = IF_DEF_PARAMS(ifp);
7637
7638 if (argc == 5) {
7639 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
7640 if (!ret) {
7641 vty_out(vty,
7642 "Please specify interface address by A.B.C.D\n");
7643 return CMD_WARNING_CONFIG_FAILED;
7644 }
7645
7646 params = ospf_lookup_if_params(ifp, addr);
7647 if (params == NULL) {
7648 vty_out(vty, "Ip Address specified is unknown\n");
7649 return CMD_WARNING_CONFIG_FAILED;
7650 }
7651
7652 params->auth_type = OSPF_AUTH_NOTSET;
7653 UNSET_IF_PARAM(params, auth_type);
7654 if (params != IF_DEF_PARAMS(ifp)) {
7655 ospf_free_if_params(ifp, addr);
7656 ospf_if_update_params(ifp, addr);
7657 }
7658 } else {
7659 /*
7660 * When a user enters 'no ip ospf authentication'
7661 * We should remove all authentication types from
7662 * the interface.
7663 */
7664 if ((params->auth_type == OSPF_AUTH_NULL)
7665 || (params->auth_type == OSPF_AUTH_CRYPTOGRAPHIC)
7666 || (params->auth_type == OSPF_AUTH_SIMPLE)) {
7667 params->auth_type = OSPF_AUTH_NOTSET;
7668 UNSET_IF_PARAM(params, auth_type);
7669 }
7670
7671 for (rn = route_top(IF_OIFS_PARAMS(ifp)); rn;
7672 rn = route_next(rn)) {
7673 if ((params = rn->info)) {
7674
7675 if ((params->auth_type == OSPF_AUTH_NULL)
7676 || (params->auth_type
7677 == OSPF_AUTH_CRYPTOGRAPHIC)
7678 || (params->auth_type
7679 == OSPF_AUTH_SIMPLE)) {
7680 params->auth_type = OSPF_AUTH_NOTSET;
7681 UNSET_IF_PARAM(params, auth_type);
7682 if (params != IF_DEF_PARAMS(ifp)) {
7683 ospf_free_if_params(
7684 ifp, rn->p.u.prefix4);
7685 ospf_if_update_params(
7686 ifp, rn->p.u.prefix4);
7687 }
7688 }
7689 }
7690 }
7691 }
7692
7693 return CMD_SUCCESS;
7694 }
7695
7696
7697 DEFUN (ip_ospf_authentication_key,
7698 ip_ospf_authentication_key_addr_cmd,
7699 "ip ospf authentication-key AUTH_KEY [A.B.C.D]",
7700 "IP Information\n"
7701 "OSPF interface commands\n"
7702 "Authentication password (key)\n"
7703 "The OSPF password (key)\n"
7704 "Address of interface\n")
7705 {
7706 VTY_DECLVAR_CONTEXT(interface, ifp);
7707 int idx = 0;
7708 struct in_addr addr;
7709 struct ospf_if_params *params;
7710
7711 params = IF_DEF_PARAMS(ifp);
7712
7713 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7714 if (!inet_aton(argv[idx]->arg, &addr)) {
7715 vty_out(vty,
7716 "Please specify interface address by A.B.C.D\n");
7717 return CMD_WARNING_CONFIG_FAILED;
7718 }
7719
7720 params = ospf_get_if_params(ifp, addr);
7721 ospf_if_update_params(ifp, addr);
7722 }
7723
7724 strlcpy((char *)params->auth_simple, argv[3]->arg,
7725 sizeof(params->auth_simple));
7726 SET_IF_PARAM(params, auth_simple);
7727
7728 return CMD_SUCCESS;
7729 }
7730
7731 DEFUN_HIDDEN (ospf_authentication_key,
7732 ospf_authentication_key_cmd,
7733 "ospf authentication-key AUTH_KEY [A.B.C.D]",
7734 "OSPF interface commands\n"
7735 VLINK_HELPSTR_AUTH_SIMPLE
7736 "Address of interface\n")
7737 {
7738 return ip_ospf_authentication_key(self, vty, argc, argv);
7739 }
7740
7741 DEFUN (no_ip_ospf_authentication_key,
7742 no_ip_ospf_authentication_key_authkey_addr_cmd,
7743 "no ip ospf authentication-key [AUTH_KEY [A.B.C.D]]",
7744 NO_STR
7745 "IP Information\n"
7746 "OSPF interface commands\n"
7747 VLINK_HELPSTR_AUTH_SIMPLE
7748 "Address of interface\n")
7749 {
7750 VTY_DECLVAR_CONTEXT(interface, ifp);
7751 int idx = 0;
7752 struct in_addr addr;
7753 struct ospf_if_params *params;
7754 params = IF_DEF_PARAMS(ifp);
7755
7756 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7757 if (!inet_aton(argv[idx]->arg, &addr)) {
7758 vty_out(vty,
7759 "Please specify interface address by A.B.C.D\n");
7760 return CMD_WARNING_CONFIG_FAILED;
7761 }
7762
7763 params = ospf_lookup_if_params(ifp, addr);
7764 if (params == NULL)
7765 return CMD_SUCCESS;
7766 }
7767
7768 memset(params->auth_simple, 0, OSPF_AUTH_SIMPLE_SIZE);
7769 UNSET_IF_PARAM(params, auth_simple);
7770
7771 if (params != IF_DEF_PARAMS(ifp)) {
7772 ospf_free_if_params(ifp, addr);
7773 ospf_if_update_params(ifp, addr);
7774 }
7775
7776 return CMD_SUCCESS;
7777 }
7778
7779 DEFUN_HIDDEN (no_ospf_authentication_key,
7780 no_ospf_authentication_key_authkey_addr_cmd,
7781 "no ospf authentication-key [AUTH_KEY [A.B.C.D]]",
7782 NO_STR
7783 "OSPF interface commands\n"
7784 VLINK_HELPSTR_AUTH_SIMPLE
7785 "Address of interface\n")
7786 {
7787 return no_ip_ospf_authentication_key(self, vty, argc, argv);
7788 }
7789
7790 DEFUN (ip_ospf_message_digest_key,
7791 ip_ospf_message_digest_key_cmd,
7792 "ip ospf message-digest-key (1-255) md5 KEY [A.B.C.D]",
7793 "IP Information\n"
7794 "OSPF interface commands\n"
7795 "Message digest authentication password (key)\n"
7796 "Key ID\n"
7797 "Use MD5 algorithm\n"
7798 "The OSPF password (key)\n"
7799 "Address of interface\n")
7800 {
7801 VTY_DECLVAR_CONTEXT(interface, ifp);
7802 struct crypt_key *ck;
7803 uint8_t key_id;
7804 struct in_addr addr;
7805 struct ospf_if_params *params;
7806
7807 params = IF_DEF_PARAMS(ifp);
7808 int idx = 0;
7809
7810 argv_find(argv, argc, "(1-255)", &idx);
7811 char *keyid = argv[idx]->arg;
7812 argv_find(argv, argc, "KEY", &idx);
7813 char *cryptkey = argv[idx]->arg;
7814
7815 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7816 if (!inet_aton(argv[idx]->arg, &addr)) {
7817 vty_out(vty,
7818 "Please specify interface address by A.B.C.D\n");
7819 return CMD_WARNING_CONFIG_FAILED;
7820 }
7821
7822 params = ospf_get_if_params(ifp, addr);
7823 ospf_if_update_params(ifp, addr);
7824 }
7825
7826 key_id = strtol(keyid, NULL, 10);
7827
7828 /* Remove existing key, if any */
7829 ospf_crypt_key_delete(params->auth_crypt, key_id);
7830
7831 ck = ospf_crypt_key_new();
7832 ck->key_id = (uint8_t)key_id;
7833 strlcpy((char *)ck->auth_key, cryptkey, sizeof(ck->auth_key));
7834
7835 ospf_crypt_key_add(params->auth_crypt, ck);
7836 SET_IF_PARAM(params, auth_crypt);
7837
7838 return CMD_SUCCESS;
7839 }
7840
7841 DEFUN_HIDDEN (ospf_message_digest_key,
7842 ospf_message_digest_key_cmd,
7843 "ospf message-digest-key (1-255) md5 KEY [A.B.C.D]",
7844 "OSPF interface commands\n"
7845 "Message digest authentication password (key)\n"
7846 "Key ID\n"
7847 "Use MD5 algorithm\n"
7848 "The OSPF password (key)\n"
7849 "Address of interface\n")
7850 {
7851 return ip_ospf_message_digest_key(self, vty, argc, argv);
7852 }
7853
7854 DEFUN (no_ip_ospf_message_digest_key,
7855 no_ip_ospf_message_digest_key_cmd,
7856 "no ip ospf message-digest-key (1-255) [md5 KEY] [A.B.C.D]",
7857 NO_STR
7858 "IP Information\n"
7859 "OSPF interface commands\n"
7860 "Message digest authentication password (key)\n"
7861 "Key ID\n"
7862 "Use MD5 algorithm\n"
7863 "The OSPF password (key)\n"
7864 "Address of interface\n")
7865 {
7866 VTY_DECLVAR_CONTEXT(interface, ifp);
7867 int idx = 0;
7868 struct crypt_key *ck;
7869 int key_id;
7870 struct in_addr addr;
7871 struct ospf_if_params *params;
7872 params = IF_DEF_PARAMS(ifp);
7873
7874 argv_find(argv, argc, "(1-255)", &idx);
7875 char *keyid = argv[idx]->arg;
7876
7877 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7878 if (!inet_aton(argv[idx]->arg, &addr)) {
7879 vty_out(vty,
7880 "Please specify interface address by A.B.C.D\n");
7881 return CMD_WARNING_CONFIG_FAILED;
7882 }
7883
7884 params = ospf_lookup_if_params(ifp, addr);
7885 if (params == NULL)
7886 return CMD_SUCCESS;
7887 }
7888
7889 key_id = strtol(keyid, NULL, 10);
7890 ck = ospf_crypt_key_lookup(params->auth_crypt, key_id);
7891 if (ck == NULL) {
7892 vty_out(vty, "OSPF: Key %d does not exist\n", key_id);
7893 return CMD_WARNING_CONFIG_FAILED;
7894 }
7895
7896 ospf_crypt_key_delete(params->auth_crypt, key_id);
7897
7898 if (params != IF_DEF_PARAMS(ifp)) {
7899 ospf_free_if_params(ifp, addr);
7900 ospf_if_update_params(ifp, addr);
7901 }
7902
7903 return CMD_SUCCESS;
7904 }
7905
7906 DEFUN_HIDDEN (no_ospf_message_digest_key,
7907 no_ospf_message_digest_key_cmd,
7908 "no ospf message-digest-key (1-255) [md5 KEY] [A.B.C.D]",
7909 NO_STR
7910 "OSPF interface commands\n"
7911 "Message digest authentication password (key)\n"
7912 "Key ID\n"
7913 "Use MD5 algorithm\n"
7914 "The OSPF password (key)\n"
7915 "Address of interface\n")
7916 {
7917 return no_ip_ospf_message_digest_key(self, vty, argc, argv);
7918 }
7919
7920 DEFUN (ip_ospf_cost,
7921 ip_ospf_cost_cmd,
7922 "ip ospf cost (1-65535) [A.B.C.D]",
7923 "IP Information\n"
7924 "OSPF interface commands\n"
7925 "Interface cost\n"
7926 "Cost\n"
7927 "Address of interface\n")
7928 {
7929 VTY_DECLVAR_CONTEXT(interface, ifp);
7930 int idx = 0;
7931 uint32_t cost = OSPF_OUTPUT_COST_DEFAULT;
7932 struct in_addr addr;
7933 struct ospf_if_params *params;
7934 params = IF_DEF_PARAMS(ifp);
7935
7936 // get arguments
7937 char *coststr = NULL, *ifaddr = NULL;
7938
7939 argv_find(argv, argc, "(1-65535)", &idx);
7940 coststr = argv[idx]->arg;
7941 cost = strtol(coststr, NULL, 10);
7942
7943 ifaddr = argv_find(argv, argc, "A.B.C.D", &idx) ? argv[idx]->arg : NULL;
7944 if (ifaddr) {
7945 if (!inet_aton(ifaddr, &addr)) {
7946 vty_out(vty,
7947 "Please specify interface address by A.B.C.D\n");
7948 return CMD_WARNING_CONFIG_FAILED;
7949 }
7950
7951 params = ospf_get_if_params(ifp, addr);
7952 ospf_if_update_params(ifp, addr);
7953 }
7954
7955 SET_IF_PARAM(params, output_cost_cmd);
7956 params->output_cost_cmd = cost;
7957
7958 ospf_if_recalculate_output_cost(ifp);
7959
7960 return CMD_SUCCESS;
7961 }
7962
7963 DEFUN_HIDDEN (ospf_cost,
7964 ospf_cost_cmd,
7965 "ospf cost (1-65535) [A.B.C.D]",
7966 "OSPF interface commands\n"
7967 "Interface cost\n"
7968 "Cost\n"
7969 "Address of interface\n")
7970 {
7971 return ip_ospf_cost(self, vty, argc, argv);
7972 }
7973
7974 DEFUN (no_ip_ospf_cost,
7975 no_ip_ospf_cost_cmd,
7976 "no ip ospf cost [(1-65535)] [A.B.C.D]",
7977 NO_STR
7978 "IP Information\n"
7979 "OSPF interface commands\n"
7980 "Interface cost\n"
7981 "Cost\n"
7982 "Address of interface\n")
7983 {
7984 VTY_DECLVAR_CONTEXT(interface, ifp);
7985 int idx = 0;
7986 struct in_addr addr;
7987 struct ospf_if_params *params;
7988
7989 params = IF_DEF_PARAMS(ifp);
7990
7991 // get arguments
7992 char *ifaddr = NULL;
7993 ifaddr = argv_find(argv, argc, "A.B.C.D", &idx) ? argv[idx]->arg : NULL;
7994
7995 /* According to the semantics we are mimicking "no ip ospf cost N" is
7996 * always treated as "no ip ospf cost" regardless of the actual value
7997 * of N already configured for the interface. Thus ignore cost. */
7998
7999 if (ifaddr) {
8000 if (!inet_aton(ifaddr, &addr)) {
8001 vty_out(vty,
8002 "Please specify interface address by A.B.C.D\n");
8003 return CMD_WARNING_CONFIG_FAILED;
8004 }
8005
8006 params = ospf_lookup_if_params(ifp, addr);
8007 if (params == NULL)
8008 return CMD_SUCCESS;
8009 }
8010
8011 UNSET_IF_PARAM(params, output_cost_cmd);
8012
8013 if (params != IF_DEF_PARAMS(ifp)) {
8014 ospf_free_if_params(ifp, addr);
8015 ospf_if_update_params(ifp, addr);
8016 }
8017
8018 ospf_if_recalculate_output_cost(ifp);
8019
8020 return CMD_SUCCESS;
8021 }
8022
8023 DEFUN_HIDDEN (no_ospf_cost,
8024 no_ospf_cost_cmd,
8025 "no ospf cost [(1-65535)] [A.B.C.D]",
8026 NO_STR
8027 "OSPF interface commands\n"
8028 "Interface cost\n"
8029 "Cost\n"
8030 "Address of interface\n")
8031 {
8032 return no_ip_ospf_cost(self, vty, argc, argv);
8033 }
8034
8035 static void ospf_nbr_timer_update(struct ospf_interface *oi)
8036 {
8037 struct route_node *rn;
8038 struct ospf_neighbor *nbr;
8039
8040 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn)) {
8041 nbr = rn->info;
8042
8043 if (!nbr)
8044 continue;
8045
8046 nbr->v_inactivity = OSPF_IF_PARAM(oi, v_wait);
8047 nbr->v_db_desc = OSPF_IF_PARAM(oi, retransmit_interval);
8048 nbr->v_ls_req = OSPF_IF_PARAM(oi, retransmit_interval);
8049 nbr->v_ls_upd = OSPF_IF_PARAM(oi, retransmit_interval);
8050 }
8051 }
8052
8053 static int ospf_vty_dead_interval_set(struct vty *vty, const char *interval_str,
8054 const char *nbr_str,
8055 const char *fast_hello_str)
8056 {
8057 VTY_DECLVAR_CONTEXT(interface, ifp);
8058 uint32_t seconds;
8059 uint8_t hellomult;
8060 struct in_addr addr;
8061 int ret;
8062 struct ospf_if_params *params;
8063 struct ospf_interface *oi;
8064 struct route_node *rn;
8065
8066 params = IF_DEF_PARAMS(ifp);
8067
8068 if (nbr_str) {
8069 ret = inet_aton(nbr_str, &addr);
8070 if (!ret) {
8071 vty_out(vty,
8072 "Please specify interface address by A.B.C.D\n");
8073 return CMD_WARNING_CONFIG_FAILED;
8074 }
8075
8076 params = ospf_get_if_params(ifp, addr);
8077 ospf_if_update_params(ifp, addr);
8078 }
8079
8080 if (interval_str) {
8081 seconds = strtoul(interval_str, NULL, 10);
8082
8083 /* reset fast_hello too, just to be sure */
8084 UNSET_IF_PARAM(params, fast_hello);
8085 params->fast_hello = OSPF_FAST_HELLO_DEFAULT;
8086 } else if (fast_hello_str) {
8087 hellomult = strtoul(fast_hello_str, NULL, 10);
8088 /* 1s dead-interval with sub-second hellos desired */
8089 seconds = OSPF_ROUTER_DEAD_INTERVAL_MINIMAL;
8090 SET_IF_PARAM(params, fast_hello);
8091 params->fast_hello = hellomult;
8092 } else {
8093 vty_out(vty,
8094 "Please specify dead-interval or hello-multiplier\n");
8095 return CMD_WARNING_CONFIG_FAILED;
8096 }
8097
8098 SET_IF_PARAM(params, v_wait);
8099 params->v_wait = seconds;
8100 params->is_v_wait_set = true;
8101
8102 /* Update timer values in neighbor structure. */
8103 if (nbr_str) {
8104 struct ospf *ospf = NULL;
8105
8106 ospf = ifp->vrf->info;
8107 if (ospf) {
8108 oi = ospf_if_lookup_by_local_addr(ospf, ifp, addr);
8109 if (oi)
8110 ospf_nbr_timer_update(oi);
8111 }
8112 } else {
8113 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn))
8114 if ((oi = rn->info))
8115 ospf_nbr_timer_update(oi);
8116 }
8117
8118 return CMD_SUCCESS;
8119 }
8120
8121 DEFUN (ip_ospf_dead_interval,
8122 ip_ospf_dead_interval_cmd,
8123 "ip ospf dead-interval (1-65535) [A.B.C.D]",
8124 "IP Information\n"
8125 "OSPF interface commands\n"
8126 "Interval time after which a neighbor is declared down\n"
8127 "Seconds\n"
8128 "Address of interface\n")
8129 {
8130 int idx = 0;
8131 char *interval = argv_find(argv, argc, "(1-65535)", &idx)
8132 ? argv[idx]->arg
8133 : NULL;
8134 char *ifaddr =
8135 argv_find(argv, argc, "A.B.C.D", &idx) ? argv[idx]->arg : NULL;
8136 return ospf_vty_dead_interval_set(vty, interval, ifaddr, NULL);
8137 }
8138
8139
8140 DEFUN_HIDDEN (ospf_dead_interval,
8141 ospf_dead_interval_cmd,
8142 "ospf dead-interval (1-65535) [A.B.C.D]",
8143 "OSPF interface commands\n"
8144 "Interval time after which a neighbor is declared down\n"
8145 "Seconds\n"
8146 "Address of interface\n")
8147 {
8148 return ip_ospf_dead_interval(self, vty, argc, argv);
8149 }
8150
8151 DEFUN (ip_ospf_dead_interval_minimal,
8152 ip_ospf_dead_interval_minimal_addr_cmd,
8153 "ip ospf dead-interval minimal hello-multiplier (1-10) [A.B.C.D]",
8154 "IP Information\n"
8155 "OSPF interface commands\n"
8156 "Interval time after which a neighbor is declared down\n"
8157 "Minimal 1s dead-interval with fast sub-second hellos\n"
8158 "Hello multiplier factor\n"
8159 "Number of Hellos to send each second\n"
8160 "Address of interface\n")
8161 {
8162 int idx_number = 5;
8163 int idx_ipv4 = 6;
8164 if (argc == 7)
8165 return ospf_vty_dead_interval_set(
8166 vty, NULL, argv[idx_ipv4]->arg, argv[idx_number]->arg);
8167 else
8168 return ospf_vty_dead_interval_set(vty, NULL, NULL,
8169 argv[idx_number]->arg);
8170 }
8171
8172 DEFUN (no_ip_ospf_dead_interval,
8173 no_ip_ospf_dead_interval_cmd,
8174 "no ip ospf dead-interval [<(1-65535)|minimal hello-multiplier (1-10)> [A.B.C.D]]",
8175 NO_STR
8176 "IP Information\n"
8177 "OSPF interface commands\n"
8178 "Interval time after which a neighbor is declared down\n"
8179 "Seconds\n"
8180 "Minimal 1s dead-interval with fast sub-second hellos\n"
8181 "Hello multiplier factor\n"
8182 "Number of Hellos to send each second\n"
8183 "Address of interface\n")
8184 {
8185 VTY_DECLVAR_CONTEXT(interface, ifp);
8186 int idx_ipv4 = argc - 1;
8187 struct in_addr addr = {.s_addr = 0L};
8188 int ret;
8189 struct ospf_if_params *params;
8190 struct ospf_interface *oi;
8191 struct route_node *rn;
8192
8193 params = IF_DEF_PARAMS(ifp);
8194
8195 if (argv[idx_ipv4]->type == IPV4_TKN) {
8196 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
8197 if (!ret) {
8198 vty_out(vty,
8199 "Please specify interface address by A.B.C.D\n");
8200 return CMD_WARNING_CONFIG_FAILED;
8201 }
8202
8203 params = ospf_lookup_if_params(ifp, addr);
8204 if (params == NULL)
8205 return CMD_SUCCESS;
8206 }
8207
8208 UNSET_IF_PARAM(params, v_wait);
8209 params->v_wait = OSPF_ROUTER_DEAD_INTERVAL_DEFAULT;
8210 params->is_v_wait_set = false;
8211
8212 UNSET_IF_PARAM(params, fast_hello);
8213 params->fast_hello = OSPF_FAST_HELLO_DEFAULT;
8214
8215 if (params != IF_DEF_PARAMS(ifp)) {
8216 ospf_free_if_params(ifp, addr);
8217 ospf_if_update_params(ifp, addr);
8218 }
8219
8220 /* Update timer values in neighbor structure. */
8221 if (argc == 1) {
8222 struct ospf *ospf = NULL;
8223
8224 ospf = ifp->vrf->info;
8225 if (ospf) {
8226 oi = ospf_if_lookup_by_local_addr(ospf, ifp, addr);
8227 if (oi)
8228 ospf_nbr_timer_update(oi);
8229 }
8230 } else {
8231 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn))
8232 if ((oi = rn->info))
8233 ospf_nbr_timer_update(oi);
8234 }
8235
8236 return CMD_SUCCESS;
8237 }
8238
8239 DEFUN_HIDDEN (no_ospf_dead_interval,
8240 no_ospf_dead_interval_cmd,
8241 "no ospf dead-interval [<(1-65535)|minimal hello-multiplier (1-10)> [A.B.C.D]]",
8242 NO_STR
8243 "OSPF interface commands\n"
8244 "Interval time after which a neighbor is declared down\n"
8245 "Seconds\n"
8246 "Minimal 1s dead-interval with fast sub-second hellos\n"
8247 "Hello multiplier factor\n"
8248 "Number of Hellos to send each second\n"
8249 "Address of interface\n")
8250 {
8251 return no_ip_ospf_dead_interval(self, vty, argc, argv);
8252 }
8253
8254 DEFUN (ip_ospf_hello_interval,
8255 ip_ospf_hello_interval_cmd,
8256 "ip ospf hello-interval (1-65535) [A.B.C.D]",
8257 "IP Information\n"
8258 "OSPF interface commands\n"
8259 "Time between HELLO packets\n"
8260 "Seconds\n"
8261 "Address of interface\n")
8262 {
8263 VTY_DECLVAR_CONTEXT(interface, ifp);
8264 int idx = 0;
8265 struct in_addr addr = {.s_addr = 0L};
8266 struct ospf_if_params *params;
8267 params = IF_DEF_PARAMS(ifp);
8268 uint32_t seconds = 0;
8269 bool is_addr = false;
8270 uint32_t old_interval = 0;
8271
8272 argv_find(argv, argc, "(1-65535)", &idx);
8273 seconds = strtol(argv[idx]->arg, NULL, 10);
8274
8275 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8276 if (!inet_aton(argv[idx]->arg, &addr)) {
8277 vty_out(vty,
8278 "Please specify interface address by A.B.C.D\n");
8279 return CMD_WARNING_CONFIG_FAILED;
8280 }
8281
8282 params = ospf_get_if_params(ifp, addr);
8283 ospf_if_update_params(ifp, addr);
8284 is_addr = true;
8285 }
8286
8287 old_interval = params->v_hello;
8288
8289 /* Return, if same interval is configured. */
8290 if (old_interval == seconds)
8291 return CMD_SUCCESS;
8292
8293 SET_IF_PARAM(params, v_hello);
8294 params->v_hello = seconds;
8295
8296 if (!params->is_v_wait_set) {
8297 SET_IF_PARAM(params, v_wait);
8298 /* As per RFC 4062
8299 * The router dead interval should
8300 * be some multiple of the HelloInterval (perhaps 4 times the
8301 * hello interval) and must be the same for all routers
8302 * attached to a common network.
8303 */
8304 params->v_wait = 4 * seconds;
8305 }
8306
8307 ospf_reset_hello_timer(ifp, addr, is_addr);
8308
8309 return CMD_SUCCESS;
8310 }
8311
8312 DEFUN_HIDDEN (ospf_hello_interval,
8313 ospf_hello_interval_cmd,
8314 "ospf hello-interval (1-65535) [A.B.C.D]",
8315 "OSPF interface commands\n"
8316 "Time between HELLO packets\n"
8317 "Seconds\n"
8318 "Address of interface\n")
8319 {
8320 return ip_ospf_hello_interval(self, vty, argc, argv);
8321 }
8322
8323 DEFUN (no_ip_ospf_hello_interval,
8324 no_ip_ospf_hello_interval_cmd,
8325 "no ip ospf hello-interval [(1-65535) [A.B.C.D]]",
8326 NO_STR
8327 "IP Information\n"
8328 "OSPF interface commands\n"
8329 "Time between HELLO packets\n" // ignored
8330 "Seconds\n"
8331 "Address of interface\n")
8332 {
8333 VTY_DECLVAR_CONTEXT(interface, ifp);
8334 int idx = 0;
8335 struct in_addr addr = {.s_addr = 0L};
8336 struct ospf_if_params *params;
8337 struct route_node *rn;
8338
8339 params = IF_DEF_PARAMS(ifp);
8340
8341 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8342 if (!inet_aton(argv[idx]->arg, &addr)) {
8343 vty_out(vty,
8344 "Please specify interface address by A.B.C.D\n");
8345 return CMD_WARNING_CONFIG_FAILED;
8346 }
8347
8348 params = ospf_lookup_if_params(ifp, addr);
8349 if (params == NULL)
8350 return CMD_SUCCESS;
8351 }
8352
8353 UNSET_IF_PARAM(params, v_hello);
8354 params->v_hello = OSPF_HELLO_INTERVAL_DEFAULT;
8355
8356 if (!params->is_v_wait_set) {
8357 UNSET_IF_PARAM(params, v_wait);
8358 params->v_wait = OSPF_ROUTER_DEAD_INTERVAL_DEFAULT;
8359 }
8360
8361 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
8362 struct ospf_interface *oi = rn->info;
8363
8364 if (!oi)
8365 continue;
8366
8367 oi->type = IF_DEF_PARAMS(ifp)->type;
8368 oi->ptp_dmvpn = IF_DEF_PARAMS(ifp)->ptp_dmvpn;
8369
8370 if (oi->state > ISM_Down) {
8371 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceDown);
8372 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceUp);
8373 }
8374 }
8375
8376 if (params != IF_DEF_PARAMS(ifp)) {
8377 ospf_free_if_params(ifp, addr);
8378 ospf_if_update_params(ifp, addr);
8379 }
8380
8381 return CMD_SUCCESS;
8382 }
8383
8384 DEFUN_HIDDEN (no_ospf_hello_interval,
8385 no_ospf_hello_interval_cmd,
8386 "no ospf hello-interval [(1-65535) [A.B.C.D]]",
8387 NO_STR
8388 "OSPF interface commands\n"
8389 "Time between HELLO packets\n" // ignored
8390 "Seconds\n"
8391 "Address of interface\n")
8392 {
8393 return no_ip_ospf_hello_interval(self, vty, argc, argv);
8394 }
8395
8396 DEFUN(ip_ospf_network, ip_ospf_network_cmd,
8397 "ip ospf network <broadcast|non-broadcast|point-to-multipoint|point-to-point [dmvpn]>",
8398 "IP Information\n"
8399 "OSPF interface commands\n"
8400 "Network type\n"
8401 "Specify OSPF broadcast multi-access network\n"
8402 "Specify OSPF NBMA network\n"
8403 "Specify OSPF point-to-multipoint network\n"
8404 "Specify OSPF point-to-point network\n"
8405 "Specify OSPF point-to-point DMVPN network\n")
8406 {
8407 VTY_DECLVAR_CONTEXT(interface, ifp);
8408 int idx = 0;
8409 int old_type = IF_DEF_PARAMS(ifp)->type;
8410 uint8_t old_ptp_dmvpn = IF_DEF_PARAMS(ifp)->ptp_dmvpn;
8411 struct route_node *rn;
8412
8413 if (old_type == OSPF_IFTYPE_LOOPBACK) {
8414 vty_out(vty,
8415 "This is a loopback interface. Can't set network type.\n");
8416 return CMD_WARNING_CONFIG_FAILED;
8417 }
8418
8419 IF_DEF_PARAMS(ifp)->ptp_dmvpn = 0;
8420
8421 if (argv_find(argv, argc, "broadcast", &idx))
8422 IF_DEF_PARAMS(ifp)->type = OSPF_IFTYPE_BROADCAST;
8423 else if (argv_find(argv, argc, "non-broadcast", &idx))
8424 IF_DEF_PARAMS(ifp)->type = OSPF_IFTYPE_NBMA;
8425 else if (argv_find(argv, argc, "point-to-multipoint", &idx))
8426 IF_DEF_PARAMS(ifp)->type = OSPF_IFTYPE_POINTOMULTIPOINT;
8427 else if (argv_find(argv, argc, "point-to-point", &idx)) {
8428 IF_DEF_PARAMS(ifp)->type = OSPF_IFTYPE_POINTOPOINT;
8429 if (argv_find(argv, argc, "dmvpn", &idx))
8430 IF_DEF_PARAMS(ifp)->ptp_dmvpn = 1;
8431 }
8432
8433 if (IF_DEF_PARAMS(ifp)->type == old_type
8434 && IF_DEF_PARAMS(ifp)->ptp_dmvpn == old_ptp_dmvpn)
8435 return CMD_SUCCESS;
8436
8437 SET_IF_PARAM(IF_DEF_PARAMS(ifp), type);
8438
8439 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
8440 struct ospf_interface *oi = rn->info;
8441
8442 if (!oi)
8443 continue;
8444
8445 oi->type = IF_DEF_PARAMS(ifp)->type;
8446
8447 if (oi->state > ISM_Down) {
8448 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceDown);
8449 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceUp);
8450 }
8451 }
8452
8453 return CMD_SUCCESS;
8454 }
8455
8456 DEFUN_HIDDEN (ospf_network,
8457 ospf_network_cmd,
8458 "ospf network <broadcast|non-broadcast|point-to-multipoint|point-to-point>",
8459 "OSPF interface commands\n"
8460 "Network type\n"
8461 "Specify OSPF broadcast multi-access network\n"
8462 "Specify OSPF NBMA network\n"
8463 "Specify OSPF point-to-multipoint network\n"
8464 "Specify OSPF point-to-point network\n")
8465 {
8466 return ip_ospf_network(self, vty, argc, argv);
8467 }
8468
8469 DEFUN (no_ip_ospf_network,
8470 no_ip_ospf_network_cmd,
8471 "no ip ospf network [<broadcast|non-broadcast|point-to-multipoint|point-to-point>]",
8472 NO_STR
8473 "IP Information\n"
8474 "OSPF interface commands\n"
8475 "Network type\n"
8476 "Specify OSPF broadcast multi-access network\n"
8477 "Specify OSPF NBMA network\n"
8478 "Specify OSPF point-to-multipoint network\n"
8479 "Specify OSPF point-to-point network\n")
8480 {
8481 VTY_DECLVAR_CONTEXT(interface, ifp);
8482 int old_type = IF_DEF_PARAMS(ifp)->type;
8483 struct route_node *rn;
8484
8485 IF_DEF_PARAMS(ifp)->type = ospf_default_iftype(ifp);
8486 IF_DEF_PARAMS(ifp)->ptp_dmvpn = 0;
8487
8488 if (IF_DEF_PARAMS(ifp)->type == old_type)
8489 return CMD_SUCCESS;
8490
8491 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
8492 struct ospf_interface *oi = rn->info;
8493
8494 if (!oi)
8495 continue;
8496
8497 oi->type = IF_DEF_PARAMS(ifp)->type;
8498
8499 if (oi->state > ISM_Down) {
8500 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceDown);
8501 OSPF_ISM_EVENT_EXECUTE(oi, ISM_InterfaceUp);
8502 }
8503 }
8504
8505 return CMD_SUCCESS;
8506 }
8507
8508 DEFUN_HIDDEN (no_ospf_network,
8509 no_ospf_network_cmd,
8510 "no ospf network [<broadcast|non-broadcast|point-to-multipoint|point-to-point>]",
8511 NO_STR
8512 "OSPF interface commands\n"
8513 "Network type\n"
8514 "Specify OSPF broadcast multi-access network\n"
8515 "Specify OSPF NBMA network\n"
8516 "Specify OSPF point-to-multipoint network\n"
8517 "Specify OSPF point-to-point network\n")
8518 {
8519 return no_ip_ospf_network(self, vty, argc, argv);
8520 }
8521
8522 DEFUN (ip_ospf_priority,
8523 ip_ospf_priority_cmd,
8524 "ip ospf priority (0-255) [A.B.C.D]",
8525 "IP Information\n"
8526 "OSPF interface commands\n"
8527 "Router priority\n"
8528 "Priority\n"
8529 "Address of interface\n")
8530 {
8531 VTY_DECLVAR_CONTEXT(interface, ifp);
8532 int idx = 0;
8533 long priority;
8534 struct route_node *rn;
8535 struct in_addr addr;
8536 struct ospf_if_params *params;
8537 params = IF_DEF_PARAMS(ifp);
8538
8539 argv_find(argv, argc, "(0-255)", &idx);
8540 priority = strtol(argv[idx]->arg, NULL, 10);
8541
8542 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8543 if (!inet_aton(argv[idx]->arg, &addr)) {
8544 vty_out(vty,
8545 "Please specify interface address by A.B.C.D\n");
8546 return CMD_WARNING_CONFIG_FAILED;
8547 }
8548
8549 params = ospf_get_if_params(ifp, addr);
8550 ospf_if_update_params(ifp, addr);
8551 }
8552
8553 SET_IF_PARAM(params, priority);
8554 params->priority = priority;
8555
8556 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
8557 struct ospf_interface *oi = rn->info;
8558
8559 if (!oi)
8560 continue;
8561
8562 if (PRIORITY(oi) != OSPF_IF_PARAM(oi, priority)) {
8563 PRIORITY(oi) = OSPF_IF_PARAM(oi, priority);
8564 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_NeighborChange);
8565 }
8566 }
8567
8568 return CMD_SUCCESS;
8569 }
8570
8571 DEFUN_HIDDEN (ospf_priority,
8572 ospf_priority_cmd,
8573 "ospf priority (0-255) [A.B.C.D]",
8574 "OSPF interface commands\n"
8575 "Router priority\n"
8576 "Priority\n"
8577 "Address of interface\n")
8578 {
8579 return ip_ospf_priority(self, vty, argc, argv);
8580 }
8581
8582 DEFUN (no_ip_ospf_priority,
8583 no_ip_ospf_priority_cmd,
8584 "no ip ospf priority [(0-255) [A.B.C.D]]",
8585 NO_STR
8586 "IP Information\n"
8587 "OSPF interface commands\n"
8588 "Router priority\n" // ignored
8589 "Priority\n"
8590 "Address of interface\n")
8591 {
8592 VTY_DECLVAR_CONTEXT(interface, ifp);
8593 int idx = 0;
8594 struct route_node *rn;
8595 struct in_addr addr;
8596 struct ospf_if_params *params;
8597
8598 params = IF_DEF_PARAMS(ifp);
8599
8600 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8601 if (!inet_aton(argv[idx]->arg, &addr)) {
8602 vty_out(vty,
8603 "Please specify interface address by A.B.C.D\n");
8604 return CMD_WARNING_CONFIG_FAILED;
8605 }
8606
8607 params = ospf_lookup_if_params(ifp, addr);
8608 if (params == NULL)
8609 return CMD_SUCCESS;
8610 }
8611
8612 UNSET_IF_PARAM(params, priority);
8613 params->priority = OSPF_ROUTER_PRIORITY_DEFAULT;
8614
8615 if (params != IF_DEF_PARAMS(ifp)) {
8616 ospf_free_if_params(ifp, addr);
8617 ospf_if_update_params(ifp, addr);
8618 }
8619
8620 for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
8621 struct ospf_interface *oi = rn->info;
8622
8623 if (!oi)
8624 continue;
8625
8626 if (PRIORITY(oi) != OSPF_IF_PARAM(oi, priority)) {
8627 PRIORITY(oi) = OSPF_IF_PARAM(oi, priority);
8628 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_NeighborChange);
8629 }
8630 }
8631
8632 return CMD_SUCCESS;
8633 }
8634
8635 DEFUN_HIDDEN (no_ospf_priority,
8636 no_ospf_priority_cmd,
8637 "no ospf priority [(0-255) [A.B.C.D]]",
8638 NO_STR
8639 "OSPF interface commands\n"
8640 "Router priority\n"
8641 "Priority\n"
8642 "Address of interface\n")
8643 {
8644 return no_ip_ospf_priority(self, vty, argc, argv);
8645 }
8646
8647 DEFUN (ip_ospf_retransmit_interval,
8648 ip_ospf_retransmit_interval_addr_cmd,
8649 "ip ospf retransmit-interval (1-65535) [A.B.C.D]",
8650 "IP Information\n"
8651 "OSPF interface commands\n"
8652 "Time between retransmitting lost link state advertisements\n"
8653 "Seconds\n"
8654 "Address of interface\n")
8655 {
8656 VTY_DECLVAR_CONTEXT(interface, ifp);
8657 int idx = 0;
8658 uint32_t seconds;
8659 struct in_addr addr;
8660 struct ospf_if_params *params;
8661 params = IF_DEF_PARAMS(ifp);
8662
8663 argv_find(argv, argc, "(1-65535)", &idx);
8664 seconds = strtol(argv[idx]->arg, NULL, 10);
8665
8666 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8667 if (!inet_aton(argv[idx]->arg, &addr)) {
8668 vty_out(vty,
8669 "Please specify interface address by A.B.C.D\n");
8670 return CMD_WARNING_CONFIG_FAILED;
8671 }
8672
8673 params = ospf_get_if_params(ifp, addr);
8674 ospf_if_update_params(ifp, addr);
8675 }
8676
8677 SET_IF_PARAM(params, retransmit_interval);
8678 params->retransmit_interval = seconds;
8679
8680 return CMD_SUCCESS;
8681 }
8682
8683 DEFUN_HIDDEN (ospf_retransmit_interval,
8684 ospf_retransmit_interval_cmd,
8685 "ospf retransmit-interval (1-65535) [A.B.C.D]",
8686 "OSPF interface commands\n"
8687 "Time between retransmitting lost link state advertisements\n"
8688 "Seconds\n"
8689 "Address of interface\n")
8690 {
8691 return ip_ospf_retransmit_interval(self, vty, argc, argv);
8692 }
8693
8694 DEFUN (no_ip_ospf_retransmit_interval,
8695 no_ip_ospf_retransmit_interval_addr_cmd,
8696 "no ip ospf retransmit-interval [(1-65535)] [A.B.C.D]",
8697 NO_STR
8698 "IP Information\n"
8699 "OSPF interface commands\n"
8700 "Time between retransmitting lost link state advertisements\n"
8701 "Seconds\n"
8702 "Address of interface\n")
8703 {
8704 VTY_DECLVAR_CONTEXT(interface, ifp);
8705 int idx = 0;
8706 struct in_addr addr;
8707 struct ospf_if_params *params;
8708
8709 params = IF_DEF_PARAMS(ifp);
8710
8711 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8712 if (!inet_aton(argv[idx]->arg, &addr)) {
8713 vty_out(vty,
8714 "Please specify interface address by A.B.C.D\n");
8715 return CMD_WARNING_CONFIG_FAILED;
8716 }
8717
8718 params = ospf_lookup_if_params(ifp, addr);
8719 if (params == NULL)
8720 return CMD_SUCCESS;
8721 }
8722
8723 UNSET_IF_PARAM(params, retransmit_interval);
8724 params->retransmit_interval = OSPF_RETRANSMIT_INTERVAL_DEFAULT;
8725
8726 if (params != IF_DEF_PARAMS(ifp)) {
8727 ospf_free_if_params(ifp, addr);
8728 ospf_if_update_params(ifp, addr);
8729 }
8730
8731 return CMD_SUCCESS;
8732 }
8733
8734 DEFUN_HIDDEN (no_ospf_retransmit_interval,
8735 no_ospf_retransmit_interval_cmd,
8736 "no ospf retransmit-interval [(1-65535)] [A.B.C.D]",
8737 NO_STR
8738 "OSPF interface commands\n"
8739 "Time between retransmitting lost link state advertisements\n"
8740 "Seconds\n"
8741 "Address of interface\n")
8742 {
8743 return no_ip_ospf_retransmit_interval(self, vty, argc, argv);
8744 }
8745
8746 DEFUN (ip_ospf_transmit_delay,
8747 ip_ospf_transmit_delay_addr_cmd,
8748 "ip ospf transmit-delay (1-65535) [A.B.C.D]",
8749 "IP Information\n"
8750 "OSPF interface commands\n"
8751 "Link state transmit delay\n"
8752 "Seconds\n"
8753 "Address of interface\n")
8754 {
8755 VTY_DECLVAR_CONTEXT(interface, ifp);
8756 int idx = 0;
8757 uint32_t seconds;
8758 struct in_addr addr;
8759 struct ospf_if_params *params;
8760
8761 params = IF_DEF_PARAMS(ifp);
8762 argv_find(argv, argc, "(1-65535)", &idx);
8763 seconds = strtol(argv[idx]->arg, NULL, 10);
8764
8765 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8766 if (!inet_aton(argv[idx]->arg, &addr)) {
8767 vty_out(vty,
8768 "Please specify interface address by A.B.C.D\n");
8769 return CMD_WARNING_CONFIG_FAILED;
8770 }
8771
8772 params = ospf_get_if_params(ifp, addr);
8773 ospf_if_update_params(ifp, addr);
8774 }
8775
8776 SET_IF_PARAM(params, transmit_delay);
8777 params->transmit_delay = seconds;
8778
8779 return CMD_SUCCESS;
8780 }
8781
8782 DEFUN_HIDDEN (ospf_transmit_delay,
8783 ospf_transmit_delay_cmd,
8784 "ospf transmit-delay (1-65535) [A.B.C.D]",
8785 "OSPF interface commands\n"
8786 "Link state transmit delay\n"
8787 "Seconds\n"
8788 "Address of interface\n")
8789 {
8790 return ip_ospf_transmit_delay(self, vty, argc, argv);
8791 }
8792
8793 DEFUN (no_ip_ospf_transmit_delay,
8794 no_ip_ospf_transmit_delay_addr_cmd,
8795 "no ip ospf transmit-delay [(1-65535)] [A.B.C.D]",
8796 NO_STR
8797 "IP Information\n"
8798 "OSPF interface commands\n"
8799 "Link state transmit delay\n"
8800 "Seconds\n"
8801 "Address of interface\n")
8802 {
8803 VTY_DECLVAR_CONTEXT(interface, ifp);
8804 int idx = 0;
8805 struct in_addr addr;
8806 struct ospf_if_params *params;
8807
8808 params = IF_DEF_PARAMS(ifp);
8809
8810 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
8811 if (!inet_aton(argv[idx]->arg, &addr)) {
8812 vty_out(vty,
8813 "Please specify interface address by A.B.C.D\n");
8814 return CMD_WARNING_CONFIG_FAILED;
8815 }
8816
8817 params = ospf_lookup_if_params(ifp, addr);
8818 if (params == NULL)
8819 return CMD_SUCCESS;
8820 }
8821
8822 UNSET_IF_PARAM(params, transmit_delay);
8823 params->transmit_delay = OSPF_TRANSMIT_DELAY_DEFAULT;
8824
8825 if (params != IF_DEF_PARAMS(ifp)) {
8826 ospf_free_if_params(ifp, addr);
8827 ospf_if_update_params(ifp, addr);
8828 }
8829
8830 return CMD_SUCCESS;
8831 }
8832
8833
8834 DEFUN_HIDDEN (no_ospf_transmit_delay,
8835 no_ospf_transmit_delay_cmd,
8836 "no ospf transmit-delay [(1-65535) [A.B.C.D]]",
8837 NO_STR
8838 "OSPF interface commands\n"
8839 "Link state transmit delay\n"
8840 "Seconds\n"
8841 "Address of interface\n")
8842 {
8843 return no_ip_ospf_transmit_delay(self, vty, argc, argv);
8844 }
8845
8846 DEFUN (ip_ospf_area,
8847 ip_ospf_area_cmd,
8848 "ip ospf [(1-65535)] area <A.B.C.D|(0-4294967295)> [A.B.C.D]",
8849 "IP Information\n"
8850 "OSPF interface commands\n"
8851 "Instance ID\n"
8852 "Enable OSPF on this interface\n"
8853 "OSPF area ID in IP address format\n"
8854 "OSPF area ID as a decimal value\n"
8855 "Address of interface\n")
8856 {
8857 VTY_DECLVAR_CONTEXT(interface, ifp);
8858 int idx = 0;
8859 int format, ret;
8860 struct in_addr area_id;
8861 struct in_addr addr;
8862 struct ospf_if_params *params = NULL;
8863 struct route_node *rn;
8864 struct ospf *ospf = NULL;
8865 unsigned short instance = 0;
8866 char *areaid;
8867 uint32_t count = 0;
8868
8869 if (argv_find(argv, argc, "(1-65535)", &idx))
8870 instance = strtol(argv[idx]->arg, NULL, 10);
8871
8872 argv_find(argv, argc, "area", &idx);
8873 areaid = argv[idx + 1]->arg;
8874
8875 if (!instance)
8876 ospf = ifp->vrf->info;
8877 else
8878 ospf = ospf_lookup_instance(instance);
8879
8880 if (instance && instance != ospf_instance) {
8881 /*
8882 * At this point we know we have received
8883 * an instance and there is no ospf instance
8884 * associated with it. This means we are
8885 * in a situation where we have an
8886 * ospf command that is setup for a different
8887 * process(instance). We need to safely
8888 * remove the command from ourselves and
8889 * allow the other instance(process) handle
8890 * the configuration command.
8891 */
8892 count = 0;
8893
8894 params = IF_DEF_PARAMS(ifp);
8895 if (OSPF_IF_PARAM_CONFIGURED(params, if_area)) {
8896 UNSET_IF_PARAM(params, if_area);
8897 count++;
8898 }
8899
8900 for (rn = route_top(IF_OIFS_PARAMS(ifp)); rn; rn = route_next(rn))
8901 if ((params = rn->info) && OSPF_IF_PARAM_CONFIGURED(params, if_area)) {
8902 UNSET_IF_PARAM(params, if_area);
8903 count++;
8904 }
8905
8906 if (count > 0) {
8907 ospf = ifp->vrf->info;
8908 if (ospf)
8909 ospf_interface_area_unset(ospf, ifp);
8910 }
8911
8912 return CMD_NOT_MY_INSTANCE;
8913 }
8914
8915 ret = str2area_id(areaid, &area_id, &format);
8916 if (ret < 0) {
8917 vty_out(vty, "Please specify area by A.B.C.D|<0-4294967295>\n");
8918 return CMD_WARNING_CONFIG_FAILED;
8919 }
8920 if (memcmp(ifp->name, "VLINK", 5) == 0) {
8921 vty_out(vty, "Cannot enable OSPF on a virtual link.\n");
8922 return CMD_WARNING_CONFIG_FAILED;
8923 }
8924
8925 if (ospf) {
8926 for (rn = route_top(ospf->networks); rn; rn = route_next(rn)) {
8927 if (rn->info != NULL) {
8928 vty_out(vty,
8929 "Please remove all network commands first.\n");
8930 return CMD_WARNING_CONFIG_FAILED;
8931 }
8932 }
8933 }
8934
8935 params = IF_DEF_PARAMS(ifp);
8936 if (OSPF_IF_PARAM_CONFIGURED(params, if_area)
8937 && !IPV4_ADDR_SAME(&params->if_area, &area_id)) {
8938 vty_out(vty,
8939 "Must remove previous area config before changing ospf area \n");
8940 return CMD_WARNING_CONFIG_FAILED;
8941 }
8942
8943 // Check if we have an address arg and proccess it
8944 if (argc == idx + 3) {
8945 if (!inet_aton(argv[idx + 2]->arg, &addr)) {
8946 vty_out(vty,
8947 "Please specify Intf Address by A.B.C.D\n");
8948 return CMD_WARNING_CONFIG_FAILED;
8949 }
8950 // update/create address-level params
8951 params = ospf_get_if_params((ifp), (addr));
8952 if (OSPF_IF_PARAM_CONFIGURED(params, if_area)) {
8953 if (!IPV4_ADDR_SAME(&params->if_area, &area_id)) {
8954 vty_out(vty,
8955 "Must remove previous area/address config before changing ospf area\n");
8956 return CMD_WARNING_CONFIG_FAILED;
8957 } else
8958 return CMD_SUCCESS;
8959 }
8960 ospf_if_update_params((ifp), (addr));
8961 }
8962
8963 /* enable ospf on this interface with area_id */
8964 if (params) {
8965 SET_IF_PARAM(params, if_area);
8966 params->if_area = area_id;
8967 params->if_area_id_fmt = format;
8968 }
8969
8970 if (ospf)
8971 ospf_interface_area_set(ospf, ifp);
8972
8973 return CMD_SUCCESS;
8974 }
8975
8976 DEFUN (no_ip_ospf_area,
8977 no_ip_ospf_area_cmd,
8978 "no ip ospf [(1-65535)] area [<A.B.C.D|(0-4294967295)> [A.B.C.D]]",
8979 NO_STR
8980 "IP Information\n"
8981 "OSPF interface commands\n"
8982 "Instance ID\n"
8983 "Disable OSPF on this interface\n"
8984 "OSPF area ID in IP address format\n"
8985 "OSPF area ID as a decimal value\n"
8986 "Address of interface\n")
8987 {
8988 VTY_DECLVAR_CONTEXT(interface, ifp);
8989 int idx = 0;
8990 struct ospf *ospf;
8991 struct ospf_if_params *params;
8992 unsigned short instance = 0;
8993 struct in_addr addr;
8994 struct in_addr area_id;
8995
8996 if (argv_find(argv, argc, "(1-65535)", &idx))
8997 instance = strtol(argv[idx]->arg, NULL, 10);
8998
8999 if (!instance)
9000 ospf = ifp->vrf->info;
9001 else
9002 ospf = ospf_lookup_instance(instance);
9003
9004 if (instance && instance != ospf_instance)
9005 return CMD_NOT_MY_INSTANCE;
9006
9007 argv_find(argv, argc, "area", &idx);
9008
9009 // Check if we have an address arg and proccess it
9010 if (argc == idx + 3) {
9011 if (!inet_aton(argv[idx + 2]->arg, &addr)) {
9012 vty_out(vty,
9013 "Please specify Intf Address by A.B.C.D\n");
9014 return CMD_WARNING_CONFIG_FAILED;
9015 }
9016 params = ospf_lookup_if_params(ifp, addr);
9017 if ((params) == NULL)
9018 return CMD_SUCCESS;
9019 } else
9020 params = IF_DEF_PARAMS(ifp);
9021
9022 area_id = params->if_area;
9023 if (!OSPF_IF_PARAM_CONFIGURED(params, if_area)) {
9024 vty_out(vty,
9025 "Can't find specified interface area configuration.\n");
9026 return CMD_WARNING_CONFIG_FAILED;
9027 }
9028
9029 UNSET_IF_PARAM(params, if_area);
9030 if (params != IF_DEF_PARAMS((ifp))) {
9031 ospf_free_if_params((ifp), (addr));
9032 ospf_if_update_params((ifp), (addr));
9033 }
9034
9035 if (ospf) {
9036 ospf_interface_area_unset(ospf, ifp);
9037 ospf_area_check_free(ospf, area_id);
9038 }
9039
9040 return CMD_SUCCESS;
9041 }
9042
9043 DEFUN (ip_ospf_passive,
9044 ip_ospf_passive_cmd,
9045 "ip ospf passive [A.B.C.D]",
9046 "IP Information\n"
9047 "OSPF interface commands\n"
9048 "Suppress routing updates on an interface\n"
9049 "Address of interface\n")
9050 {
9051 VTY_DECLVAR_CONTEXT(interface, ifp);
9052 int idx_ipv4 = 3;
9053 struct in_addr addr = {.s_addr = INADDR_ANY};
9054 struct ospf_if_params *params;
9055 int ret;
9056
9057 if (argc == 4) {
9058 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
9059 if (!ret) {
9060 vty_out(vty,
9061 "Please specify interface address by A.B.C.D\n");
9062 return CMD_WARNING_CONFIG_FAILED;
9063 }
9064 params = ospf_get_if_params(ifp, addr);
9065 ospf_if_update_params(ifp, addr);
9066 } else {
9067 params = IF_DEF_PARAMS(ifp);
9068 }
9069
9070 ospf_passive_interface_update(ifp, params, addr, OSPF_IF_PASSIVE);
9071
9072 return CMD_SUCCESS;
9073 }
9074
9075 DEFUN (no_ip_ospf_passive,
9076 no_ip_ospf_passive_cmd,
9077 "no ip ospf passive [A.B.C.D]",
9078 NO_STR
9079 "IP Information\n"
9080 "OSPF interface commands\n"
9081 "Enable routing updates on an interface\n"
9082 "Address of interface\n")
9083 {
9084 VTY_DECLVAR_CONTEXT(interface, ifp);
9085 int idx_ipv4 = 4;
9086 struct in_addr addr = {.s_addr = INADDR_ANY};
9087 struct ospf_if_params *params;
9088 int ret;
9089
9090 if (argc == 5) {
9091 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
9092 if (!ret) {
9093 vty_out(vty,
9094 "Please specify interface address by A.B.C.D\n");
9095 return CMD_WARNING_CONFIG_FAILED;
9096 }
9097 params = ospf_lookup_if_params(ifp, addr);
9098 if (params == NULL)
9099 return CMD_SUCCESS;
9100 } else {
9101 params = IF_DEF_PARAMS(ifp);
9102 }
9103
9104 ospf_passive_interface_update(ifp, params, addr, OSPF_IF_ACTIVE);
9105
9106 return CMD_SUCCESS;
9107 }
9108
9109 DEFUN (ospf_redistribute_source,
9110 ospf_redistribute_source_cmd,
9111 "redistribute " FRR_REDIST_STR_OSPFD " [{metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9112 REDIST_STR
9113 FRR_REDIST_HELP_STR_OSPFD
9114 "Metric for redistributed routes\n"
9115 "OSPF default metric\n"
9116 "OSPF exterior metric type for redistributed routes\n"
9117 "Set OSPF External Type 1/2 metrics\n"
9118 "Route map reference\n"
9119 "Pointer to route-map entries\n")
9120 {
9121 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9122 int idx_protocol = 1;
9123 int source;
9124 int type = -1;
9125 int metric = -1;
9126 struct ospf_redist *red;
9127 int idx = 0;
9128 bool update = false;
9129
9130 /* Get distribute source. */
9131 source = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
9132 if (source < 0)
9133 return CMD_WARNING_CONFIG_FAILED;
9134
9135 /* Get metric value. */
9136 if (argv_find(argv, argc, "(0-16777214)", &idx)) {
9137 if (!str2metric(argv[idx]->arg, &metric))
9138 return CMD_WARNING_CONFIG_FAILED;
9139 }
9140 idx = 1;
9141 /* Get metric type. */
9142 if (argv_find(argv, argc, "(1-2)", &idx)) {
9143 if (!str2metric_type(argv[idx]->arg, &type))
9144 return CMD_WARNING_CONFIG_FAILED;
9145 }
9146 idx = 1;
9147
9148 red = ospf_redist_lookup(ospf, source, 0);
9149 if (!red)
9150 red = ospf_redist_add(ospf, source, 0);
9151 else
9152 update = true;
9153
9154 /* Get route-map */
9155 if (argv_find(argv, argc, "route-map", &idx)) {
9156 ospf_routemap_set(red, argv[idx + 1]->arg);
9157 } else
9158 ospf_routemap_unset(red);
9159
9160 if (update)
9161 return ospf_redistribute_update(ospf, red, source, 0, type,
9162 metric);
9163 else
9164 return ospf_redistribute_set(ospf, red, source, 0, type,
9165 metric);
9166 }
9167
9168 DEFUN (no_ospf_redistribute_source,
9169 no_ospf_redistribute_source_cmd,
9170 "no redistribute " FRR_REDIST_STR_OSPFD " [{metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9171 NO_STR
9172 REDIST_STR
9173 FRR_REDIST_HELP_STR_OSPFD
9174 "Metric for redistributed routes\n"
9175 "OSPF default metric\n"
9176 "OSPF exterior metric type for redistributed routes\n"
9177 "Set OSPF External Type 1/2 metrics\n"
9178 "Route map reference\n"
9179 "Pointer to route-map entries\n")
9180 {
9181 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9182 int idx_protocol = 2;
9183 int source;
9184 struct ospf_redist *red;
9185
9186 source = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
9187 if (source < 0)
9188 return CMD_WARNING_CONFIG_FAILED;
9189
9190 red = ospf_redist_lookup(ospf, source, 0);
9191 if (!red)
9192 return CMD_SUCCESS;
9193
9194 ospf_routemap_unset(red);
9195 ospf_redist_del(ospf, source, 0);
9196
9197 return ospf_redistribute_unset(ospf, source, 0);
9198 }
9199
9200 DEFUN (ospf_redistribute_instance_source,
9201 ospf_redistribute_instance_source_cmd,
9202 "redistribute <ospf|table> (1-65535) [{metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9203 REDIST_STR
9204 "Open Shortest Path First\n"
9205 "Non-main Kernel Routing Table\n"
9206 "Instance ID/Table ID\n"
9207 "Metric for redistributed routes\n"
9208 "OSPF default metric\n"
9209 "OSPF exterior metric type for redistributed routes\n"
9210 "Set OSPF External Type 1/2 metrics\n"
9211 "Route map reference\n"
9212 "Pointer to route-map entries\n")
9213 {
9214 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9215 int idx_ospf_table = 1;
9216 int idx_number = 2;
9217 int idx = 3;
9218 int source;
9219 int type = -1;
9220 int metric = -1;
9221 unsigned short instance;
9222 struct ospf_redist *red;
9223 bool update = false;
9224
9225 source = proto_redistnum(AFI_IP, argv[idx_ospf_table]->text);
9226
9227 if (source < 0) {
9228 vty_out(vty, "Unknown instance redistribution\n");
9229 return CMD_WARNING_CONFIG_FAILED;
9230 }
9231
9232 instance = strtoul(argv[idx_number]->arg, NULL, 10);
9233
9234 if ((source == ZEBRA_ROUTE_OSPF) && !ospf->instance) {
9235 vty_out(vty,
9236 "Instance redistribution in non-instanced OSPF not allowed\n");
9237 return CMD_WARNING_CONFIG_FAILED;
9238 }
9239
9240 if ((source == ZEBRA_ROUTE_OSPF) && (ospf->instance == instance)) {
9241 vty_out(vty, "Same instance OSPF redistribution not allowed\n");
9242 return CMD_WARNING_CONFIG_FAILED;
9243 }
9244
9245 /* Get metric value. */
9246 if (argv_find(argv, argc, "metric", &idx))
9247 if (!str2metric(argv[idx + 1]->arg, &metric))
9248 return CMD_WARNING_CONFIG_FAILED;
9249
9250 idx = 3;
9251 /* Get metric type. */
9252 if (argv_find(argv, argc, "metric-type", &idx))
9253 if (!str2metric_type(argv[idx + 1]->arg, &type))
9254 return CMD_WARNING_CONFIG_FAILED;
9255
9256 red = ospf_redist_lookup(ospf, source, instance);
9257 if (!red)
9258 red = ospf_redist_add(ospf, source, instance);
9259 else
9260 update = true;
9261
9262 idx = 3;
9263 if (argv_find(argv, argc, "route-map", &idx))
9264 ospf_routemap_set(red, argv[idx + 1]->arg);
9265 else
9266 ospf_routemap_unset(red);
9267
9268 if (update)
9269 return ospf_redistribute_update(ospf, red, source, instance,
9270 type, metric);
9271 else
9272 return ospf_redistribute_set(ospf, red, source, instance, type,
9273 metric);
9274 }
9275
9276 DEFUN (no_ospf_redistribute_instance_source,
9277 no_ospf_redistribute_instance_source_cmd,
9278 "no redistribute <ospf|table> (1-65535) [{metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9279 NO_STR
9280 REDIST_STR
9281 "Open Shortest Path First\n"
9282 "Non-main Kernel Routing Table\n"
9283 "Instance ID/Table Id\n"
9284 "Metric for redistributed routes\n"
9285 "OSPF default metric\n"
9286 "OSPF exterior metric type for redistributed routes\n"
9287 "Set OSPF External Type 1/2 metrics\n"
9288 "Route map reference\n"
9289 "Pointer to route-map entries\n")
9290 {
9291 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9292 int idx_ospf_table = 2;
9293 int idx_number = 3;
9294 unsigned int instance;
9295 struct ospf_redist *red;
9296 int source;
9297
9298 if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9299 source = ZEBRA_ROUTE_OSPF;
9300 else
9301 source = ZEBRA_ROUTE_TABLE;
9302
9303 instance = strtoul(argv[idx_number]->arg, NULL, 10);
9304
9305 if ((source == ZEBRA_ROUTE_OSPF) && !ospf->instance) {
9306 vty_out(vty,
9307 "Instance redistribution in non-instanced OSPF not allowed\n");
9308 return CMD_WARNING_CONFIG_FAILED;
9309 }
9310
9311 if ((source == ZEBRA_ROUTE_OSPF) && (ospf->instance == instance)) {
9312 vty_out(vty, "Same instance OSPF redistribution not allowed\n");
9313 return CMD_WARNING_CONFIG_FAILED;
9314 }
9315
9316 red = ospf_redist_lookup(ospf, source, instance);
9317 if (!red)
9318 return CMD_SUCCESS;
9319
9320 ospf_routemap_unset(red);
9321 ospf_redist_del(ospf, source, instance);
9322
9323 return ospf_redistribute_unset(ospf, source, instance);
9324 }
9325
9326 DEFUN (ospf_distribute_list_out,
9327 ospf_distribute_list_out_cmd,
9328 "distribute-list ACCESSLIST4_NAME out " FRR_REDIST_STR_OSPFD,
9329 "Filter networks in routing updates\n"
9330 "Access-list name\n"
9331 OUT_STR
9332 FRR_REDIST_HELP_STR_OSPFD)
9333 {
9334 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9335 int idx_word = 1;
9336 int source;
9337
9338 char *proto = argv[argc - 1]->text;
9339
9340 /* Get distribute source. */
9341 source = proto_redistnum(AFI_IP, proto);
9342 if (source < 0)
9343 return CMD_WARNING_CONFIG_FAILED;
9344
9345 return ospf_distribute_list_out_set(ospf, source, argv[idx_word]->arg);
9346 }
9347
9348 DEFUN (no_ospf_distribute_list_out,
9349 no_ospf_distribute_list_out_cmd,
9350 "no distribute-list ACCESSLIST4_NAME out " FRR_REDIST_STR_OSPFD,
9351 NO_STR
9352 "Filter networks in routing updates\n"
9353 "Access-list name\n"
9354 OUT_STR
9355 FRR_REDIST_HELP_STR_OSPFD)
9356 {
9357 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9358 int idx_word = 2;
9359 int source;
9360
9361 char *proto = argv[argc - 1]->text;
9362 source = proto_redistnum(AFI_IP, proto);
9363 if (source < 0)
9364 return CMD_WARNING_CONFIG_FAILED;
9365
9366 return ospf_distribute_list_out_unset(ospf, source,
9367 argv[idx_word]->arg);
9368 }
9369
9370 /* Default information originate. */
9371 DEFUN (ospf_default_information_originate,
9372 ospf_default_information_originate_cmd,
9373 "default-information originate [{always|metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9374 "Control distribution of default information\n"
9375 "Distribute a default route\n"
9376 "Always advertise default route\n"
9377 "OSPF default metric\n"
9378 "OSPF metric\n"
9379 "OSPF metric type for default routes\n"
9380 "Set OSPF External Type 1/2 metrics\n"
9381 "Route map reference\n"
9382 "Pointer to route-map entries\n")
9383 {
9384 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9385 int default_originate = DEFAULT_ORIGINATE_ZEBRA;
9386 int type = -1;
9387 int metric = -1;
9388 struct ospf_redist *red;
9389 int idx = 0;
9390 int cur_originate = ospf->default_originate;
9391 bool sameRtmap = false;
9392 char *rtmap = NULL;
9393
9394 red = ospf_redist_add(ospf, DEFAULT_ROUTE, 0);
9395
9396 /* Check whether "always" was specified */
9397 if (argv_find(argv, argc, "always", &idx))
9398 default_originate = DEFAULT_ORIGINATE_ALWAYS;
9399 idx = 1;
9400 /* Get metric value */
9401 if (argv_find(argv, argc, "(0-16777214)", &idx)) {
9402 if (!str2metric(argv[idx]->arg, &metric))
9403 return CMD_WARNING_CONFIG_FAILED;
9404 }
9405 idx = 1;
9406 /* Get metric type. */
9407 if (argv_find(argv, argc, "(1-2)", &idx)) {
9408 if (!str2metric_type(argv[idx]->arg, &type))
9409 return CMD_WARNING_CONFIG_FAILED;
9410 }
9411 idx = 1;
9412 /* Get route-map */
9413 if (argv_find(argv, argc, "route-map", &idx))
9414 rtmap = argv[idx]->arg + 1;
9415
9416 /* To check if user is providing same route map */
9417 if ((!rtmap && !ROUTEMAP_NAME(red)) ||
9418 (rtmap && ROUTEMAP_NAME(red) &&
9419 (strcmp(rtmap, ROUTEMAP_NAME(red)) == 0)))
9420 sameRtmap = true;
9421
9422 /* Don't allow if the same lsa is already originated. */
9423 if ((sameRtmap)
9424 && (red->dmetric.type == type)
9425 && (red->dmetric.value == metric)
9426 && (cur_originate == default_originate))
9427 return CMD_SUCCESS;
9428
9429 /* Updating Metric details */
9430 red->dmetric.type = type;
9431 red->dmetric.value = metric;
9432
9433 /* updating route map details */
9434 if (rtmap)
9435 ospf_routemap_set(red, rtmap);
9436 else
9437 ospf_routemap_unset(red);
9438
9439 return ospf_redistribute_default_set(ospf, default_originate, type,
9440 metric);
9441 }
9442
9443 DEFUN (no_ospf_default_information_originate,
9444 no_ospf_default_information_originate_cmd,
9445 "no default-information originate [{always|metric (0-16777214)|metric-type (1-2)|route-map RMAP_NAME}]",
9446 NO_STR
9447 "Control distribution of default information\n"
9448 "Distribute a default route\n"
9449 "Always advertise default route\n"
9450 "OSPF default metric\n"
9451 "OSPF metric\n"
9452 "OSPF metric type for default routes\n"
9453 "Set OSPF External Type 1/2 metrics\n"
9454 "Route map reference\n"
9455 "Pointer to route-map entries\n")
9456 {
9457 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9458 struct ospf_redist *red;
9459
9460 red = ospf_redist_lookup(ospf, DEFAULT_ROUTE, 0);
9461 if (!red)
9462 return CMD_SUCCESS;
9463
9464 ospf_routemap_unset(red);
9465 ospf_redist_del(ospf, DEFAULT_ROUTE, 0);
9466
9467 return ospf_redistribute_default_set(ospf, DEFAULT_ORIGINATE_NONE,
9468 0, 0);
9469 }
9470
9471 DEFUN (ospf_default_metric,
9472 ospf_default_metric_cmd,
9473 "default-metric (0-16777214)",
9474 "Set metric of redistributed routes\n"
9475 "Default metric\n")
9476 {
9477 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9478 int idx_number = 1;
9479 int metric = -1;
9480
9481 if (!str2metric(argv[idx_number]->arg, &metric))
9482 return CMD_WARNING_CONFIG_FAILED;
9483
9484 ospf->default_metric = metric;
9485
9486 return CMD_SUCCESS;
9487 }
9488
9489 DEFUN (no_ospf_default_metric,
9490 no_ospf_default_metric_cmd,
9491 "no default-metric [(0-16777214)]",
9492 NO_STR
9493 "Set metric of redistributed routes\n"
9494 "Default metric\n")
9495 {
9496 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9497
9498 ospf->default_metric = -1;
9499
9500 return CMD_SUCCESS;
9501 }
9502
9503
9504 DEFUN (ospf_distance,
9505 ospf_distance_cmd,
9506 "distance (1-255)",
9507 "Administrative distance\n"
9508 "OSPF Administrative distance\n")
9509 {
9510 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9511 int idx_number = 1;
9512 uint8_t distance;
9513
9514 distance = atoi(argv[idx_number]->arg);
9515 if (ospf->distance_all != distance) {
9516 ospf->distance_all = distance;
9517 ospf_restart_spf(ospf);
9518 }
9519
9520 return CMD_SUCCESS;
9521 }
9522
9523 DEFUN (no_ospf_distance,
9524 no_ospf_distance_cmd,
9525 "no distance (1-255)",
9526 NO_STR
9527 "Administrative distance\n"
9528 "OSPF Administrative distance\n")
9529 {
9530 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9531
9532 if (ospf->distance_all) {
9533 ospf->distance_all = 0;
9534 ospf_restart_spf(ospf);
9535 }
9536
9537 return CMD_SUCCESS;
9538 }
9539
9540 DEFUN (no_ospf_distance_ospf,
9541 no_ospf_distance_ospf_cmd,
9542 "no distance ospf [{intra-area [(1-255)]|inter-area [(1-255)]|external [(1-255)]}]",
9543 NO_STR
9544 "Administrative distance\n"
9545 "OSPF administrative distance\n"
9546 "Intra-area routes\n"
9547 "Distance for intra-area routes\n"
9548 "Inter-area routes\n"
9549 "Distance for inter-area routes\n"
9550 "External routes\n"
9551 "Distance for external routes\n")
9552 {
9553 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9554 int idx = 0;
9555
9556 if (argv_find(argv, argc, "intra-area", &idx) || argc == 3)
9557 idx = ospf->distance_intra = 0;
9558 if (argv_find(argv, argc, "inter-area", &idx) || argc == 3)
9559 idx = ospf->distance_inter = 0;
9560 if (argv_find(argv, argc, "external", &idx) || argc == 3)
9561 ospf->distance_external = 0;
9562
9563 return CMD_SUCCESS;
9564 }
9565
9566 DEFUN (ospf_distance_ospf,
9567 ospf_distance_ospf_cmd,
9568 "distance ospf {intra-area (1-255)|inter-area (1-255)|external (1-255)}",
9569 "Administrative distance\n"
9570 "OSPF administrative distance\n"
9571 "Intra-area routes\n"
9572 "Distance for intra-area routes\n"
9573 "Inter-area routes\n"
9574 "Distance for inter-area routes\n"
9575 "External routes\n"
9576 "Distance for external routes\n")
9577 {
9578 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9579 int idx = 0;
9580
9581 ospf->distance_intra = 0;
9582 ospf->distance_inter = 0;
9583 ospf->distance_external = 0;
9584
9585 if (argv_find(argv, argc, "intra-area", &idx))
9586 ospf->distance_intra = atoi(argv[idx + 1]->arg);
9587 idx = 0;
9588 if (argv_find(argv, argc, "inter-area", &idx))
9589 ospf->distance_inter = atoi(argv[idx + 1]->arg);
9590 idx = 0;
9591 if (argv_find(argv, argc, "external", &idx))
9592 ospf->distance_external = atoi(argv[idx + 1]->arg);
9593
9594 return CMD_SUCCESS;
9595 }
9596
9597 DEFUN (ip_ospf_mtu_ignore,
9598 ip_ospf_mtu_ignore_addr_cmd,
9599 "ip ospf mtu-ignore [A.B.C.D]",
9600 "IP Information\n"
9601 "OSPF interface commands\n"
9602 "Disable MTU mismatch detection on this interface\n"
9603 "Address of interface\n")
9604 {
9605 VTY_DECLVAR_CONTEXT(interface, ifp);
9606 int idx_ipv4 = 3;
9607 struct in_addr addr;
9608 int ret;
9609
9610 struct ospf_if_params *params;
9611 params = IF_DEF_PARAMS(ifp);
9612
9613 if (argc == 4) {
9614 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
9615 if (!ret) {
9616 vty_out(vty,
9617 "Please specify interface address by A.B.C.D\n");
9618 return CMD_WARNING_CONFIG_FAILED;
9619 }
9620 params = ospf_get_if_params(ifp, addr);
9621 ospf_if_update_params(ifp, addr);
9622 }
9623 params->mtu_ignore = 1;
9624 if (params->mtu_ignore != OSPF_MTU_IGNORE_DEFAULT)
9625 SET_IF_PARAM(params, mtu_ignore);
9626 else {
9627 UNSET_IF_PARAM(params, mtu_ignore);
9628 if (params != IF_DEF_PARAMS(ifp)) {
9629 ospf_free_if_params(ifp, addr);
9630 ospf_if_update_params(ifp, addr);
9631 }
9632 }
9633 return CMD_SUCCESS;
9634 }
9635
9636 DEFUN (no_ip_ospf_mtu_ignore,
9637 no_ip_ospf_mtu_ignore_addr_cmd,
9638 "no ip ospf mtu-ignore [A.B.C.D]",
9639 NO_STR
9640 "IP Information\n"
9641 "OSPF interface commands\n"
9642 "Disable MTU mismatch detection on this interface\n"
9643 "Address of interface\n")
9644 {
9645 VTY_DECLVAR_CONTEXT(interface, ifp);
9646 int idx_ipv4 = 4;
9647 struct in_addr addr;
9648 int ret;
9649
9650 struct ospf_if_params *params;
9651 params = IF_DEF_PARAMS(ifp);
9652
9653 if (argc == 5) {
9654 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
9655 if (!ret) {
9656 vty_out(vty,
9657 "Please specify interface address by A.B.C.D\n");
9658 return CMD_WARNING_CONFIG_FAILED;
9659 }
9660 params = ospf_get_if_params(ifp, addr);
9661 ospf_if_update_params(ifp, addr);
9662 }
9663 params->mtu_ignore = 0;
9664 if (params->mtu_ignore != OSPF_MTU_IGNORE_DEFAULT)
9665 SET_IF_PARAM(params, mtu_ignore);
9666 else {
9667 UNSET_IF_PARAM(params, mtu_ignore);
9668 if (params != IF_DEF_PARAMS(ifp)) {
9669 ospf_free_if_params(ifp, addr);
9670 ospf_if_update_params(ifp, addr);
9671 }
9672 }
9673 return CMD_SUCCESS;
9674 }
9675
9676
9677 DEFUN (ospf_max_metric_router_lsa_admin,
9678 ospf_max_metric_router_lsa_admin_cmd,
9679 "max-metric router-lsa administrative",
9680 "OSPF maximum / infinite-distance metric\n"
9681 "Advertise own Router-LSA with infinite distance (stub router)\n"
9682 "Administratively applied, for an indefinite period\n")
9683 {
9684 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9685 struct listnode *ln;
9686 struct ospf_area *area;
9687
9688 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
9689 SET_FLAG(area->stub_router_state, OSPF_AREA_ADMIN_STUB_ROUTED);
9690
9691 if (!CHECK_FLAG(area->stub_router_state,
9692 OSPF_AREA_IS_STUB_ROUTED))
9693 ospf_router_lsa_update_area(area);
9694 }
9695
9696 /* Allows for areas configured later to get the property */
9697 ospf->stub_router_admin_set = OSPF_STUB_ROUTER_ADMINISTRATIVE_SET;
9698
9699 return CMD_SUCCESS;
9700 }
9701
9702 DEFUN (no_ospf_max_metric_router_lsa_admin,
9703 no_ospf_max_metric_router_lsa_admin_cmd,
9704 "no max-metric router-lsa administrative",
9705 NO_STR
9706 "OSPF maximum / infinite-distance metric\n"
9707 "Advertise own Router-LSA with infinite distance (stub router)\n"
9708 "Administratively applied, for an indefinite period\n")
9709 {
9710 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9711 struct listnode *ln;
9712 struct ospf_area *area;
9713
9714 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
9715 UNSET_FLAG(area->stub_router_state,
9716 OSPF_AREA_ADMIN_STUB_ROUTED);
9717
9718 /* Don't trample on the start-up stub timer */
9719 if (CHECK_FLAG(area->stub_router_state,
9720 OSPF_AREA_IS_STUB_ROUTED)
9721 && !area->t_stub_router) {
9722 UNSET_FLAG(area->stub_router_state,
9723 OSPF_AREA_IS_STUB_ROUTED);
9724 ospf_router_lsa_update_area(area);
9725 }
9726 }
9727 ospf->stub_router_admin_set = OSPF_STUB_ROUTER_ADMINISTRATIVE_UNSET;
9728 return CMD_SUCCESS;
9729 }
9730
9731 DEFUN (ospf_max_metric_router_lsa_startup,
9732 ospf_max_metric_router_lsa_startup_cmd,
9733 "max-metric router-lsa on-startup (5-86400)",
9734 "OSPF maximum / infinite-distance metric\n"
9735 "Advertise own Router-LSA with infinite distance (stub router)\n"
9736 "Automatically advertise stub Router-LSA on startup of OSPF\n"
9737 "Time (seconds) to advertise self as stub-router\n")
9738 {
9739 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9740 int idx_number = 3;
9741 unsigned int seconds;
9742
9743 if (argc < 4) {
9744 vty_out(vty, "%% Must supply stub-router period\n");
9745 return CMD_WARNING_CONFIG_FAILED;
9746 }
9747
9748 seconds = strtoul(argv[idx_number]->arg, NULL, 10);
9749
9750 ospf->stub_router_startup_time = seconds;
9751
9752 return CMD_SUCCESS;
9753 }
9754
9755 DEFUN (no_ospf_max_metric_router_lsa_startup,
9756 no_ospf_max_metric_router_lsa_startup_cmd,
9757 "no max-metric router-lsa on-startup [(5-86400)]",
9758 NO_STR
9759 "OSPF maximum / infinite-distance metric\n"
9760 "Advertise own Router-LSA with infinite distance (stub router)\n"
9761 "Automatically advertise stub Router-LSA on startup of OSPF\n"
9762 "Time (seconds) to advertise self as stub-router\n")
9763 {
9764 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9765 struct listnode *ln;
9766 struct ospf_area *area;
9767
9768 ospf->stub_router_startup_time = OSPF_STUB_ROUTER_UNCONFIGURED;
9769
9770 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
9771 SET_FLAG(area->stub_router_state,
9772 OSPF_AREA_WAS_START_STUB_ROUTED);
9773 THREAD_OFF(area->t_stub_router);
9774
9775 /* Don't trample on admin stub routed */
9776 if (!CHECK_FLAG(area->stub_router_state,
9777 OSPF_AREA_ADMIN_STUB_ROUTED)) {
9778 UNSET_FLAG(area->stub_router_state,
9779 OSPF_AREA_IS_STUB_ROUTED);
9780 ospf_router_lsa_update_area(area);
9781 }
9782 }
9783 return CMD_SUCCESS;
9784 }
9785
9786
9787 DEFUN (ospf_max_metric_router_lsa_shutdown,
9788 ospf_max_metric_router_lsa_shutdown_cmd,
9789 "max-metric router-lsa on-shutdown (5-100)",
9790 "OSPF maximum / infinite-distance metric\n"
9791 "Advertise own Router-LSA with infinite distance (stub router)\n"
9792 "Advertise stub-router prior to full shutdown of OSPF\n"
9793 "Time (seconds) to wait till full shutdown\n")
9794 {
9795 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9796 int idx_number = 3;
9797 unsigned int seconds;
9798
9799 if (argc < 4) {
9800 vty_out(vty, "%% Must supply stub-router shutdown period\n");
9801 return CMD_WARNING_CONFIG_FAILED;
9802 }
9803
9804 seconds = strtoul(argv[idx_number]->arg, NULL, 10);
9805
9806 ospf->stub_router_shutdown_time = seconds;
9807
9808 return CMD_SUCCESS;
9809 }
9810
9811 DEFUN (no_ospf_max_metric_router_lsa_shutdown,
9812 no_ospf_max_metric_router_lsa_shutdown_cmd,
9813 "no max-metric router-lsa on-shutdown [(5-100)]",
9814 NO_STR
9815 "OSPF maximum / infinite-distance metric\n"
9816 "Advertise own Router-LSA with infinite distance (stub router)\n"
9817 "Advertise stub-router prior to full shutdown of OSPF\n"
9818 "Time (seconds) to wait till full shutdown\n")
9819 {
9820 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9821
9822 ospf->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
9823
9824 return CMD_SUCCESS;
9825 }
9826
9827 DEFUN (ospf_proactive_arp,
9828 ospf_proactive_arp_cmd,
9829 "proactive-arp",
9830 "Allow sending ARP requests proactively\n")
9831 {
9832 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9833
9834 ospf->proactive_arp = true;
9835
9836 return CMD_SUCCESS;
9837 }
9838
9839 DEFUN (no_ospf_proactive_arp,
9840 no_ospf_proactive_arp_cmd,
9841 "no proactive-arp",
9842 NO_STR
9843 "Disallow sending ARP requests proactively\n")
9844 {
9845 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9846
9847 ospf->proactive_arp = false;
9848
9849 return CMD_SUCCESS;
9850 }
9851
9852 /* Graceful Restart HELPER Commands */
9853 DEFPY(ospf_gr_helper_enable, ospf_gr_helper_enable_cmd,
9854 "graceful-restart helper enable [A.B.C.D$address]",
9855 "OSPF Graceful Restart\n"
9856 "OSPF GR Helper\n"
9857 "Enable Helper support\n"
9858 "Advertising Router-ID\n")
9859 {
9860 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9861
9862 if (address_str) {
9863 ospf_gr_helper_support_set_per_routerid(ospf, &address,
9864 OSPF_GR_TRUE);
9865 return CMD_SUCCESS;
9866 }
9867
9868 ospf_gr_helper_support_set(ospf, OSPF_GR_TRUE);
9869
9870 return CMD_SUCCESS;
9871 }
9872
9873 DEFPY(no_ospf_gr_helper_enable,
9874 no_ospf_gr_helper_enable_cmd,
9875 "no graceful-restart helper enable [A.B.C.D$address]",
9876 NO_STR
9877 "OSPF Graceful Restart\n"
9878 "OSPF GR Helper\n"
9879 "Enable Helper support\n"
9880 "Advertising Router-ID\n")
9881 {
9882 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9883
9884 if (address_str) {
9885 ospf_gr_helper_support_set_per_routerid(ospf, &address,
9886 OSPF_GR_FALSE);
9887 return CMD_SUCCESS;
9888 }
9889
9890 ospf_gr_helper_support_set(ospf, OSPF_GR_FALSE);
9891 return CMD_SUCCESS;
9892 }
9893
9894 DEFPY(ospf_gr_helper_enable_lsacheck,
9895 ospf_gr_helper_enable_lsacheck_cmd,
9896 "graceful-restart helper strict-lsa-checking",
9897 "OSPF Graceful Restart\n"
9898 "OSPF GR Helper\n"
9899 "Enable strict LSA check\n")
9900 {
9901 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9902
9903 ospf_gr_helper_lsa_check_set(ospf, OSPF_GR_TRUE);
9904 return CMD_SUCCESS;
9905 }
9906
9907 DEFPY(no_ospf_gr_helper_enable_lsacheck,
9908 no_ospf_gr_helper_enable_lsacheck_cmd,
9909 "no graceful-restart helper strict-lsa-checking",
9910 NO_STR
9911 "OSPF Graceful Restart\n"
9912 "OSPF GR Helper\n"
9913 "Disable strict LSA check\n")
9914 {
9915 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9916
9917 ospf_gr_helper_lsa_check_set(ospf, OSPF_GR_FALSE);
9918 return CMD_SUCCESS;
9919 }
9920
9921 DEFPY(ospf_gr_helper_supported_grace_time,
9922 ospf_gr_helper_supported_grace_time_cmd,
9923 "graceful-restart helper supported-grace-time (10-1800)$interval",
9924 "OSPF Graceful Restart\n"
9925 "OSPF GR Helper\n"
9926 "Supported grace timer\n"
9927 "Grace interval(in seconds)\n")
9928 {
9929 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9930
9931 ospf_gr_helper_supported_gracetime_set(ospf, interval);
9932 return CMD_SUCCESS;
9933 }
9934
9935 DEFPY(no_ospf_gr_helper_supported_grace_time,
9936 no_ospf_gr_helper_supported_grace_time_cmd,
9937 "no graceful-restart helper supported-grace-time (10-1800)$interval",
9938 NO_STR
9939 "OSPF Graceful Restart\n"
9940 "OSPF GR Helper\n"
9941 "Supported grace timer\n"
9942 "Grace interval(in seconds)\n")
9943 {
9944 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9945
9946 ospf_gr_helper_supported_gracetime_set(ospf, OSPF_MAX_GRACE_INTERVAL);
9947 return CMD_SUCCESS;
9948 }
9949
9950 DEFPY(ospf_gr_helper_planned_only,
9951 ospf_gr_helper_planned_only_cmd,
9952 "graceful-restart helper planned-only",
9953 "OSPF Graceful Restart\n"
9954 "OSPF GR Helper\n"
9955 "Supported only planned restart\n")
9956 {
9957 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9958
9959 ospf_gr_helper_set_supported_planned_only_restart(ospf, OSPF_GR_TRUE);
9960
9961 return CMD_SUCCESS;
9962 }
9963
9964 /* External Route Aggregation */
9965 DEFUN (ospf_external_route_aggregation,
9966 ospf_external_route_aggregation_cmd,
9967 "summary-address A.B.C.D/M [tag (1-4294967295)]",
9968 "External summary address\n"
9969 "Summary address prefix\n"
9970 "Router tag \n"
9971 "Router tag value\n")
9972 {
9973 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
9974 struct prefix_ipv4 p;
9975 int idx = 1;
9976 route_tag_t tag = 0;
9977 int ret = OSPF_SUCCESS;
9978
9979 str2prefix_ipv4(argv[idx]->arg, &p);
9980
9981 if (is_default_prefix4(&p)) {
9982 vty_out(vty,
9983 "Default address shouldn't be configured as summary address.\n");
9984 return CMD_SUCCESS;
9985 }
9986
9987 /* Apply mask for given prefix. */
9988 apply_mask(&p);
9989
9990 if (!is_valid_summary_addr(&p)) {
9991 vty_out(vty, "Not a valid summary address.\n");
9992 return CMD_WARNING_CONFIG_FAILED;
9993 }
9994
9995 if (argc > 2)
9996 tag = strtoul(argv[idx + 2]->arg, NULL, 10);
9997
9998 ret = ospf_asbr_external_aggregator_set(ospf, &p, tag);
9999 if (ret == OSPF_INVALID)
10000 vty_out(vty, "Invalid configuration!!\n");
10001
10002 return CMD_SUCCESS;
10003 }
10004
10005 DEFUN (no_ospf_external_route_aggregation,
10006 no_ospf_external_route_aggregation_cmd,
10007 "no summary-address A.B.C.D/M [tag (1-4294967295)]",
10008 NO_STR
10009 "External summary address\n"
10010 "Summary address prefix\n"
10011 "Router tag\n"
10012 "Router tag value\n")
10013 {
10014 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10015 struct prefix_ipv4 p;
10016 int idx = 2;
10017 route_tag_t tag = 0;
10018 int ret = OSPF_SUCCESS;
10019
10020 str2prefix_ipv4(argv[idx]->arg, &p);
10021
10022 if (is_default_prefix4(&p)) {
10023 vty_out(vty,
10024 "Default address shouldn't be configured as summary address.\n");
10025 return CMD_SUCCESS;
10026 }
10027
10028 /* Apply mask for given prefix. */
10029 apply_mask(&p);
10030
10031 if (!is_valid_summary_addr(&p)) {
10032 vty_out(vty, "Not a valid summary address.\n");
10033 return CMD_WARNING_CONFIG_FAILED;
10034 }
10035
10036 if (argc > 3)
10037 tag = strtoul(argv[idx + 2]->arg, NULL, 10);
10038
10039 ret = ospf_asbr_external_aggregator_unset(ospf, &p, tag);
10040 if (ret == OSPF_INVALID)
10041 vty_out(vty, "Invalid configuration!!\n");
10042
10043 return CMD_SUCCESS;
10044 }
10045
10046 DEFPY(no_ospf_gr_helper_planned_only,
10047 no_ospf_gr_helper_planned_only_cmd,
10048 "no graceful-restart helper planned-only",
10049 NO_STR
10050 "OSPF Graceful Restart\n"
10051 "OSPF GR Helper\n"
10052 "Supported only for planned restart\n")
10053 {
10054 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10055
10056 ospf_gr_helper_set_supported_planned_only_restart(ospf, OSPF_GR_FALSE);
10057
10058 return CMD_SUCCESS;
10059 }
10060
10061 static int ospf_print_vty_helper_dis_rtr_walkcb(struct hash_bucket *bucket,
10062 void *arg)
10063 {
10064 struct advRtr *rtr = bucket->data;
10065 struct vty *vty = (struct vty *)arg;
10066 static unsigned int count;
10067
10068 vty_out(vty, "%-6pI4,", &rtr->advRtrAddr);
10069 count++;
10070
10071 if (count % 5 == 0)
10072 vty_out(vty, "\n");
10073
10074 return HASHWALK_CONTINUE;
10075 }
10076
10077 static int ospf_print_json_helper_enabled_rtr_walkcb(struct hash_bucket *bucket,
10078 void *arg)
10079 {
10080 struct advRtr *rtr = bucket->data;
10081 struct json_object *json_rid_array = arg;
10082 struct json_object *json_rid;
10083
10084 json_rid = json_object_new_object();
10085
10086 json_object_string_addf(json_rid, "routerId", "%pI4", &rtr->advRtrAddr);
10087 json_object_array_add(json_rid_array, json_rid);
10088
10089 return HASHWALK_CONTINUE;
10090 }
10091
10092 static int ospf_show_gr_helper_details(struct vty *vty, struct ospf *ospf,
10093 uint8_t use_vrf, json_object *json,
10094 bool uj, bool detail)
10095 {
10096 struct listnode *node;
10097 struct ospf_interface *oi;
10098 char buf[PREFIX_STRLEN];
10099 json_object *json_vrf = NULL;
10100
10101 if (uj) {
10102 if (use_vrf)
10103 json_vrf = json_object_new_object();
10104 else
10105 json_vrf = json;
10106 }
10107
10108 if (ospf->instance) {
10109 if (uj)
10110 json_object_int_add(json, "ospfInstance",
10111 ospf->instance);
10112 else
10113 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
10114 }
10115
10116 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
10117
10118 if (uj) {
10119 if (use_vrf)
10120 json_object_object_add(json, ospf_get_name(ospf),
10121 json_vrf);
10122 } else
10123 vty_out(vty, "\n");
10124
10125 /* Show Router ID. */
10126 if (uj) {
10127 json_object_string_add(json_vrf, "routerId",
10128 inet_ntop(AF_INET, &ospf->router_id,
10129 buf, sizeof(buf)));
10130 } else {
10131 vty_out(vty, "\n OSPF Router with ID (%pI4)\n\n",
10132 &ospf->router_id);
10133 }
10134
10135 if (!uj) {
10136
10137 if (ospf->is_helper_supported)
10138 vty_out(vty,
10139 " Graceful restart helper support enabled.\n");
10140 else
10141 vty_out(vty,
10142 " Graceful restart helper support disabled.\n");
10143
10144 if (ospf->strict_lsa_check)
10145 vty_out(vty, " Strict LSA check is enabled.\n");
10146 else
10147 vty_out(vty, " Strict LSA check is disabled.\n");
10148
10149 if (ospf->only_planned_restart)
10150 vty_out(vty,
10151 " Helper supported for planned restarts only.\n");
10152 else
10153 vty_out(vty,
10154 " Helper supported for Planned and Unplanned Restarts.\n");
10155
10156 vty_out(vty,
10157 " Supported Graceful restart interval: %d(in seconds).\n",
10158 ospf->supported_grace_time);
10159
10160 if (OSPF_HELPER_ENABLE_RTR_COUNT(ospf)) {
10161 vty_out(vty, " Enable Router list:\n");
10162 vty_out(vty, " ");
10163 hash_walk(ospf->enable_rtr_list,
10164 ospf_print_vty_helper_dis_rtr_walkcb, vty);
10165 vty_out(vty, "\n\n");
10166 }
10167
10168 if (ospf->last_exit_reason != OSPF_GR_HELPER_EXIT_NONE) {
10169 vty_out(vty, " Last Helper exit Reason :%s\n",
10170 ospf_exit_reason2str(ospf->last_exit_reason));
10171 }
10172
10173 if (ospf->active_restarter_cnt)
10174 vty_out(vty,
10175 " Number of Active neighbours in graceful restart: %d\n",
10176 ospf->active_restarter_cnt);
10177 else
10178 vty_out(vty, "\n");
10179
10180 } else {
10181 json_object_string_add(
10182 json_vrf, "helperSupport",
10183 (ospf->is_helper_supported) ? "Enabled" : "Disabled");
10184 json_object_string_add(json_vrf, "strictLsaCheck",
10185 (ospf->strict_lsa_check) ? "Enabled"
10186 : "Disabled");
10187 json_object_string_add(
10188 json_vrf, "restartSupoort",
10189 (ospf->only_planned_restart)
10190 ? "Planned Restart only"
10191 : "Planned and Unplanned Restarts");
10192
10193 json_object_int_add(json_vrf, "supportedGracePeriod",
10194 ospf->supported_grace_time);
10195
10196 #if CONFDATE > 20230131
10197 CPP_NOTICE("Remove JSON object commands with keys starting with capital")
10198 #endif
10199 if (ospf->last_exit_reason != OSPF_GR_HELPER_EXIT_NONE) {
10200 json_object_string_add(
10201 json_vrf, "LastExitReason",
10202 ospf_exit_reason2str(ospf->last_exit_reason));
10203 json_object_string_add(
10204 json_vrf, "lastExitReason",
10205 ospf_exit_reason2str(ospf->last_exit_reason));
10206 }
10207
10208 if (ospf->active_restarter_cnt)
10209 json_object_int_add(json_vrf, "activeRestarterCnt",
10210 ospf->active_restarter_cnt);
10211
10212 if (OSPF_HELPER_ENABLE_RTR_COUNT(ospf)) {
10213 struct json_object *json_rid_array =
10214 json_object_new_array();
10215
10216 json_object_object_add(json_vrf, "enabledRouterIds",
10217 json_rid_array);
10218
10219 hash_walk(ospf->enable_rtr_list,
10220 ospf_print_json_helper_enabled_rtr_walkcb,
10221 json_rid_array);
10222 }
10223 }
10224
10225
10226 if (detail) {
10227 int cnt = 1;
10228 json_object *json_neighbors = NULL;
10229
10230 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
10231 struct route_node *rn;
10232 struct ospf_neighbor *nbr;
10233 json_object *json_neigh;
10234
10235 if (ospf_interface_neighbor_count(oi) == 0)
10236 continue;
10237
10238 if (uj) {
10239 json_object_object_get_ex(json_vrf, "Neighbors",
10240 &json_neighbors);
10241 json_object_object_get_ex(json_vrf, "neighbors",
10242 &json_neighbors);
10243 if (!json_neighbors) {
10244 json_neighbors =
10245 json_object_new_object();
10246 json_object_object_add(json_vrf,
10247 "Neighbors",
10248 json_neighbors);
10249 json_object_object_add(json_vrf,
10250 "neighbors",
10251 json_neighbors);
10252 }
10253 }
10254
10255 for (rn = route_top(oi->nbrs); rn;
10256 rn = route_next(rn)) {
10257
10258 if (!rn->info)
10259 continue;
10260
10261 nbr = rn->info;
10262
10263 if (!OSPF_GR_IS_ACTIVE_HELPER(nbr))
10264 continue;
10265
10266 if (!uj) {
10267 vty_out(vty, " Neighbour %d :\n", cnt);
10268 vty_out(vty, " Address : %pI4\n",
10269 &nbr->address.u.prefix4);
10270 vty_out(vty, " Routerid : %pI4\n",
10271 &nbr->router_id);
10272 vty_out(vty,
10273 " Received Grace period : %d(in seconds).\n",
10274 nbr->gr_helper_info
10275 .recvd_grace_period);
10276 vty_out(vty,
10277 " Actual Grace period : %d(in seconds)\n",
10278 nbr->gr_helper_info
10279 .actual_grace_period);
10280 vty_out(vty,
10281 " Remaining GraceTime:%ld(in seconds).\n",
10282 thread_timer_remain_second(
10283 nbr->gr_helper_info
10284 .t_grace_timer));
10285 vty_out(vty,
10286 " Graceful Restart reason: %s.\n\n",
10287 ospf_restart_reason2str(
10288 nbr->gr_helper_info
10289 .gr_restart_reason));
10290 cnt++;
10291 } else {
10292 json_neigh = json_object_new_object();
10293 json_object_string_add(
10294 json_neigh, "srcAddr",
10295 inet_ntop(AF_INET, &nbr->src,
10296 buf, sizeof(buf)));
10297
10298 json_object_string_add(
10299 json_neigh, "routerid",
10300 inet_ntop(AF_INET,
10301 &nbr->router_id,
10302 buf, sizeof(buf)));
10303 json_object_int_add(
10304 json_neigh,
10305 "recvdGraceInterval",
10306 nbr->gr_helper_info
10307 .recvd_grace_period);
10308 json_object_int_add(
10309 json_neigh,
10310 "actualGraceInterval",
10311 nbr->gr_helper_info
10312 .actual_grace_period);
10313 json_object_int_add(
10314 json_neigh, "remainGracetime",
10315 thread_timer_remain_second(
10316 nbr->gr_helper_info
10317 .t_grace_timer));
10318 json_object_string_add(
10319 json_neigh, "restartReason",
10320 ospf_restart_reason2str(
10321 nbr->gr_helper_info
10322 .gr_restart_reason));
10323 json_object_object_add(
10324 json_neighbors,
10325 inet_ntop(AF_INET, &nbr->src,
10326 buf, sizeof(buf)),
10327 json_neigh);
10328 }
10329 }
10330 }
10331 }
10332 return CMD_SUCCESS;
10333 }
10334
10335 DEFUN (ospf_external_route_aggregation_no_adrvertise,
10336 ospf_external_route_aggregation_no_adrvertise_cmd,
10337 "summary-address A.B.C.D/M no-advertise",
10338 "External summary address\n"
10339 "Summary address prefix\n"
10340 "Don't advertise summary route \n")
10341 {
10342 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10343 struct prefix_ipv4 p;
10344 int idx = 1;
10345 int ret = OSPF_SUCCESS;
10346
10347 str2prefix_ipv4(argv[idx]->arg, &p);
10348
10349 if (is_default_prefix4(&p)) {
10350 vty_out(vty,
10351 "Default address shouldn't be configured as summary address.\n");
10352 return CMD_SUCCESS;
10353 }
10354
10355 /* Apply mask for given prefix. */
10356 apply_mask(&p);
10357
10358 if (!is_valid_summary_addr(&p)) {
10359 vty_out(vty, "Not a valid summary address.\n");
10360 return CMD_WARNING_CONFIG_FAILED;
10361 }
10362
10363 ret = ospf_asbr_external_rt_no_advertise(ospf, &p);
10364 if (ret == OSPF_INVALID)
10365 vty_out(vty, "Invalid configuration!!\n");
10366
10367 return CMD_SUCCESS;
10368 }
10369
10370 DEFUN (no_ospf_external_route_aggregation_no_adrvertise,
10371 no_ospf_external_route_aggregation_no_adrvertise_cmd,
10372 "no summary-address A.B.C.D/M no-advertise",
10373 NO_STR
10374 "External summary address\n"
10375 "Summary address prefix\n"
10376 "Advertise summary route to the AS \n")
10377 {
10378 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10379 struct prefix_ipv4 p;
10380 int idx = 2;
10381 int ret = OSPF_SUCCESS;
10382
10383 str2prefix_ipv4(argv[idx]->arg, &p);
10384
10385 if (is_default_prefix4(&p)) {
10386 vty_out(vty,
10387 "Default address shouldn't be configured as summary address.\n");
10388 return CMD_SUCCESS;
10389 }
10390
10391 /* Apply mask for given prefix. */
10392 apply_mask(&p);
10393
10394 if (!is_valid_summary_addr(&p)) {
10395 vty_out(vty, "Not a valid summary address.\n");
10396 return CMD_WARNING_CONFIG_FAILED;
10397 }
10398
10399 ret = ospf_asbr_external_rt_advertise(ospf, &p);
10400 if (ret == OSPF_INVALID)
10401 vty_out(vty, "Invalid configuration!!\n");
10402
10403 return CMD_SUCCESS;
10404 }
10405
10406 DEFUN (ospf_route_aggregation_timer,
10407 ospf_route_aggregation_timer_cmd,
10408 "aggregation timer (5-1800)",
10409 "External route aggregation\n"
10410 "Delay timer (in seconds)\n"
10411 "Timer interval(in seconds)\n")
10412 {
10413 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10414 uint16_t interval = 0;
10415
10416 interval = strtoul(argv[2]->arg, NULL, 10);
10417
10418 ospf_external_aggregator_timer_set(ospf, interval);
10419
10420 return CMD_SUCCESS;
10421 }
10422
10423 DEFPY (show_ip_ospf_gr_helper,
10424 show_ip_ospf_gr_helper_cmd,
10425 "show ip ospf [vrf <NAME|all>] graceful-restart helper [detail] [json]",
10426 SHOW_STR
10427 IP_STR
10428 "OSPF information\n"
10429 VRF_CMD_HELP_STR
10430 "All VRFs\n"
10431 "OSPF Graceful Restart\n"
10432 "Helper details in the router\n"
10433 "Detailed information\n"
10434 JSON_STR)
10435 {
10436 char *vrf_name = NULL;
10437 bool all_vrf = false;
10438 int ret = CMD_SUCCESS;
10439 int idx_vrf = 0;
10440 int idx = 0;
10441 uint8_t use_vrf = 0;
10442 bool uj = use_json(argc, argv);
10443 struct ospf *ospf = NULL;
10444 json_object *json = NULL;
10445 struct listnode *node = NULL;
10446 int inst = 0;
10447 bool detail = false;
10448
10449 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
10450
10451 if (argv_find(argv, argc, "detail", &idx))
10452 detail = true;
10453
10454 if (uj)
10455 json = json_object_new_object();
10456
10457 /* vrf input is provided */
10458 if (vrf_name) {
10459 use_vrf = 1;
10460
10461 if (all_vrf) {
10462 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
10463 if (!ospf->oi_running)
10464 continue;
10465
10466 ret = ospf_show_gr_helper_details(
10467 vty, ospf, use_vrf, json, uj, detail);
10468 }
10469
10470 if (uj)
10471 vty_json(vty, json);
10472
10473 return ret;
10474 }
10475
10476 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
10477
10478 if (ospf == NULL || !ospf->oi_running) {
10479
10480 if (uj)
10481 vty_json(vty, json);
10482 else
10483 vty_out(vty,
10484 "%% OSPF is not enabled in vrf %s\n",
10485 vrf_name);
10486
10487 return CMD_SUCCESS;
10488 }
10489
10490 } else {
10491 /* Default Vrf */
10492 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
10493
10494 if (ospf == NULL || !ospf->oi_running) {
10495
10496 if (uj)
10497 vty_json(vty, json);
10498 else
10499 vty_out(vty,
10500 "%% OSPF is not enabled in vrf default\n");
10501
10502 return CMD_SUCCESS;
10503 }
10504
10505 ospf_show_gr_helper_details(vty, ospf, use_vrf, json, uj,
10506 detail);
10507 }
10508
10509 if (uj)
10510 vty_json(vty, json);
10511
10512 return CMD_SUCCESS;
10513 }
10514 /* Graceful Restart HELPER commands end */
10515 DEFUN (no_ospf_route_aggregation_timer,
10516 no_ospf_route_aggregation_timer_cmd,
10517 "no aggregation timer",
10518 NO_STR
10519 "External route aggregation\n"
10520 "Delay timer\n")
10521 {
10522 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
10523
10524 ospf_external_aggregator_timer_set(ospf, OSPF_EXTL_AGGR_DEFAULT_DELAY);
10525
10526 return CMD_SUCCESS;
10527 }
10528
10529 /* External Route Aggregation End */
10530
10531 static void config_write_stub_router(struct vty *vty, struct ospf *ospf)
10532 {
10533 struct listnode *ln;
10534 struct ospf_area *area;
10535
10536 if (ospf->stub_router_startup_time != OSPF_STUB_ROUTER_UNCONFIGURED)
10537 vty_out(vty, " max-metric router-lsa on-startup %u\n",
10538 ospf->stub_router_startup_time);
10539 if (ospf->stub_router_shutdown_time != OSPF_STUB_ROUTER_UNCONFIGURED)
10540 vty_out(vty, " max-metric router-lsa on-shutdown %u\n",
10541 ospf->stub_router_shutdown_time);
10542 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
10543 if (CHECK_FLAG(area->stub_router_state,
10544 OSPF_AREA_ADMIN_STUB_ROUTED)) {
10545 vty_out(vty, " max-metric router-lsa administrative\n");
10546 break;
10547 }
10548 }
10549 return;
10550 }
10551
10552 #if CONFDATE > 20230131
10553 CPP_NOTICE("Remove JSON object commands with keys containing whitespaces")
10554 #endif
10555 static void show_ip_ospf_route_network(struct vty *vty, struct ospf *ospf,
10556 struct route_table *rt,
10557 json_object *json)
10558 {
10559 struct route_node *rn;
10560 struct ospf_route * or ;
10561 struct listnode *pnode, *pnnode;
10562 struct ospf_path *path;
10563 json_object *json_route = NULL, *json_nexthop_array = NULL,
10564 *json_nexthop = NULL;
10565
10566 if (!json)
10567 vty_out(vty,
10568 "============ OSPF network routing table ============\n");
10569
10570 for (rn = route_top(rt); rn; rn = route_next(rn)) {
10571 char buf1[PREFIX2STR_BUFFER];
10572
10573 if ((or = rn->info) == NULL)
10574 continue;
10575
10576 prefix2str(&rn->p, buf1, sizeof(buf1));
10577
10578 if (json) {
10579 json_route = json_object_new_object();
10580 json_object_object_add(json, buf1, json_route);
10581 }
10582
10583 switch (or->path_type) {
10584 case OSPF_PATH_INTER_AREA:
10585 if (or->type == OSPF_DESTINATION_NETWORK) {
10586 if (json) {
10587 json_object_string_add(json_route,
10588 "routeType",
10589 "N IA");
10590 json_object_int_add(json_route, "cost",
10591 or->cost);
10592 json_object_string_addf(
10593 json_route, "area", "%pI4",
10594 &or->u.std.area_id);
10595 } else {
10596 vty_out(vty,
10597 "N IA %-18s [%d] area: %pI4\n",
10598 buf1, or->cost,
10599 &or->u.std.area_id);
10600 }
10601 } else if (or->type == OSPF_DESTINATION_DISCARD) {
10602 if (json) {
10603 json_object_string_add(json_route,
10604 "routeType",
10605 "D IA");
10606 } else {
10607 vty_out(vty,
10608 "D IA %-18s Discard entry\n",
10609 buf1);
10610 }
10611 }
10612 break;
10613 case OSPF_PATH_INTRA_AREA:
10614 if (json) {
10615 json_object_string_add(json_route, "routeType",
10616 "N");
10617 json_object_int_add(json_route, "cost",
10618 or->cost);
10619 json_object_string_addf(json_route, "area",
10620 "%pI4",
10621 &or->u.std.area_id);
10622 } else {
10623 vty_out(vty, "N %-18s [%d] area: %pI4\n",
10624 buf1, or->cost,
10625 &or->u.std.area_id);
10626 }
10627 break;
10628 default:
10629 break;
10630 }
10631
10632 if (or->type == OSPF_DESTINATION_NETWORK) {
10633 if (json) {
10634 json_nexthop_array = json_object_new_array();
10635 json_object_object_add(json_route, "nexthops",
10636 json_nexthop_array);
10637 }
10638
10639 for (ALL_LIST_ELEMENTS(or->paths, pnode, pnnode,
10640 path)) {
10641 if (json) {
10642 json_nexthop = json_object_new_object();
10643 json_object_array_add(
10644 json_nexthop_array,
10645 json_nexthop);
10646 }
10647 if (if_lookup_by_index(path->ifindex,
10648 ospf->vrf_id)) {
10649
10650 if (path->nexthop.s_addr
10651 == INADDR_ANY) {
10652 if (json) {
10653 json_object_string_add(
10654 json_nexthop,
10655 "ip", " ");
10656 json_object_string_add(
10657 json_nexthop,
10658 "directly attached to",
10659 ifindex2ifname(
10660 path->ifindex,
10661 ospf->vrf_id));
10662 json_object_string_add(
10663 json_nexthop,
10664 "directlyAttachedTo",
10665 ifindex2ifname(
10666 path->ifindex,
10667 ospf->vrf_id));
10668 } else {
10669 vty_out(vty,
10670 "%24s directly attached to %s\n",
10671 "",
10672 ifindex2ifname(
10673 path->ifindex,
10674 ospf->vrf_id));
10675 }
10676 } else {
10677 if (json) {
10678 json_object_string_addf(
10679 json_nexthop,
10680 "ip", "%pI4",
10681 &path->nexthop);
10682 json_object_string_add(
10683 json_nexthop,
10684 "via",
10685 ifindex2ifname(
10686 path->ifindex,
10687 ospf->vrf_id));
10688 } else {
10689 vty_out(vty,
10690 "%24s via %pI4, %s\n",
10691 "",
10692 &path->nexthop,
10693 ifindex2ifname(
10694 path->ifindex,
10695 ospf->vrf_id));
10696 }
10697 }
10698 }
10699 }
10700 }
10701 }
10702 if (!json)
10703 vty_out(vty, "\n");
10704 }
10705
10706 static void show_ip_ospf_route_router(struct vty *vty, struct ospf *ospf,
10707 struct route_table *rtrs,
10708 json_object *json)
10709 {
10710 struct route_node *rn;
10711 struct ospf_route * or ;
10712 struct listnode *pnode;
10713 struct listnode *node;
10714 struct ospf_path *path;
10715 char buf[PREFIX_STRLEN];
10716 json_object *json_route = NULL, *json_nexthop_array = NULL,
10717 *json_nexthop = NULL;
10718
10719 if (!json)
10720 vty_out(vty, "============ OSPF %s table =============\n",
10721 ospf->all_rtrs == rtrs ? "reachable routers"
10722 : "router routing");
10723
10724 for (rn = route_top(rtrs); rn; rn = route_next(rn)) {
10725 if (rn->info == NULL)
10726 continue;
10727 int flag = 0;
10728
10729 if (json) {
10730 json_route = json_object_new_object();
10731 json_object_object_add(
10732 json, inet_ntop(AF_INET, &rn->p.u.prefix4,
10733 buf, sizeof(buf)),
10734 json_route);
10735 json_object_string_add(json_route, "routeType", "R ");
10736 } else {
10737 vty_out(vty, "R %-15pI4 ",
10738 &rn->p.u.prefix4);
10739 }
10740
10741 for (ALL_LIST_ELEMENTS_RO((struct list *)rn->info, node, or)) {
10742 if (flag++) {
10743 if (!json)
10744 vty_out(vty, "%24s", "");
10745 }
10746
10747 /* Show path. */
10748 if (json) {
10749 json_object_int_add(json_route, "cost",
10750 or->cost);
10751 json_object_string_addf(json_route, "area",
10752 "%pI4",
10753 &or->u.std.area_id);
10754 if (or->path_type == OSPF_PATH_INTER_AREA) {
10755 json_object_boolean_true_add(json_route,
10756 "IA");
10757 json_object_boolean_true_add(json_route,
10758 "ia");
10759 }
10760 if (or->u.std.flags & ROUTER_LSA_BORDER)
10761 json_object_string_add(json_route,
10762 "routerType",
10763 "abr");
10764 else if (or->u.std.flags & ROUTER_LSA_EXTERNAL)
10765 json_object_string_add(json_route,
10766 "routerType",
10767 "asbr");
10768 } else {
10769 vty_out(vty, "%s [%d] area: %pI4",
10770 (or->path_type == OSPF_PATH_INTER_AREA
10771 ? "IA"
10772 : " "),
10773 or->cost, &or->u.std.area_id);
10774 /* Show flags. */
10775 vty_out(vty, "%s%s\n",
10776 (or->u.std.flags & ROUTER_LSA_BORDER
10777 ? ", ABR"
10778 : ""),
10779 (or->u.std.flags & ROUTER_LSA_EXTERNAL
10780 ? ", ASBR"
10781 : ""));
10782 }
10783
10784 if (json) {
10785 json_nexthop_array = json_object_new_array();
10786 json_object_object_add(json_route, "nexthops",
10787 json_nexthop_array);
10788 }
10789
10790 for (ALL_LIST_ELEMENTS_RO(or->paths, pnode, path)) {
10791 if (json) {
10792 json_nexthop = json_object_new_object();
10793 json_object_array_add(
10794 json_nexthop_array,
10795 json_nexthop);
10796 }
10797 if (if_lookup_by_index(path->ifindex,
10798 ospf->vrf_id)) {
10799 if (path->nexthop.s_addr
10800 == INADDR_ANY) {
10801 if (json) {
10802 json_object_string_add(
10803 json_nexthop,
10804 "ip", " ");
10805 json_object_string_add(
10806 json_nexthop,
10807 "directly attached to",
10808 ifindex2ifname(
10809 path->ifindex,
10810 ospf->vrf_id));
10811 json_object_string_add(
10812 json_nexthop,
10813 "directlyAttachedTo",
10814 ifindex2ifname(
10815 path->ifindex,
10816 ospf->vrf_id));
10817 } else {
10818 vty_out(vty,
10819 "%24s directly attached to %s\n",
10820 "",
10821 ifindex2ifname(
10822 path->ifindex,
10823 ospf->vrf_id));
10824 }
10825 } else {
10826 if (json) {
10827 json_object_string_addf(
10828 json_nexthop,
10829 "ip", "%pI4",
10830 &path->nexthop);
10831 json_object_string_add(
10832 json_nexthop,
10833 "via",
10834 ifindex2ifname(
10835 path->ifindex,
10836 ospf->vrf_id));
10837 } else {
10838 vty_out(vty,
10839 "%24s via %pI4, %s\n",
10840 "",
10841 &path->nexthop,
10842 ifindex2ifname(
10843 path->ifindex,
10844 ospf->vrf_id));
10845 }
10846 }
10847 }
10848 }
10849 }
10850 }
10851 if (!json)
10852 vty_out(vty, "\n");
10853 }
10854
10855 static void show_ip_ospf_route_external(struct vty *vty, struct ospf *ospf,
10856 struct route_table *rt,
10857 json_object *json)
10858 {
10859 struct route_node *rn;
10860 struct ospf_route *er;
10861 struct listnode *pnode, *pnnode;
10862 struct ospf_path *path;
10863 json_object *json_route = NULL, *json_nexthop_array = NULL,
10864 *json_nexthop = NULL;
10865
10866 if (!json)
10867 vty_out(vty,
10868 "============ OSPF external routing table ===========\n");
10869
10870 for (rn = route_top(rt); rn; rn = route_next(rn)) {
10871 if ((er = rn->info) == NULL)
10872 continue;
10873
10874 char buf1[19];
10875
10876 snprintfrr(buf1, sizeof(buf1), "%pFX", &rn->p);
10877 if (json) {
10878 json_route = json_object_new_object();
10879 json_object_object_add(json, buf1, json_route);
10880 }
10881
10882 switch (er->path_type) {
10883 case OSPF_PATH_TYPE1_EXTERNAL:
10884 if (json) {
10885 json_object_string_add(json_route, "routeType",
10886 "N E1");
10887 json_object_int_add(json_route, "cost",
10888 er->cost);
10889 json_object_int_add(json_route, "tag",
10890 er->u.ext.tag);
10891 } else {
10892 vty_out(vty,
10893 "N E1 %-18s [%d] tag: %" ROUTE_TAG_PRI
10894 "\n",
10895 buf1, er->cost, er->u.ext.tag);
10896 }
10897 break;
10898 case OSPF_PATH_TYPE2_EXTERNAL:
10899 if (json) {
10900 json_object_string_add(json_route, "routeType",
10901 "N E2");
10902 json_object_int_add(json_route, "cost",
10903 er->cost);
10904 json_object_int_add(json_route, "type2cost",
10905 er->u.ext.type2_cost);
10906 json_object_int_add(json_route, "tag",
10907 er->u.ext.tag);
10908 } else {
10909 vty_out(vty,
10910 "N E2 %-18s [%d/%d] tag: %" ROUTE_TAG_PRI
10911 "\n",
10912 buf1, er->cost, er->u.ext.type2_cost,
10913 er->u.ext.tag);
10914 }
10915 break;
10916 }
10917
10918 if (json) {
10919 json_nexthop_array = json_object_new_array();
10920 json_object_object_add(json_route, "nexthops",
10921 json_nexthop_array);
10922 }
10923
10924 for (ALL_LIST_ELEMENTS(er->paths, pnode, pnnode, path)) {
10925 if (json) {
10926 json_nexthop = json_object_new_object();
10927 json_object_array_add(json_nexthop_array,
10928 json_nexthop);
10929 }
10930
10931 if (if_lookup_by_index(path->ifindex, ospf->vrf_id)) {
10932 if (path->nexthop.s_addr == INADDR_ANY) {
10933 if (json) {
10934 json_object_string_add(
10935 json_nexthop, "ip",
10936 " ");
10937 json_object_string_add(
10938 json_nexthop,
10939 "directly attached to",
10940 ifindex2ifname(
10941 path->ifindex,
10942 ospf->vrf_id));
10943 json_object_string_add(
10944 json_nexthop,
10945 "directlyAttachedTo",
10946 ifindex2ifname(
10947 path->ifindex,
10948 ospf->vrf_id));
10949 } else {
10950 vty_out(vty,
10951 "%24s directly attached to %s\n",
10952 "",
10953 ifindex2ifname(
10954 path->ifindex,
10955 ospf->vrf_id));
10956 }
10957 } else {
10958 if (json) {
10959 json_object_string_addf(
10960 json_nexthop, "ip",
10961 "%pI4", &path->nexthop);
10962 json_object_string_add(
10963 json_nexthop, "via",
10964 ifindex2ifname(
10965 path->ifindex,
10966 ospf->vrf_id));
10967 } else {
10968 vty_out(vty,
10969 "%24s via %pI4, %s\n",
10970 "",
10971 &path->nexthop,
10972 ifindex2ifname(
10973 path->ifindex,
10974 ospf->vrf_id));
10975 }
10976 }
10977 }
10978 }
10979 }
10980 if (!json)
10981 vty_out(vty, "\n");
10982 }
10983
10984 static void show_ip_ospf_route_orr_root(struct vty *vty, struct ospf *ospf,
10985 struct orr_root *root, bool use_vrf)
10986 {
10987 if (ospf->instance)
10988 vty_out(vty, "\nOSPF Instance: %d\n", ospf->instance);
10989
10990 ospf_show_vrf_name(ospf, vty, NULL, use_vrf);
10991
10992 vty_out(vty, "ORR Group: %s\n", root->group_name);
10993 vty_out(vty, "Active Root: %pI4\n\n", &root->router_id);
10994 vty_out(vty, "SPF calculated from %pI4\n\n", &root->router_id);
10995
10996 if (root->new_table)
10997 show_ip_ospf_route_network(vty, ospf, root->new_table, NULL);
10998
10999 if (root->new_rtrs)
11000 show_ip_ospf_route_router(vty, ospf, root->new_rtrs, NULL);
11001
11002 vty_out(vty, "\n");
11003 }
11004
11005 static void show_ip_ospf_route_orr_common(struct vty *vty, struct ospf *ospf,
11006 const char *orr_group, bool use_vrf)
11007 {
11008 afi_t afi;
11009 safi_t safi;
11010 struct orr_root *root = NULL;
11011 struct listnode *node = NULL;
11012 struct list *orr_root_list = NULL;
11013
11014 if (!ospf->orr_spf_request)
11015 return;
11016
11017 FOREACH_AFI_SAFI (afi, safi) {
11018 orr_root_list = ospf->orr_root[afi][safi];
11019 if (!orr_root_list)
11020 continue;
11021 for (ALL_LIST_ELEMENTS_RO(orr_root_list, node, root)) {
11022 if (orr_group) {
11023 if (!strmatch(root->group_name, orr_group))
11024 continue;
11025 show_ip_ospf_route_orr_root(vty, ospf, root,
11026 use_vrf);
11027 } else
11028 show_ip_ospf_route_orr_root(vty, ospf, root,
11029 use_vrf);
11030 }
11031 }
11032 }
11033
11034 DEFPY (show_ip_ospf_instance_route_orr,
11035 show_ip_ospf_instance_route_orr_cmd,
11036 "show ip ospf (1-65535)$instance route orr [WORD$orr_group]",
11037 SHOW_STR
11038 IP_STR
11039 OSPF_STR
11040 "Instance ID\n"
11041 "OSPF routing table\n"
11042 "Optimal Route Reflection\n"
11043 "ORR Group name\n")
11044 {
11045 struct ospf *ospf;
11046
11047 if (instance != ospf_instance)
11048 return CMD_NOT_MY_INSTANCE;
11049
11050 ospf = ospf_lookup_instance(instance);
11051 if (!ospf || !ospf->oi_running)
11052 return CMD_SUCCESS;
11053
11054 show_ip_ospf_route_orr_common(vty, ospf, orr_group, false);
11055
11056 return CMD_SUCCESS;
11057 }
11058
11059 DEFPY (show_ip_ospf_route_orr,
11060 show_ip_ospf_route_orr_cmd,
11061 "show ip ospf [vrf <NAME$vrf_name|all$all_vrf>] route orr [WORD$orr_group]",
11062 SHOW_STR
11063 IP_STR
11064 OSPF_STR
11065 VRF_CMD_HELP_STR
11066 "All VRFs\n"
11067 "OSPF routing table\n"
11068 "Optimal Route Reflection\n"
11069 "ORR Group name\n")
11070 {
11071 struct ospf *ospf = NULL;
11072 struct listnode *node = NULL;
11073 int ret = CMD_SUCCESS;
11074 int inst = 0;
11075 bool use_vrf = vrf_name || all_vrf;
11076
11077 if (all_vrf) {
11078 bool ospf_output = false;
11079
11080 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11081 if (!ospf->oi_running)
11082 continue;
11083 ospf_output = true;
11084
11085 show_ip_ospf_route_orr_common(vty, ospf, orr_group,
11086 use_vrf);
11087 }
11088 if (!ospf_output)
11089 vty_out(vty, "%% OSPF is not enabled\n");
11090 return ret;
11091 }
11092
11093 if (vrf_name)
11094 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
11095 else
11096 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
11097
11098 if (!ospf || !ospf->oi_running) {
11099 vty_out(vty, "%% OSPF is not enabled in vrf %s\n",
11100 vrf_name ? vrf_name : "default");
11101 return CMD_SUCCESS;
11102 }
11103
11104 show_ip_ospf_route_orr_common(vty, ospf, orr_group, use_vrf);
11105
11106 return ret;
11107 }
11108
11109 static int show_ip_ospf_reachable_routers_common(struct vty *vty,
11110 struct ospf *ospf,
11111 uint8_t use_vrf)
11112 {
11113 if (ospf->instance)
11114 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
11115
11116 ospf_show_vrf_name(ospf, vty, NULL, use_vrf);
11117
11118 if (ospf->all_rtrs == NULL) {
11119 vty_out(vty, "No OSPF reachable router information exist\n");
11120 return CMD_SUCCESS;
11121 }
11122
11123 /* Show Router routes. */
11124 show_ip_ospf_route_router(vty, ospf, ospf->all_rtrs, NULL);
11125
11126 vty_out(vty, "\n");
11127
11128 return CMD_SUCCESS;
11129 }
11130
11131 DEFUN (show_ip_ospf_reachable_routers,
11132 show_ip_ospf_reachable_routers_cmd,
11133 "show ip ospf [vrf <NAME|all>] reachable-routers",
11134 SHOW_STR
11135 IP_STR
11136 "OSPF information\n"
11137 VRF_CMD_HELP_STR
11138 "All VRFs\n"
11139 "Show all the reachable OSPF routers\n")
11140 {
11141 struct ospf *ospf = NULL;
11142 struct listnode *node = NULL;
11143 char *vrf_name = NULL;
11144 bool all_vrf = false;
11145 int ret = CMD_SUCCESS;
11146 int inst = 0;
11147 int idx_vrf = 0;
11148 uint8_t use_vrf = 0;
11149
11150 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
11151
11152 if (vrf_name) {
11153 bool ospf_output = false;
11154
11155 use_vrf = 1;
11156
11157 if (all_vrf) {
11158 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11159 if (!ospf->oi_running)
11160 continue;
11161
11162 ospf_output = true;
11163 ret = show_ip_ospf_reachable_routers_common(
11164 vty, ospf, use_vrf);
11165 }
11166
11167 if (!ospf_output)
11168 vty_out(vty, "%% OSPF instance not found\n");
11169 } else {
11170 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
11171 if (ospf == NULL || !ospf->oi_running) {
11172 vty_out(vty, "%% OSPF instance not found\n");
11173 return CMD_SUCCESS;
11174 }
11175
11176 ret = show_ip_ospf_reachable_routers_common(vty, ospf,
11177 use_vrf);
11178 }
11179 } else {
11180 /* Display default ospf (instance 0) info */
11181 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
11182 if (ospf == NULL || !ospf->oi_running) {
11183 vty_out(vty, "%% OSPF instance not found\n");
11184 return CMD_SUCCESS;
11185 }
11186
11187 ret = show_ip_ospf_reachable_routers_common(vty, ospf, use_vrf);
11188 }
11189
11190 return ret;
11191 }
11192
11193 DEFUN (show_ip_ospf_instance_reachable_routers,
11194 show_ip_ospf_instance_reachable_routers_cmd,
11195 "show ip ospf (1-65535) reachable-routers",
11196 SHOW_STR
11197 IP_STR
11198 "OSPF information\n"
11199 "Instance ID\n"
11200 "Show all the reachable OSPF routers\n")
11201 {
11202 int idx_number = 3;
11203 struct ospf *ospf;
11204 unsigned short instance = 0;
11205
11206 instance = strtoul(argv[idx_number]->arg, NULL, 10);
11207 if (instance != ospf_instance)
11208 return CMD_NOT_MY_INSTANCE;
11209
11210 ospf = ospf_lookup_instance(instance);
11211 if (!ospf || !ospf->oi_running)
11212 return CMD_SUCCESS;
11213
11214 return show_ip_ospf_reachable_routers_common(vty, ospf, 0);
11215 }
11216
11217 static int show_ip_ospf_border_routers_common(struct vty *vty,
11218 struct ospf *ospf,
11219 uint8_t use_vrf)
11220 {
11221 if (ospf->instance)
11222 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
11223
11224 ospf_show_vrf_name(ospf, vty, NULL, use_vrf);
11225
11226 if (ospf->new_table == NULL) {
11227 vty_out(vty, "No OSPF routing information exist\n");
11228 return CMD_SUCCESS;
11229 }
11230
11231 /* Show Network routes.
11232 show_ip_ospf_route_network (vty, ospf->new_table); */
11233
11234 /* Show Router routes. */
11235 show_ip_ospf_route_router(vty, ospf, ospf->new_rtrs, NULL);
11236
11237 vty_out(vty, "\n");
11238
11239 return CMD_SUCCESS;
11240 }
11241
11242 DEFUN (show_ip_ospf_border_routers,
11243 show_ip_ospf_border_routers_cmd,
11244 "show ip ospf [vrf <NAME|all>] border-routers",
11245 SHOW_STR
11246 IP_STR
11247 "OSPF information\n"
11248 VRF_CMD_HELP_STR
11249 "All VRFs\n"
11250 "Show all the ABR's and ASBR's\n")
11251 {
11252 struct ospf *ospf = NULL;
11253 struct listnode *node = NULL;
11254 char *vrf_name = NULL;
11255 bool all_vrf = false;
11256 int ret = CMD_SUCCESS;
11257 int inst = 0;
11258 int idx_vrf = 0;
11259 uint8_t use_vrf = 0;
11260
11261 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
11262
11263 if (vrf_name) {
11264 bool ospf_output = false;
11265
11266 use_vrf = 1;
11267
11268 if (all_vrf) {
11269 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11270 if (!ospf->oi_running)
11271 continue;
11272
11273 ospf_output = true;
11274 ret = show_ip_ospf_border_routers_common(
11275 vty, ospf, use_vrf);
11276 }
11277
11278 if (!ospf_output)
11279 vty_out(vty, "%% OSPF is not enabled\n");
11280 } else {
11281 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
11282 if (ospf == NULL || !ospf->oi_running) {
11283 vty_out(vty,
11284 "%% OSPF is not enabled in vrf %s\n",
11285 vrf_name);
11286 return CMD_SUCCESS;
11287 }
11288
11289 ret = show_ip_ospf_border_routers_common(vty, ospf,
11290 use_vrf);
11291 }
11292 } else {
11293 /* Display default ospf (instance 0) info */
11294 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
11295 if (ospf == NULL || !ospf->oi_running) {
11296 vty_out(vty, "%% OSPF is not enabled in vrf default\n");
11297 return CMD_SUCCESS;
11298 }
11299
11300 ret = show_ip_ospf_border_routers_common(vty, ospf, use_vrf);
11301 }
11302
11303 return ret;
11304 }
11305
11306 DEFUN (show_ip_ospf_instance_border_routers,
11307 show_ip_ospf_instance_border_routers_cmd,
11308 "show ip ospf (1-65535) border-routers",
11309 SHOW_STR
11310 IP_STR
11311 "OSPF information\n"
11312 "Instance ID\n"
11313 "Show all the ABR's and ASBR's\n")
11314 {
11315 int idx_number = 3;
11316 struct ospf *ospf;
11317 unsigned short instance = 0;
11318
11319 instance = strtoul(argv[idx_number]->arg, NULL, 10);
11320 if (instance != ospf_instance)
11321 return CMD_NOT_MY_INSTANCE;
11322
11323 ospf = ospf_lookup_instance(instance);
11324 if (!ospf || !ospf->oi_running)
11325 return CMD_SUCCESS;
11326
11327 return show_ip_ospf_border_routers_common(vty, ospf, 0);
11328 }
11329
11330 static int show_ip_ospf_route_common(struct vty *vty, struct ospf *ospf,
11331 json_object *json, uint8_t use_vrf)
11332 {
11333 json_object *json_vrf = NULL;
11334
11335 if (ospf->instance)
11336 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
11337
11338
11339 if (json) {
11340 if (use_vrf)
11341 json_vrf = json_object_new_object();
11342 else
11343 json_vrf = json;
11344 }
11345
11346 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
11347
11348 if (ospf->new_table == NULL) {
11349 vty_out(vty, "No OSPF routing information exist\n");
11350 return CMD_SUCCESS;
11351 }
11352
11353 /* Show Network routes. */
11354 show_ip_ospf_route_network(vty, ospf, ospf->new_table, json_vrf);
11355
11356 /* Show Router routes. */
11357 show_ip_ospf_route_router(vty, ospf, ospf->new_rtrs, json_vrf);
11358
11359 /* Show Router routes. */
11360 if (ospf->all_rtrs)
11361 show_ip_ospf_route_router(vty, ospf, ospf->all_rtrs, json_vrf);
11362
11363 /* Show AS External routes. */
11364 show_ip_ospf_route_external(vty, ospf, ospf->old_external_route,
11365 json_vrf);
11366
11367 if (json) {
11368 if (use_vrf) {
11369 // json_object_object_add(json_vrf, "areas",
11370 // json_areas);
11371 json_object_object_add(json, ospf_get_name(ospf),
11372 json_vrf);
11373 }
11374 } else {
11375 vty_out(vty, "\n");
11376 }
11377
11378 return CMD_SUCCESS;
11379 }
11380
11381 DEFUN (show_ip_ospf_route,
11382 show_ip_ospf_route_cmd,
11383 "show ip ospf [vrf <NAME|all>] route [json]",
11384 SHOW_STR
11385 IP_STR
11386 "OSPF information\n"
11387 VRF_CMD_HELP_STR
11388 "All VRFs\n"
11389 "OSPF routing table\n"
11390 JSON_STR)
11391 {
11392 struct ospf *ospf = NULL;
11393 struct listnode *node = NULL;
11394 char *vrf_name = NULL;
11395 bool all_vrf = false;
11396 int ret = CMD_SUCCESS;
11397 int inst = 0;
11398 int idx_vrf = 0;
11399 uint8_t use_vrf = 0;
11400 bool uj = use_json(argc, argv);
11401 json_object *json = NULL;
11402
11403 if (uj)
11404 json = json_object_new_object();
11405
11406 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
11407
11408 /* vrf input is provided could be all or specific vrf*/
11409 if (vrf_name) {
11410 bool ospf_output = false;
11411
11412 use_vrf = 1;
11413
11414 if (all_vrf) {
11415 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11416 if (!ospf->oi_running)
11417 continue;
11418 ospf_output = true;
11419 ret = show_ip_ospf_route_common(vty, ospf, json,
11420 use_vrf);
11421 }
11422
11423 if (uj) {
11424 /* Keep Non-pretty format */
11425 vty_json(vty, json);
11426 } else if (!ospf_output)
11427 vty_out(vty, "%% OSPF is not enabled\n");
11428
11429 return ret;
11430 }
11431 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
11432 if (ospf == NULL || !ospf->oi_running) {
11433 if (uj)
11434 vty_json(vty, json);
11435 else
11436 vty_out(vty,
11437 "%% OSPF is not enabled in vrf %s\n",
11438 vrf_name);
11439
11440 return CMD_SUCCESS;
11441 }
11442 } else {
11443 /* Display default ospf (instance 0) info */
11444 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
11445 if (ospf == NULL || !ospf->oi_running) {
11446 if (uj)
11447 vty_json(vty, json);
11448 else
11449 vty_out(vty,
11450 "%% OSPF is not enabled in vrf default\n");
11451
11452 return CMD_SUCCESS;
11453 }
11454 }
11455
11456 if (ospf) {
11457 ret = show_ip_ospf_route_common(vty, ospf, json, use_vrf);
11458 /* Keep Non-pretty format */
11459 if (uj)
11460 vty_out(vty, "%s\n",
11461 json_object_to_json_string_ext(
11462 json, JSON_C_TO_STRING_NOSLASHESCAPE));
11463 }
11464
11465 if (uj)
11466 json_object_free(json);
11467
11468 return ret;
11469 }
11470
11471 DEFUN (show_ip_ospf_instance_route,
11472 show_ip_ospf_instance_route_cmd,
11473 "show ip ospf (1-65535) route",
11474 SHOW_STR
11475 IP_STR
11476 "OSPF information\n"
11477 "Instance ID\n"
11478 "OSPF routing table\n")
11479 {
11480 int idx_number = 3;
11481 struct ospf *ospf;
11482 unsigned short instance = 0;
11483
11484 instance = strtoul(argv[idx_number]->arg, NULL, 10);
11485 if (instance != ospf_instance)
11486 return CMD_NOT_MY_INSTANCE;
11487
11488 ospf = ospf_lookup_instance(instance);
11489 if (!ospf || !ospf->oi_running)
11490 return CMD_SUCCESS;
11491
11492 return show_ip_ospf_route_common(vty, ospf, NULL, 0);
11493 }
11494
11495
11496 DEFUN (show_ip_ospf_vrfs,
11497 show_ip_ospf_vrfs_cmd,
11498 "show ip ospf vrfs [json]",
11499 SHOW_STR
11500 IP_STR
11501 "OSPF information\n"
11502 "Show OSPF VRFs \n"
11503 JSON_STR)
11504 {
11505 bool uj = use_json(argc, argv);
11506 json_object *json = NULL;
11507 json_object *json_vrfs = NULL;
11508 struct ospf *ospf = NULL;
11509 struct listnode *node = NULL;
11510 int count = 0;
11511 static const char header[] = "Name Id RouterId ";
11512
11513 if (uj) {
11514 json = json_object_new_object();
11515 json_vrfs = json_object_new_object();
11516 }
11517
11518 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11519 json_object *json_vrf = NULL;
11520 const char *name = NULL;
11521 int64_t vrf_id_ui = 0;
11522
11523 count++;
11524
11525 if (!uj && count == 1)
11526 vty_out(vty, "%s\n", header);
11527 if (uj)
11528 json_vrf = json_object_new_object();
11529
11530 name = ospf_get_name(ospf);
11531
11532 vrf_id_ui = (ospf->vrf_id == VRF_UNKNOWN)
11533 ? -1
11534 : (int64_t)ospf->vrf_id;
11535
11536 if (uj) {
11537 json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
11538 json_object_string_addf(json_vrf, "routerId", "%pI4",
11539 &ospf->router_id);
11540
11541 json_object_object_add(json_vrfs, name, json_vrf);
11542
11543 } else {
11544 vty_out(vty, "%-25s %-5d %-16pI4 \n", name,
11545 ospf->vrf_id, &ospf->router_id);
11546 }
11547 }
11548
11549 if (uj) {
11550 json_object_object_add(json, "vrfs", json_vrfs);
11551 json_object_int_add(json, "totalVrfs", count);
11552
11553 vty_json(vty, json);
11554 } else {
11555 if (count)
11556 vty_out(vty, "\nTotal number of OSPF VRFs: %d\n",
11557 count);
11558 }
11559
11560 return CMD_SUCCESS;
11561 }
11562 DEFPY (clear_ip_ospf_neighbor,
11563 clear_ip_ospf_neighbor_cmd,
11564 "clear ip ospf [(1-65535)]$instance neighbor [A.B.C.D$nbr_id]",
11565 CLEAR_STR
11566 IP_STR
11567 "OSPF information\n"
11568 "Instance ID\n"
11569 "Reset OSPF Neighbor\n"
11570 "Neighbor ID\n")
11571 {
11572 struct listnode *node;
11573 struct ospf *ospf = NULL;
11574
11575 /* If user does not specify the arguments,
11576 * instance = 0 and nbr_id = 0.0.0.0
11577 */
11578 if (instance != 0) {
11579 /* This means clear only the particular ospf process */
11580 if (instance != ospf_instance)
11581 return CMD_NOT_MY_INSTANCE;
11582 }
11583
11584 /* Clear all the ospf processes */
11585 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11586 if (!ospf->oi_running)
11587 continue;
11588
11589 if (nbr_id_str && IPV4_ADDR_SAME(&ospf->router_id, &nbr_id)) {
11590 vty_out(vty, "Self router-id is not allowed.\r\n ");
11591 return CMD_SUCCESS;
11592 }
11593
11594 ospf_neighbor_reset(ospf, nbr_id, nbr_id_str);
11595 }
11596
11597 return CMD_SUCCESS;
11598 }
11599
11600 DEFPY (clear_ip_ospf_process,
11601 clear_ip_ospf_process_cmd,
11602 "clear ip ospf [(1-65535)]$instance process",
11603 CLEAR_STR
11604 IP_STR
11605 "OSPF information\n"
11606 "Instance ID\n"
11607 "Reset OSPF Process\n")
11608 {
11609 struct listnode *node;
11610 struct ospf *ospf = NULL;
11611
11612 /* Check if instance is not passed as an argument */
11613 if (instance != 0) {
11614 /* This means clear only the particular ospf process */
11615 if (instance != ospf_instance)
11616 return CMD_NOT_MY_INSTANCE;
11617 }
11618
11619 /* Clear all the ospf processes */
11620 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11621 if (!ospf->oi_running)
11622 continue;
11623
11624 ospf_process_reset(ospf);
11625 }
11626
11627 return CMD_SUCCESS;
11628 }
11629
11630 static const char *const ospf_abr_type_str[] = {
11631 "unknown", "standard", "ibm", "cisco", "shortcut"
11632 };
11633
11634 static const char *const ospf_shortcut_mode_str[] = {
11635 "default", "enable", "disable"
11636 };
11637 static int ospf_vty_external_rt_walkcb(struct hash_bucket *bucket,
11638 void *arg)
11639 {
11640 struct external_info *ei = bucket->data;
11641 struct vty *vty = (struct vty *)arg;
11642 static unsigned int count;
11643
11644 vty_out(vty, "%-4pI4/%d, ", &ei->p.prefix, ei->p.prefixlen);
11645 count++;
11646
11647 if (count % 5 == 0)
11648 vty_out(vty, "\n");
11649
11650 if (OSPF_EXTERNAL_RT_COUNT(ei->aggr_route) == count)
11651 count = 0;
11652
11653 return HASHWALK_CONTINUE;
11654 }
11655
11656 static int ospf_json_external_rt_walkcb(struct hash_bucket *bucket,
11657 void *arg)
11658 {
11659 struct external_info *ei = bucket->data;
11660 struct json_object *json = (struct json_object *)arg;
11661 char buf[PREFIX2STR_BUFFER];
11662 char exnalbuf[20];
11663 static unsigned int count;
11664
11665 prefix2str(&ei->p, buf, sizeof(buf));
11666
11667 snprintf(exnalbuf, 20, "Exnl Addr-%d", count);
11668
11669 json_object_string_add(json, exnalbuf, buf);
11670
11671 count++;
11672
11673 if (OSPF_EXTERNAL_RT_COUNT(ei->aggr_route) == count)
11674 count = 0;
11675
11676 return HASHWALK_CONTINUE;
11677 }
11678
11679 static int ospf_show_summary_address(struct vty *vty, struct ospf *ospf,
11680 uint8_t use_vrf, json_object *json,
11681 bool uj, bool detail)
11682 {
11683 struct route_node *rn;
11684 json_object *json_vrf = NULL;
11685 int mtype = 0;
11686 int mval = 0;
11687 static char header[] =
11688 "Summary-address Metric-type Metric Tag External_Rt_count\n";
11689
11690 mtype = metric_type(ospf, 0, ospf->instance);
11691 mval = metric_value(ospf, 0, ospf->instance);
11692
11693 if (!uj)
11694 vty_out(vty, "%s\n", header);
11695
11696 if (uj) {
11697 if (use_vrf)
11698 json_vrf = json_object_new_object();
11699 else
11700 json_vrf = json;
11701 }
11702
11703 if (ospf->instance) {
11704 if (uj)
11705 json_object_int_add(json, "ospfInstance",
11706 ospf->instance);
11707 else
11708 vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
11709 }
11710
11711 ospf_show_vrf_name(ospf, vty, json_vrf, use_vrf);
11712
11713 if (!uj) {
11714 vty_out(vty, "aggregation delay interval :%u(in seconds)\n\n",
11715 ospf->aggr_delay_interval);
11716 } else {
11717 json_object_int_add(json_vrf, "aggregation delay interval",
11718 ospf->aggr_delay_interval);
11719 json_object_int_add(json_vrf, "aggregationDelayInterval",
11720 ospf->aggr_delay_interval);
11721 }
11722
11723 for (rn = route_top(ospf->rt_aggr_tbl); rn; rn = route_next(rn))
11724 if (rn->info) {
11725 struct ospf_external_aggr_rt *aggr = rn->info;
11726 json_object *json_aggr = NULL;
11727 char buf[PREFIX2STR_BUFFER];
11728
11729 prefix2str(&aggr->p, buf, sizeof(buf));
11730
11731 if (uj) {
11732
11733 json_aggr = json_object_new_object();
11734
11735 json_object_object_add(json_vrf, buf,
11736 json_aggr);
11737
11738 json_object_string_add(json_aggr,
11739 "Summary address", buf);
11740 json_object_string_add(json_aggr,
11741 "summaryAddress", buf);
11742
11743 json_object_string_add(
11744 json_aggr, "Metric-type",
11745 (mtype == EXTERNAL_METRIC_TYPE_1)
11746 ? "E1"
11747 : "E2");
11748 json_object_string_add(
11749 json_aggr, "metricType",
11750 (mtype == EXTERNAL_METRIC_TYPE_1)
11751 ? "E1"
11752 : "E2");
11753
11754 #if CONFDATE > 20230131
11755 CPP_NOTICE("Remove JSON object commands with keys starting with capital")
11756 #endif
11757 json_object_int_add(json_aggr, "Metric", mval);
11758 json_object_int_add(json_aggr, "metric", mval);
11759
11760 json_object_int_add(json_aggr, "Tag",
11761 aggr->tag);
11762 json_object_int_add(json_aggr, "tag",
11763 aggr->tag);
11764
11765 json_object_int_add(
11766 json_aggr, "External route count",
11767 OSPF_EXTERNAL_RT_COUNT(aggr));
11768 json_object_int_add(
11769 json_aggr, "externalRouteCount",
11770 OSPF_EXTERNAL_RT_COUNT(aggr));
11771
11772 if (OSPF_EXTERNAL_RT_COUNT(aggr) && detail) {
11773 hash_walk(
11774 aggr->match_extnl_hash,
11775 ospf_json_external_rt_walkcb,
11776 json_aggr);
11777 }
11778
11779 } else {
11780 vty_out(vty, "%-20s", buf);
11781
11782 (mtype == EXTERNAL_METRIC_TYPE_1)
11783 ? vty_out(vty, "%-16s", "E1")
11784 : vty_out(vty, "%-16s", "E2");
11785 vty_out(vty, "%-11d", mval);
11786
11787 vty_out(vty, "%-12u", aggr->tag);
11788
11789 vty_out(vty, "%-5ld\n",
11790 OSPF_EXTERNAL_RT_COUNT(aggr));
11791
11792 if (OSPF_EXTERNAL_RT_COUNT(aggr) && detail) {
11793 vty_out(vty,
11794 "Matched External routes:\n");
11795 hash_walk(
11796 aggr->match_extnl_hash,
11797 ospf_vty_external_rt_walkcb,
11798 vty);
11799 vty_out(vty, "\n");
11800 }
11801
11802 vty_out(vty, "\n");
11803 }
11804 }
11805
11806 if (uj) {
11807 if (use_vrf)
11808 json_object_object_add(json, ospf_get_name(ospf),
11809 json_vrf);
11810 } else
11811 vty_out(vty, "\n");
11812
11813 return CMD_SUCCESS;
11814 }
11815
11816 DEFUN (show_ip_ospf_external_aggregator,
11817 show_ip_ospf_external_aggregator_cmd,
11818 "show ip ospf [vrf <NAME|all>] summary-address [detail] [json]",
11819 SHOW_STR IP_STR
11820 "OSPF information\n"
11821 VRF_CMD_HELP_STR
11822 "All VRFs\n"
11823 "Show external summary addresses\n"
11824 "Detailed information\n"
11825 JSON_STR)
11826 {
11827 char *vrf_name = NULL;
11828 bool all_vrf = false;
11829 int ret = CMD_SUCCESS;
11830 int idx_vrf = 0;
11831 int idx = 0;
11832 uint8_t use_vrf = 0;
11833 bool uj = use_json(argc, argv);
11834 struct ospf *ospf = NULL;
11835 json_object *json = NULL;
11836 struct listnode *node = NULL;
11837 int inst = 0;
11838 bool detail = false;
11839
11840 OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
11841
11842 if (argv_find(argv, argc, "detail", &idx))
11843 detail = true;
11844
11845 if (uj)
11846 json = json_object_new_object();
11847
11848 /* vrf input is provided */
11849 if (vrf_name) {
11850 use_vrf = 1;
11851 if (all_vrf) {
11852 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
11853 if (!ospf->oi_running)
11854 continue;
11855 ret = ospf_show_summary_address(
11856 vty, ospf, use_vrf, json, uj, detail);
11857 }
11858
11859 if (uj)
11860 vty_json(vty, json);
11861
11862 return ret;
11863 }
11864
11865 ospf = ospf_lookup_by_inst_name(inst, vrf_name);
11866
11867 if (ospf == NULL || !ospf->oi_running) {
11868 if (uj)
11869 vty_json(vty, json);
11870 else
11871 vty_out(vty,
11872 "%% OSPF is not enabled in vrf %s\n",
11873 vrf_name);
11874
11875 return CMD_SUCCESS;
11876 }
11877 ospf_show_summary_address(vty, ospf, use_vrf, json, uj, detail);
11878
11879 } else {
11880 /* Default Vrf */
11881 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
11882 if (ospf == NULL || !ospf->oi_running) {
11883 if (uj)
11884 vty_json(vty, json);
11885 else
11886 vty_out(vty,
11887 "%% OSPF is not enabled in vrf default\n");
11888
11889 return CMD_SUCCESS;
11890 }
11891
11892 ospf_show_summary_address(vty, ospf, use_vrf, json, uj, detail);
11893 }
11894
11895 if (uj)
11896 vty_json(vty, json);
11897 return CMD_SUCCESS;
11898 }
11899
11900 static const char *const ospf_int_type_str[] = {
11901 "unknown", /* should never be used. */
11902 "point-to-point",
11903 "broadcast",
11904 "non-broadcast",
11905 "point-to-multipoint",
11906 "virtual-link", /* should never be used. */
11907 "loopback"
11908 };
11909
11910 static const char *interface_config_auth_str(struct ospf_if_params *params)
11911 {
11912 if (!OSPF_IF_PARAM_CONFIGURED(params, auth_type)
11913 || params->auth_type == OSPF_AUTH_NOTSET)
11914 return NULL;
11915
11916 /* Translation tables are not that much help
11917 * here due to syntax
11918 * of the simple option */
11919 switch (params->auth_type) {
11920
11921 case OSPF_AUTH_NULL:
11922 return " null";
11923
11924 case OSPF_AUTH_SIMPLE:
11925 return "";
11926
11927 case OSPF_AUTH_CRYPTOGRAPHIC:
11928 return " message-digest";
11929 }
11930
11931 return "";
11932 }
11933
11934 static int config_write_interface_one(struct vty *vty, struct vrf *vrf)
11935 {
11936 struct listnode *node;
11937 struct interface *ifp;
11938 struct crypt_key *ck;
11939 struct route_node *rn = NULL;
11940 struct ospf_if_params *params;
11941 const char *auth_str;
11942 int write = 0;
11943
11944 FOR_ALL_INTERFACES (vrf, ifp) {
11945
11946 if (memcmp(ifp->name, "VLINK", 5) == 0)
11947 continue;
11948
11949 if_vty_config_start(vty, ifp);
11950
11951 if (ifp->desc)
11952 vty_out(vty, " description %s\n", ifp->desc);
11953
11954 write++;
11955
11956 params = IF_DEF_PARAMS(ifp);
11957
11958 do {
11959 /* Interface Network print. */
11960 if (OSPF_IF_PARAM_CONFIGURED(params, type)
11961 && params->type != OSPF_IFTYPE_LOOPBACK) {
11962 if (params->type != ospf_default_iftype(ifp)) {
11963 vty_out(vty, " ip ospf network %s",
11964 ospf_int_type_str
11965 [params->type]);
11966 if (params->type
11967 == OSPF_IFTYPE_POINTOPOINT
11968 && params->ptp_dmvpn)
11969 vty_out(vty, " dmvpn");
11970 if (params != IF_DEF_PARAMS(ifp) && rn)
11971 vty_out(vty, " %pI4",
11972 &rn->p.u.prefix4);
11973 vty_out(vty, "\n");
11974 }
11975 }
11976
11977 /* OSPF interface authentication print */
11978 auth_str = interface_config_auth_str(params);
11979 if (auth_str) {
11980 vty_out(vty, " ip ospf authentication%s",
11981 auth_str);
11982 if (params != IF_DEF_PARAMS(ifp) && rn)
11983 vty_out(vty, " %pI4",
11984 &rn->p.u.prefix4);
11985 vty_out(vty, "\n");
11986 }
11987
11988 /* Simple Authentication Password print. */
11989 if (OSPF_IF_PARAM_CONFIGURED(params, auth_simple)
11990 && params->auth_simple[0] != '\0') {
11991 vty_out(vty, " ip ospf authentication-key %s",
11992 params->auth_simple);
11993 if (params != IF_DEF_PARAMS(ifp) && rn)
11994 vty_out(vty, " %pI4",
11995 &rn->p.u.prefix4);
11996 vty_out(vty, "\n");
11997 }
11998
11999 /* Cryptographic Authentication Key print. */
12000 if (params && params->auth_crypt) {
12001 for (ALL_LIST_ELEMENTS_RO(params->auth_crypt,
12002 node, ck)) {
12003 vty_out(vty,
12004 " ip ospf message-digest-key %d md5 %s",
12005 ck->key_id, ck->auth_key);
12006 if (params != IF_DEF_PARAMS(ifp) && rn)
12007 vty_out(vty, " %pI4",
12008 &rn->p.u.prefix4);
12009 vty_out(vty, "\n");
12010 }
12011 }
12012
12013 /* Interface Output Cost print. */
12014 if (OSPF_IF_PARAM_CONFIGURED(params, output_cost_cmd)) {
12015 vty_out(vty, " ip ospf cost %u",
12016 params->output_cost_cmd);
12017 if (params != IF_DEF_PARAMS(ifp) && rn)
12018 vty_out(vty, " %pI4",
12019 &rn->p.u.prefix4);
12020 vty_out(vty, "\n");
12021 }
12022
12023 /* Hello Interval print. */
12024 if (OSPF_IF_PARAM_CONFIGURED(params, v_hello)
12025 && params->v_hello != OSPF_HELLO_INTERVAL_DEFAULT) {
12026 vty_out(vty, " ip ospf hello-interval %u",
12027 params->v_hello);
12028 if (params != IF_DEF_PARAMS(ifp) && rn)
12029 vty_out(vty, " %pI4",
12030 &rn->p.u.prefix4);
12031 vty_out(vty, "\n");
12032 }
12033
12034
12035 /* Router Dead Interval print. */
12036 if (OSPF_IF_PARAM_CONFIGURED(params, v_wait)
12037 && params->is_v_wait_set) {
12038 vty_out(vty, " ip ospf dead-interval ");
12039
12040 /* fast hello ? */
12041 if (OSPF_IF_PARAM_CONFIGURED(params,
12042 fast_hello))
12043 vty_out(vty,
12044 "minimal hello-multiplier %d",
12045 params->fast_hello);
12046 else
12047 vty_out(vty, "%u", params->v_wait);
12048
12049 if (params != IF_DEF_PARAMS(ifp) && rn)
12050 vty_out(vty, " %pI4",
12051 &rn->p.u.prefix4);
12052 vty_out(vty, "\n");
12053 }
12054
12055 /* Router Priority print. */
12056 if (OSPF_IF_PARAM_CONFIGURED(params, priority)
12057 && params->priority
12058 != OSPF_ROUTER_PRIORITY_DEFAULT) {
12059 vty_out(vty, " ip ospf priority %u",
12060 params->priority);
12061 if (params != IF_DEF_PARAMS(ifp) && rn)
12062 vty_out(vty, " %pI4",
12063 &rn->p.u.prefix4);
12064 vty_out(vty, "\n");
12065 }
12066
12067 /* Retransmit Interval print. */
12068 if (OSPF_IF_PARAM_CONFIGURED(params,
12069 retransmit_interval)
12070 && params->retransmit_interval
12071 != OSPF_RETRANSMIT_INTERVAL_DEFAULT) {
12072 vty_out(vty, " ip ospf retransmit-interval %u",
12073 params->retransmit_interval);
12074 if (params != IF_DEF_PARAMS(ifp) && rn)
12075 vty_out(vty, " %pI4",
12076 &rn->p.u.prefix4);
12077 vty_out(vty, "\n");
12078 }
12079
12080 /* Transmit Delay print. */
12081 if (OSPF_IF_PARAM_CONFIGURED(params, transmit_delay)
12082 && params->transmit_delay
12083 != OSPF_TRANSMIT_DELAY_DEFAULT) {
12084 vty_out(vty, " ip ospf transmit-delay %u",
12085 params->transmit_delay);
12086 if (params != IF_DEF_PARAMS(ifp) && rn)
12087 vty_out(vty, " %pI4",
12088 &rn->p.u.prefix4);
12089 vty_out(vty, "\n");
12090 }
12091
12092 /* Area print. */
12093 if (OSPF_IF_PARAM_CONFIGURED(params, if_area)) {
12094 if (ospf_instance)
12095 vty_out(vty, " ip ospf %d",
12096 ospf_instance);
12097 else
12098 vty_out(vty, " ip ospf");
12099
12100 char buf[INET_ADDRSTRLEN];
12101
12102 area_id2str(buf, sizeof(buf), &params->if_area,
12103 params->if_area_id_fmt);
12104 vty_out(vty, " area %s", buf);
12105 if (params != IF_DEF_PARAMS(ifp) && rn)
12106 vty_out(vty, " %pI4",
12107 &rn->p.u.prefix4);
12108 vty_out(vty, "\n");
12109 }
12110
12111 /* bfd print. */
12112 if (params && params->bfd_config)
12113 ospf_bfd_write_config(vty, params);
12114
12115 /* MTU ignore print. */
12116 if (OSPF_IF_PARAM_CONFIGURED(params, mtu_ignore)
12117 && params->mtu_ignore != OSPF_MTU_IGNORE_DEFAULT) {
12118 if (params->mtu_ignore == 0)
12119 vty_out(vty, " no ip ospf mtu-ignore");
12120 else
12121 vty_out(vty, " ip ospf mtu-ignore");
12122 if (params != IF_DEF_PARAMS(ifp) && rn)
12123 vty_out(vty, " %pI4",
12124 &rn->p.u.prefix4);
12125 vty_out(vty, "\n");
12126 }
12127
12128 if (OSPF_IF_PARAM_CONFIGURED(params,
12129 passive_interface)) {
12130 vty_out(vty, " %sip ospf passive",
12131 params->passive_interface
12132 == OSPF_IF_ACTIVE
12133 ? "no "
12134 : "");
12135 if (params != IF_DEF_PARAMS(ifp) && rn)
12136 vty_out(vty, " %pI4", &rn->p.u.prefix4);
12137 vty_out(vty, "\n");
12138 }
12139
12140 /* LDP-Sync print */
12141 if (params && params->ldp_sync_info)
12142 ospf_ldp_sync_if_write_config(vty, params);
12143
12144 while (1) {
12145 if (rn == NULL)
12146 rn = route_top(IF_OIFS_PARAMS(ifp));
12147 else
12148 rn = route_next(rn);
12149
12150 if (rn == NULL)
12151 break;
12152 params = rn->info;
12153 if (params != NULL)
12154 break;
12155 }
12156 } while (rn);
12157
12158 ospf_opaque_config_write_if(vty, ifp);
12159
12160 if_vty_config_end(vty);
12161 }
12162
12163 return write;
12164 }
12165
12166 /* Configuration write function for ospfd. */
12167 static int config_write_interface(struct vty *vty)
12168 {
12169 int write = 0;
12170 struct vrf *vrf = NULL;
12171
12172 /* Display all VRF aware OSPF interface configuration */
12173 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
12174 write += config_write_interface_one(vty, vrf);
12175 }
12176
12177 return write;
12178 }
12179
12180 static int config_write_network_area(struct vty *vty, struct ospf *ospf)
12181 {
12182 struct route_node *rn;
12183 char buf[INET_ADDRSTRLEN];
12184
12185 /* `network area' print. */
12186 for (rn = route_top(ospf->networks); rn; rn = route_next(rn))
12187 if (rn->info) {
12188 struct ospf_network *n = rn->info;
12189
12190 /* Create Area ID string by specified Area ID format. */
12191 if (n->area_id_fmt == OSPF_AREA_ID_FMT_DOTTEDQUAD)
12192 inet_ntop(AF_INET, &n->area_id, buf,
12193 sizeof(buf));
12194 else
12195 snprintf(buf, sizeof(buf), "%lu",
12196 (unsigned long int)ntohl(
12197 n->area_id.s_addr));
12198
12199 /* Network print. */
12200 vty_out(vty, " network %pFX area %s\n", &rn->p, buf);
12201 }
12202
12203 return 0;
12204 }
12205
12206 static int config_write_ospf_area(struct vty *vty, struct ospf *ospf)
12207 {
12208 struct listnode *node;
12209 struct ospf_area *area;
12210 char buf[INET_ADDRSTRLEN];
12211
12212 /* Area configuration print. */
12213 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
12214 struct route_node *rn1;
12215
12216 area_id2str(buf, sizeof(buf), &area->area_id,
12217 area->area_id_fmt);
12218
12219 if (area->auth_type != OSPF_AUTH_NULL) {
12220 if (area->auth_type == OSPF_AUTH_SIMPLE)
12221 vty_out(vty, " area %s authentication\n", buf);
12222 else
12223 vty_out(vty,
12224 " area %s authentication message-digest\n",
12225 buf);
12226 }
12227
12228 if (area->shortcut_configured != OSPF_SHORTCUT_DEFAULT)
12229 vty_out(vty, " area %s shortcut %s\n", buf,
12230 ospf_shortcut_mode_str
12231 [area->shortcut_configured]);
12232
12233 if ((area->external_routing == OSPF_AREA_STUB)
12234 || (area->external_routing == OSPF_AREA_NSSA)) {
12235 if (area->external_routing == OSPF_AREA_STUB) {
12236 vty_out(vty, " area %s stub", buf);
12237 if (area->no_summary)
12238 vty_out(vty, " no-summary\n");
12239 vty_out(vty, "\n");
12240 } else if (area->external_routing == OSPF_AREA_NSSA) {
12241 switch (area->NSSATranslatorRole) {
12242 case OSPF_NSSA_ROLE_NEVER:
12243 vty_out(vty,
12244 " area %s nssa translate-never\n",
12245 buf);
12246 break;
12247 case OSPF_NSSA_ROLE_ALWAYS:
12248 vty_out(vty,
12249 " area %s nssa translate-always\n",
12250 buf);
12251 break;
12252 case OSPF_NSSA_ROLE_CANDIDATE:
12253 vty_out(vty, " area %s nssa \n", buf);
12254 break;
12255 }
12256 if (area->no_summary)
12257 vty_out(vty,
12258 " area %s nssa no-summary\n",
12259 buf);
12260 if (area->suppress_fa)
12261 vty_out(vty,
12262 " area %s nssa suppress-fa\n",
12263 buf);
12264 }
12265
12266 if (area->default_cost != 1)
12267 vty_out(vty, " area %s default-cost %d\n", buf,
12268 area->default_cost);
12269 }
12270
12271 for (rn1 = route_top(area->ranges); rn1; rn1 = route_next(rn1))
12272 if (rn1->info) {
12273 struct ospf_area_range *range = rn1->info;
12274
12275 vty_out(vty, " area %s range %pFX", buf,
12276 &rn1->p);
12277
12278 if (range->cost_config
12279 != OSPF_AREA_RANGE_COST_UNSPEC)
12280 vty_out(vty, " cost %d",
12281 range->cost_config);
12282
12283 if (!CHECK_FLAG(range->flags,
12284 OSPF_AREA_RANGE_ADVERTISE))
12285 vty_out(vty, " not-advertise");
12286
12287 if (CHECK_FLAG(range->flags,
12288 OSPF_AREA_RANGE_SUBSTITUTE))
12289 vty_out(vty, " substitute %pI4/%d",
12290 &range->subst_addr,
12291 range->subst_masklen);
12292
12293 vty_out(vty, "\n");
12294 }
12295
12296 if (EXPORT_NAME(area))
12297 vty_out(vty, " area %s export-list %s\n", buf,
12298 EXPORT_NAME(area));
12299
12300 if (IMPORT_NAME(area))
12301 vty_out(vty, " area %s import-list %s\n", buf,
12302 IMPORT_NAME(area));
12303
12304 if (PREFIX_NAME_IN(area))
12305 vty_out(vty, " area %s filter-list prefix %s in\n", buf,
12306 PREFIX_NAME_IN(area));
12307
12308 if (PREFIX_NAME_OUT(area))
12309 vty_out(vty, " area %s filter-list prefix %s out\n",
12310 buf, PREFIX_NAME_OUT(area));
12311 }
12312
12313 return 0;
12314 }
12315
12316 static int config_write_ospf_nbr_nbma(struct vty *vty, struct ospf *ospf)
12317 {
12318 struct ospf_nbr_nbma *nbr_nbma;
12319 struct route_node *rn;
12320
12321 /* Static Neighbor configuration print. */
12322 for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
12323 if ((nbr_nbma = rn->info)) {
12324 vty_out(vty, " neighbor %pI4", &nbr_nbma->addr);
12325
12326 if (nbr_nbma->priority
12327 != OSPF_NEIGHBOR_PRIORITY_DEFAULT)
12328 vty_out(vty, " priority %d",
12329 nbr_nbma->priority);
12330
12331 if (nbr_nbma->v_poll != OSPF_POLL_INTERVAL_DEFAULT)
12332 vty_out(vty, " poll-interval %d",
12333 nbr_nbma->v_poll);
12334
12335 vty_out(vty, "\n");
12336 }
12337
12338 return 0;
12339 }
12340
12341 static int config_write_virtual_link(struct vty *vty, struct ospf *ospf)
12342 {
12343 struct listnode *node;
12344 struct ospf_vl_data *vl_data;
12345 const char *auth_str;
12346 char buf[INET_ADDRSTRLEN];
12347
12348 /* Virtual-Link print */
12349 for (ALL_LIST_ELEMENTS_RO(ospf->vlinks, node, vl_data)) {
12350 struct listnode *n2;
12351 struct crypt_key *ck;
12352 struct ospf_interface *oi;
12353
12354 if (vl_data != NULL) {
12355 area_id2str(buf, sizeof(buf), &vl_data->vl_area_id,
12356 vl_data->vl_area_id_fmt);
12357 oi = vl_data->vl_oi;
12358
12359 /* timers */
12360 if (OSPF_IF_PARAM(oi, v_hello)
12361 != OSPF_HELLO_INTERVAL_DEFAULT
12362 || OSPF_IF_PARAM(oi, v_wait)
12363 != OSPF_ROUTER_DEAD_INTERVAL_DEFAULT
12364 || OSPF_IF_PARAM(oi, retransmit_interval)
12365 != OSPF_RETRANSMIT_INTERVAL_DEFAULT
12366 || OSPF_IF_PARAM(oi, transmit_delay)
12367 != OSPF_TRANSMIT_DELAY_DEFAULT)
12368 vty_out(vty,
12369 " area %s virtual-link %pI4 hello-interval %d retransmit-interval %d transmit-delay %d dead-interval %d\n",
12370 buf, &vl_data->vl_peer,
12371 OSPF_IF_PARAM(oi, v_hello),
12372 OSPF_IF_PARAM(oi, retransmit_interval),
12373 OSPF_IF_PARAM(oi, transmit_delay),
12374 OSPF_IF_PARAM(oi, v_wait));
12375 else
12376 vty_out(vty, " area %s virtual-link %pI4\n", buf,
12377 &vl_data->vl_peer);
12378 /* Auth type */
12379 auth_str = interface_config_auth_str(
12380 IF_DEF_PARAMS(oi->ifp));
12381 if (auth_str)
12382 vty_out(vty,
12383 " area %s virtual-link %pI4 authentication%s\n",
12384 buf, &vl_data->vl_peer, auth_str);
12385 /* Auth key */
12386 if (IF_DEF_PARAMS(vl_data->vl_oi->ifp)->auth_simple[0]
12387 != '\0')
12388 vty_out(vty,
12389 " area %s virtual-link %pI4 authentication-key %s\n",
12390 buf, &vl_data->vl_peer,
12391 IF_DEF_PARAMS(vl_data->vl_oi->ifp)
12392 ->auth_simple);
12393 /* md5 keys */
12394 for (ALL_LIST_ELEMENTS_RO(
12395 IF_DEF_PARAMS(vl_data->vl_oi->ifp)
12396 ->auth_crypt,
12397 n2, ck))
12398 vty_out(vty,
12399 " area %s virtual-link %pI4 message-digest-key %d md5 %s\n",
12400 buf, &vl_data->vl_peer,
12401 ck->key_id, ck->auth_key);
12402 }
12403 }
12404
12405 return 0;
12406 }
12407
12408
12409 static int config_write_ospf_redistribute(struct vty *vty, struct ospf *ospf)
12410 {
12411 int type;
12412
12413 /* redistribute print. */
12414 for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
12415 struct list *red_list;
12416 struct listnode *node;
12417 struct ospf_redist *red;
12418
12419 red_list = ospf->redist[type];
12420 if (!red_list)
12421 continue;
12422
12423 for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
12424 vty_out(vty, " redistribute %s",
12425 zebra_route_string(type));
12426 if (red->instance)
12427 vty_out(vty, " %d", red->instance);
12428
12429 if (red->dmetric.value >= 0)
12430 vty_out(vty, " metric %d", red->dmetric.value);
12431
12432 if (red->dmetric.type == EXTERNAL_METRIC_TYPE_1)
12433 vty_out(vty, " metric-type 1");
12434
12435 if (ROUTEMAP_NAME(red))
12436 vty_out(vty, " route-map %s",
12437 ROUTEMAP_NAME(red));
12438
12439 vty_out(vty, "\n");
12440 }
12441 }
12442
12443 return 0;
12444 }
12445
12446 static int ospf_cfg_write_helper_dis_rtr_walkcb(struct hash_bucket *bucket,
12447 void *arg)
12448 {
12449 struct advRtr *rtr = bucket->data;
12450 struct vty *vty = (struct vty *)arg;
12451
12452 vty_out(vty, " graceful-restart helper enable %pI4\n",
12453 &rtr->advRtrAddr);
12454 return HASHWALK_CONTINUE;
12455 }
12456
12457 static void config_write_ospf_gr(struct vty *vty, struct ospf *ospf)
12458 {
12459 if (!ospf->gr_info.restart_support)
12460 return;
12461
12462 if (ospf->gr_info.grace_period == OSPF_DFLT_GRACE_INTERVAL)
12463 vty_out(vty, " graceful-restart\n");
12464 else
12465 vty_out(vty, " graceful-restart grace-period %u\n",
12466 ospf->gr_info.grace_period);
12467 }
12468
12469 static int config_write_ospf_gr_helper(struct vty *vty, struct ospf *ospf)
12470 {
12471 if (ospf->is_helper_supported)
12472 vty_out(vty, " graceful-restart helper enable\n");
12473
12474 if (!ospf->strict_lsa_check)
12475 vty_out(vty,
12476 " no graceful-restart helper strict-lsa-checking\n");
12477
12478 if (ospf->only_planned_restart)
12479 vty_out(vty, " graceful-restart helper planned-only\n");
12480
12481 if (ospf->supported_grace_time != OSPF_MAX_GRACE_INTERVAL)
12482 vty_out(vty,
12483 " graceful-restart helper supported-grace-time %d\n",
12484 ospf->supported_grace_time);
12485
12486 if (OSPF_HELPER_ENABLE_RTR_COUNT(ospf)) {
12487 hash_walk(ospf->enable_rtr_list,
12488 ospf_cfg_write_helper_dis_rtr_walkcb, vty);
12489 }
12490 return 0;
12491 }
12492
12493 static int config_write_ospf_external_aggregator(struct vty *vty,
12494 struct ospf *ospf)
12495 {
12496 struct route_node *rn;
12497
12498 if (ospf->aggr_delay_interval != OSPF_EXTL_AGGR_DEFAULT_DELAY)
12499 vty_out(vty, " aggregation timer %u\n",
12500 ospf->aggr_delay_interval);
12501
12502 /* print 'summary-address A.B.C.D/M' */
12503 for (rn = route_top(ospf->rt_aggr_tbl); rn; rn = route_next(rn))
12504 if (rn->info) {
12505 struct ospf_external_aggr_rt *aggr = rn->info;
12506
12507 vty_out(vty, " summary-address %pI4/%d",
12508 &aggr->p.prefix, aggr->p.prefixlen);
12509 if (aggr->tag)
12510 vty_out(vty, " tag %u", aggr->tag);
12511
12512 if (CHECK_FLAG(aggr->flags,
12513 OSPF_EXTERNAL_AGGRT_NO_ADVERTISE))
12514 vty_out(vty, " no-advertise");
12515
12516 vty_out(vty, "\n");
12517 }
12518
12519 return 0;
12520 }
12521
12522 static int config_write_ospf_default_metric(struct vty *vty, struct ospf *ospf)
12523 {
12524 if (ospf->default_metric != -1)
12525 vty_out(vty, " default-metric %d\n", ospf->default_metric);
12526 return 0;
12527 }
12528
12529 static int config_write_ospf_distribute(struct vty *vty, struct ospf *ospf)
12530 {
12531 int type;
12532 struct ospf_redist *red;
12533
12534 if (ospf) {
12535 /* distribute-list print. */
12536 for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
12537 if (DISTRIBUTE_NAME(ospf, type))
12538 vty_out(vty, " distribute-list %s out %s\n",
12539 DISTRIBUTE_NAME(ospf, type),
12540 zebra_route_string(type));
12541
12542 /* default-information print. */
12543 if (ospf->default_originate != DEFAULT_ORIGINATE_NONE) {
12544 vty_out(vty, " default-information originate");
12545 if (ospf->default_originate == DEFAULT_ORIGINATE_ALWAYS)
12546 vty_out(vty, " always");
12547
12548 red = ospf_redist_lookup(ospf, DEFAULT_ROUTE, 0);
12549 if (red) {
12550 if (red->dmetric.value >= 0)
12551 vty_out(vty, " metric %d",
12552 red->dmetric.value);
12553
12554 if (red->dmetric.type == EXTERNAL_METRIC_TYPE_1)
12555 vty_out(vty, " metric-type 1");
12556
12557 if (ROUTEMAP_NAME(red))
12558 vty_out(vty, " route-map %s",
12559 ROUTEMAP_NAME(red));
12560 }
12561
12562 vty_out(vty, "\n");
12563 }
12564 }
12565
12566 return 0;
12567 }
12568
12569 static int config_write_ospf_distance(struct vty *vty, struct ospf *ospf)
12570 {
12571 struct route_node *rn;
12572 struct ospf_distance *odistance;
12573
12574 if (ospf->distance_all)
12575 vty_out(vty, " distance %d\n", ospf->distance_all);
12576
12577 if (ospf->distance_intra || ospf->distance_inter
12578 || ospf->distance_external) {
12579 vty_out(vty, " distance ospf");
12580
12581 if (ospf->distance_intra)
12582 vty_out(vty, " intra-area %d", ospf->distance_intra);
12583 if (ospf->distance_inter)
12584 vty_out(vty, " inter-area %d", ospf->distance_inter);
12585 if (ospf->distance_external)
12586 vty_out(vty, " external %d", ospf->distance_external);
12587
12588 vty_out(vty, "\n");
12589 }
12590
12591 for (rn = route_top(ospf->distance_table); rn; rn = route_next(rn))
12592 if ((odistance = rn->info) != NULL) {
12593 vty_out(vty, " distance %d %pFX %s\n",
12594 odistance->distance, &rn->p,
12595 odistance->access_list ? odistance->access_list
12596 : "");
12597 }
12598 return 0;
12599 }
12600
12601 static int ospf_config_write_one(struct vty *vty, struct ospf *ospf)
12602 {
12603 int write = 0;
12604
12605 /* `router ospf' print. */
12606 if (ospf->instance && strcmp(ospf->name, VRF_DEFAULT_NAME)) {
12607 vty_out(vty, "router ospf %d vrf %s\n", ospf->instance,
12608 ospf->name);
12609 } else if (ospf->instance) {
12610 vty_out(vty, "router ospf %d\n", ospf->instance);
12611 } else if (strcmp(ospf->name, VRF_DEFAULT_NAME)) {
12612 vty_out(vty, "router ospf vrf %s\n", ospf->name);
12613 } else
12614 vty_out(vty, "router ospf\n");
12615
12616 if (!ospf->networks) {
12617 write++;
12618 return write;
12619 }
12620
12621 /* Router ID print. */
12622 if (ospf->router_id_static.s_addr != INADDR_ANY)
12623 vty_out(vty, " ospf router-id %pI4\n",
12624 &ospf->router_id_static);
12625
12626 /* zebra opaque attributes configuration. */
12627 if (CHECK_FLAG(ospf->config, OSPF_SEND_EXTRA_DATA_TO_ZEBRA))
12628 vty_out(vty, " ospf send-extra-data zebra\n");
12629
12630 /* ABR type print. */
12631 if (ospf->abr_type != OSPF_ABR_DEFAULT)
12632 vty_out(vty, " ospf abr-type %s\n",
12633 ospf_abr_type_str[ospf->abr_type]);
12634
12635 /* log-adjacency-changes flag print. */
12636 if (CHECK_FLAG(ospf->config, OSPF_LOG_ADJACENCY_CHANGES)) {
12637 if (CHECK_FLAG(ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
12638 vty_out(vty, " log-adjacency-changes detail\n");
12639 else if (!SAVE_OSPF_LOG_ADJACENCY_CHANGES)
12640 vty_out(vty, " log-adjacency-changes\n");
12641 } else if (SAVE_OSPF_LOG_ADJACENCY_CHANGES) {
12642 vty_out(vty, " no log-adjacency-changes\n");
12643 }
12644
12645 /* RFC1583 compatibility flag print -- Compatible with CISCO
12646 * 12.1. */
12647 if (CHECK_FLAG(ospf->config, OSPF_RFC1583_COMPATIBLE))
12648 vty_out(vty, " compatible rfc1583\n");
12649
12650 /* auto-cost reference-bandwidth configuration. */
12651 if (ospf->ref_bandwidth != OSPF_DEFAULT_REF_BANDWIDTH) {
12652 vty_out(vty,
12653 "! Important: ensure reference bandwidth is consistent across all routers\n");
12654 vty_out(vty, " auto-cost reference-bandwidth %d\n",
12655 ospf->ref_bandwidth);
12656 }
12657
12658 /* SPF timers print. */
12659 if (ospf->spf_delay != OSPF_SPF_DELAY_DEFAULT
12660 || ospf->spf_holdtime != OSPF_SPF_HOLDTIME_DEFAULT
12661 || ospf->spf_max_holdtime != OSPF_SPF_MAX_HOLDTIME_DEFAULT)
12662 vty_out(vty, " timers throttle spf %d %d %d\n", ospf->spf_delay,
12663 ospf->spf_holdtime, ospf->spf_max_holdtime);
12664
12665 /* LSA timers print. */
12666 if (ospf->min_ls_interval != OSPF_MIN_LS_INTERVAL)
12667 vty_out(vty, " timers throttle lsa all %d\n",
12668 ospf->min_ls_interval);
12669 if (ospf->min_ls_arrival != OSPF_MIN_LS_ARRIVAL)
12670 vty_out(vty, " timers lsa min-arrival %d\n",
12671 ospf->min_ls_arrival);
12672
12673 /* Write multiplier print. */
12674 if (ospf->write_oi_count != OSPF_WRITE_INTERFACE_COUNT_DEFAULT)
12675 vty_out(vty, " ospf write-multiplier %d\n",
12676 ospf->write_oi_count);
12677
12678 if (ospf->max_multipath != MULTIPATH_NUM)
12679 vty_out(vty, " maximum-paths %d\n", ospf->max_multipath);
12680
12681 /* Max-metric router-lsa print */
12682 config_write_stub_router(vty, ospf);
12683
12684 /* SPF refresh parameters print. */
12685 if (ospf->lsa_refresh_interval != OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
12686 vty_out(vty, " refresh timer %d\n", ospf->lsa_refresh_interval);
12687
12688 /* Redistribute information print. */
12689 config_write_ospf_redistribute(vty, ospf);
12690
12691 /* Graceful Restart print */
12692 config_write_ospf_gr(vty, ospf);
12693 config_write_ospf_gr_helper(vty, ospf);
12694
12695 /* Print external route aggregation. */
12696 config_write_ospf_external_aggregator(vty, ospf);
12697
12698 /* passive-interface print. */
12699 if (ospf->passive_interface_default == OSPF_IF_PASSIVE)
12700 vty_out(vty, " passive-interface default\n");
12701
12702 /* proactive-arp print. */
12703 if (ospf->proactive_arp != OSPF_PROACTIVE_ARP_DEFAULT) {
12704 if (ospf->proactive_arp)
12705 vty_out(vty, " proactive-arp\n");
12706 else
12707 vty_out(vty, " no proactive-arp\n");
12708 }
12709
12710 /* TI-LFA print. */
12711 if (ospf->ti_lfa_enabled) {
12712 if (ospf->ti_lfa_protection_type == OSPF_TI_LFA_NODE_PROTECTION)
12713 vty_out(vty, " fast-reroute ti-lfa node-protection\n");
12714 else
12715 vty_out(vty, " fast-reroute ti-lfa\n");
12716 }
12717
12718 /* Network area print. */
12719 config_write_network_area(vty, ospf);
12720
12721 /* Area config print. */
12722 config_write_ospf_area(vty, ospf);
12723
12724 /* static neighbor print. */
12725 config_write_ospf_nbr_nbma(vty, ospf);
12726
12727 /* Virtual-Link print. */
12728 config_write_virtual_link(vty, ospf);
12729
12730 /* Default metric configuration. */
12731 config_write_ospf_default_metric(vty, ospf);
12732
12733 /* Distribute-list and default-information print. */
12734 config_write_ospf_distribute(vty, ospf);
12735
12736 /* Distance configuration. */
12737 config_write_ospf_distance(vty, ospf);
12738
12739 ospf_opaque_config_write_router(vty, ospf);
12740
12741 /* LDP-Sync print */
12742 ospf_ldp_sync_write_config(vty, ospf);
12743
12744 vty_out(vty, "exit\n");
12745
12746 write++;
12747 return write;
12748 }
12749
12750 /* OSPF configuration write function. */
12751 static int ospf_config_write(struct vty *vty)
12752 {
12753 struct ospf *ospf;
12754 struct listnode *ospf_node = NULL;
12755 int write = 0;
12756
12757 if (listcount(om->ospf) == 0)
12758 return write;
12759
12760 for (ALL_LIST_ELEMENTS_RO(om->ospf, ospf_node, ospf)) {
12761 /* VRF Default check if it is running.
12762 * Upon daemon start, there could be default instance
12763 * in absence of 'router ospf'/oi_running is disabled. */
12764 if (ospf->vrf_id == VRF_DEFAULT && ospf->oi_running)
12765 write += ospf_config_write_one(vty, ospf);
12766 /* For Non-Default VRF simply display the configuration,
12767 * even if it is not oi_running. */
12768 else if (ospf->vrf_id != VRF_DEFAULT)
12769 write += ospf_config_write_one(vty, ospf);
12770 }
12771 return write;
12772 }
12773
12774 void ospf_vty_show_init(void)
12775 {
12776 /* "show ip ospf" commands. */
12777 install_element(VIEW_NODE, &show_ip_ospf_cmd);
12778
12779 install_element(VIEW_NODE, &show_ip_ospf_instance_cmd);
12780
12781 /* "show ip ospf database" commands. */
12782 install_element(VIEW_NODE, &show_ip_ospf_database_cmd);
12783 install_element(VIEW_NODE, &show_ip_ospf_database_max_cmd);
12784 install_element(VIEW_NODE,
12785 &show_ip_ospf_database_type_adv_router_cmd);
12786 install_element(VIEW_NODE,
12787 &show_ip_ospf_instance_database_type_adv_router_cmd);
12788 install_element(VIEW_NODE, &show_ip_ospf_instance_database_cmd);
12789 install_element(VIEW_NODE, &show_ip_ospf_instance_database_max_cmd);
12790
12791 /* "show ip ospf interface" commands. */
12792 install_element(VIEW_NODE, &show_ip_ospf_interface_cmd);
12793
12794 install_element(VIEW_NODE, &show_ip_ospf_instance_interface_cmd);
12795 /* "show ip ospf interface traffic */
12796 install_element(VIEW_NODE, &show_ip_ospf_interface_traffic_cmd);
12797
12798 /* "show ip ospf neighbor" commands. */
12799 install_element(VIEW_NODE, &show_ip_ospf_neighbor_int_detail_cmd);
12800 install_element(VIEW_NODE, &show_ip_ospf_neighbor_int_cmd);
12801 install_element(VIEW_NODE, &show_ip_ospf_neighbor_id_cmd);
12802 install_element(VIEW_NODE, &show_ip_ospf_neighbor_detail_all_cmd);
12803 install_element(VIEW_NODE, &show_ip_ospf_neighbor_detail_cmd);
12804 install_element(VIEW_NODE, &show_ip_ospf_neighbor_cmd);
12805 install_element(VIEW_NODE, &show_ip_ospf_neighbor_all_cmd);
12806
12807 install_element(VIEW_NODE,
12808 &show_ip_ospf_instance_neighbor_int_detail_cmd);
12809 install_element(VIEW_NODE, &show_ip_ospf_instance_neighbor_int_cmd);
12810 install_element(VIEW_NODE, &show_ip_ospf_instance_neighbor_id_cmd);
12811 install_element(VIEW_NODE,
12812 &show_ip_ospf_instance_neighbor_detail_all_cmd);
12813 install_element(VIEW_NODE, &show_ip_ospf_instance_neighbor_detail_cmd);
12814 install_element(VIEW_NODE, &show_ip_ospf_instance_neighbor_cmd);
12815 install_element(VIEW_NODE, &show_ip_ospf_instance_neighbor_all_cmd);
12816
12817 /* "show ip ospf route" commands. */
12818 install_element(VIEW_NODE, &show_ip_ospf_route_cmd);
12819 install_element(VIEW_NODE, &show_ip_ospf_border_routers_cmd);
12820 install_element(VIEW_NODE, &show_ip_ospf_reachable_routers_cmd);
12821 install_element(VIEW_NODE, &show_ip_ospf_route_orr_cmd);
12822
12823 install_element(VIEW_NODE, &show_ip_ospf_instance_route_cmd);
12824 install_element(VIEW_NODE, &show_ip_ospf_instance_border_routers_cmd);
12825 install_element(VIEW_NODE,
12826 &show_ip_ospf_instance_reachable_routers_cmd);
12827 install_element(VIEW_NODE, &show_ip_ospf_instance_route_orr_cmd);
12828
12829 /* "show ip ospf vrfs" commands. */
12830 install_element(VIEW_NODE, &show_ip_ospf_vrfs_cmd);
12831
12832 /* "show ip ospf gr-helper details" command */
12833 install_element(VIEW_NODE, &show_ip_ospf_gr_helper_cmd);
12834
12835 /* "show ip ospf summary-address" command */
12836 install_element(VIEW_NODE, &show_ip_ospf_external_aggregator_cmd);
12837 }
12838
12839 /* Initialization of OSPF interface. */
12840 static void ospf_vty_if_init(void)
12841 {
12842 /* Install interface node. */
12843 if_cmd_init(config_write_interface);
12844
12845 /* "ip ospf authentication" commands. */
12846 install_element(INTERFACE_NODE, &ip_ospf_authentication_args_addr_cmd);
12847 install_element(INTERFACE_NODE, &ip_ospf_authentication_addr_cmd);
12848 install_element(INTERFACE_NODE,
12849 &no_ip_ospf_authentication_args_addr_cmd);
12850 install_element(INTERFACE_NODE, &no_ip_ospf_authentication_addr_cmd);
12851 install_element(INTERFACE_NODE, &ip_ospf_authentication_key_addr_cmd);
12852 install_element(INTERFACE_NODE,
12853 &no_ip_ospf_authentication_key_authkey_addr_cmd);
12854 install_element(INTERFACE_NODE,
12855 &no_ospf_authentication_key_authkey_addr_cmd);
12856
12857 /* "ip ospf message-digest-key" commands. */
12858 install_element(INTERFACE_NODE, &ip_ospf_message_digest_key_cmd);
12859 install_element(INTERFACE_NODE, &no_ip_ospf_message_digest_key_cmd);
12860
12861 /* "ip ospf cost" commands. */
12862 install_element(INTERFACE_NODE, &ip_ospf_cost_cmd);
12863 install_element(INTERFACE_NODE, &no_ip_ospf_cost_cmd);
12864
12865 /* "ip ospf mtu-ignore" commands. */
12866 install_element(INTERFACE_NODE, &ip_ospf_mtu_ignore_addr_cmd);
12867 install_element(INTERFACE_NODE, &no_ip_ospf_mtu_ignore_addr_cmd);
12868
12869 /* "ip ospf dead-interval" commands. */
12870 install_element(INTERFACE_NODE, &ip_ospf_dead_interval_cmd);
12871 install_element(INTERFACE_NODE,
12872 &ip_ospf_dead_interval_minimal_addr_cmd);
12873 install_element(INTERFACE_NODE, &no_ip_ospf_dead_interval_cmd);
12874
12875 /* "ip ospf hello-interval" commands. */
12876 install_element(INTERFACE_NODE, &ip_ospf_hello_interval_cmd);
12877 install_element(INTERFACE_NODE, &no_ip_ospf_hello_interval_cmd);
12878
12879 /* "ip ospf network" commands. */
12880 install_element(INTERFACE_NODE, &ip_ospf_network_cmd);
12881 install_element(INTERFACE_NODE, &no_ip_ospf_network_cmd);
12882
12883 /* "ip ospf priority" commands. */
12884 install_element(INTERFACE_NODE, &ip_ospf_priority_cmd);
12885 install_element(INTERFACE_NODE, &no_ip_ospf_priority_cmd);
12886
12887 /* "ip ospf retransmit-interval" commands. */
12888 install_element(INTERFACE_NODE, &ip_ospf_retransmit_interval_addr_cmd);
12889 install_element(INTERFACE_NODE,
12890 &no_ip_ospf_retransmit_interval_addr_cmd);
12891
12892 /* "ip ospf transmit-delay" commands. */
12893 install_element(INTERFACE_NODE, &ip_ospf_transmit_delay_addr_cmd);
12894 install_element(INTERFACE_NODE, &no_ip_ospf_transmit_delay_addr_cmd);
12895
12896 /* "ip ospf area" commands. */
12897 install_element(INTERFACE_NODE, &ip_ospf_area_cmd);
12898 install_element(INTERFACE_NODE, &no_ip_ospf_area_cmd);
12899
12900 /* "ip ospf passive" commands. */
12901 install_element(INTERFACE_NODE, &ip_ospf_passive_cmd);
12902 install_element(INTERFACE_NODE, &no_ip_ospf_passive_cmd);
12903
12904 /* These commands are compatibitliy for previous version. */
12905 install_element(INTERFACE_NODE, &ospf_authentication_key_cmd);
12906 install_element(INTERFACE_NODE, &ospf_message_digest_key_cmd);
12907 install_element(INTERFACE_NODE, &no_ospf_message_digest_key_cmd);
12908 install_element(INTERFACE_NODE, &ospf_dead_interval_cmd);
12909 install_element(INTERFACE_NODE, &no_ospf_dead_interval_cmd);
12910 install_element(INTERFACE_NODE, &ospf_hello_interval_cmd);
12911 install_element(INTERFACE_NODE, &no_ospf_hello_interval_cmd);
12912 install_element(INTERFACE_NODE, &ospf_cost_cmd);
12913 install_element(INTERFACE_NODE, &no_ospf_cost_cmd);
12914 install_element(INTERFACE_NODE, &ospf_network_cmd);
12915 install_element(INTERFACE_NODE, &no_ospf_network_cmd);
12916 install_element(INTERFACE_NODE, &ospf_priority_cmd);
12917 install_element(INTERFACE_NODE, &no_ospf_priority_cmd);
12918 install_element(INTERFACE_NODE, &ospf_retransmit_interval_cmd);
12919 install_element(INTERFACE_NODE, &no_ospf_retransmit_interval_cmd);
12920 install_element(INTERFACE_NODE, &ospf_transmit_delay_cmd);
12921 install_element(INTERFACE_NODE, &no_ospf_transmit_delay_cmd);
12922 }
12923
12924 static void ospf_vty_zebra_init(void)
12925 {
12926 install_element(OSPF_NODE, &ospf_redistribute_source_cmd);
12927 install_element(OSPF_NODE, &no_ospf_redistribute_source_cmd);
12928 install_element(OSPF_NODE, &ospf_redistribute_instance_source_cmd);
12929 install_element(OSPF_NODE, &no_ospf_redistribute_instance_source_cmd);
12930
12931 install_element(OSPF_NODE, &ospf_distribute_list_out_cmd);
12932 install_element(OSPF_NODE, &no_ospf_distribute_list_out_cmd);
12933
12934 install_element(OSPF_NODE, &ospf_default_information_originate_cmd);
12935 install_element(OSPF_NODE, &no_ospf_default_information_originate_cmd);
12936
12937 install_element(OSPF_NODE, &ospf_default_metric_cmd);
12938 install_element(OSPF_NODE, &no_ospf_default_metric_cmd);
12939
12940 install_element(OSPF_NODE, &ospf_distance_cmd);
12941 install_element(OSPF_NODE, &no_ospf_distance_cmd);
12942 install_element(OSPF_NODE, &no_ospf_distance_ospf_cmd);
12943 install_element(OSPF_NODE, &ospf_distance_ospf_cmd);
12944
12945 /*Ospf garcefull restart helper configurations */
12946 install_element(OSPF_NODE, &ospf_gr_helper_enable_cmd);
12947 install_element(OSPF_NODE, &no_ospf_gr_helper_enable_cmd);
12948 install_element(OSPF_NODE, &ospf_gr_helper_enable_lsacheck_cmd);
12949 install_element(OSPF_NODE, &no_ospf_gr_helper_enable_lsacheck_cmd);
12950 install_element(OSPF_NODE, &ospf_gr_helper_supported_grace_time_cmd);
12951 install_element(OSPF_NODE, &no_ospf_gr_helper_supported_grace_time_cmd);
12952 install_element(OSPF_NODE, &ospf_gr_helper_planned_only_cmd);
12953 install_element(OSPF_NODE, &no_ospf_gr_helper_planned_only_cmd);
12954
12955 /* External LSA summarisation config commands.*/
12956 install_element(OSPF_NODE, &ospf_external_route_aggregation_cmd);
12957 install_element(OSPF_NODE, &no_ospf_external_route_aggregation_cmd);
12958 install_element(OSPF_NODE,
12959 &ospf_external_route_aggregation_no_adrvertise_cmd);
12960 install_element(OSPF_NODE,
12961 &no_ospf_external_route_aggregation_no_adrvertise_cmd);
12962 install_element(OSPF_NODE, &ospf_route_aggregation_timer_cmd);
12963 install_element(OSPF_NODE, &no_ospf_route_aggregation_timer_cmd);
12964 }
12965
12966 static int ospf_config_write(struct vty *vty);
12967 static struct cmd_node ospf_node = {
12968 .name = "ospf",
12969 .node = OSPF_NODE,
12970 .parent_node = CONFIG_NODE,
12971 .prompt = "%s(config-router)# ",
12972 .config_write = ospf_config_write,
12973 };
12974
12975 static void ospf_interface_clear(struct interface *ifp)
12976 {
12977 if (!if_is_operative(ifp))
12978 return;
12979
12980 if (IS_DEBUG_OSPF(ism, ISM_EVENTS))
12981 zlog_debug("ISM[%s]: clear by reset", ifp->name);
12982
12983 ospf_if_reset(ifp);
12984 }
12985
12986 DEFUN (clear_ip_ospf_interface,
12987 clear_ip_ospf_interface_cmd,
12988 "clear ip ospf [vrf NAME] interface [IFNAME]",
12989 CLEAR_STR
12990 IP_STR
12991 "OSPF information\n"
12992 VRF_CMD_HELP_STR
12993 "Interface information\n"
12994 "Interface name\n")
12995 {
12996 int idx_ifname = 0;
12997 int idx_vrf = 0;
12998 struct interface *ifp;
12999 struct listnode *node;
13000 struct ospf *ospf = NULL;
13001 char *vrf_name = NULL;
13002 vrf_id_t vrf_id = VRF_DEFAULT;
13003 struct vrf *vrf = NULL;
13004
13005 if (argv_find(argv, argc, "vrf", &idx_vrf))
13006 vrf_name = argv[idx_vrf + 1]->arg;
13007 if (vrf_name && strmatch(vrf_name, VRF_DEFAULT_NAME))
13008 vrf_name = NULL;
13009 if (vrf_name) {
13010 vrf = vrf_lookup_by_name(vrf_name);
13011 if (vrf)
13012 vrf_id = vrf->vrf_id;
13013 }
13014 if (!argv_find(argv, argc, "IFNAME", &idx_ifname)) {
13015 /* Clear all the ospfv2 interfaces. */
13016 for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
13017 if (vrf_id != ospf->vrf_id)
13018 continue;
13019 if (!vrf)
13020 vrf = vrf_lookup_by_id(ospf->vrf_id);
13021 FOR_ALL_INTERFACES (vrf, ifp)
13022 ospf_interface_clear(ifp);
13023 }
13024 } else {
13025 /* Interface name is specified. */
13026 ifp = if_lookup_by_name(argv[idx_ifname]->arg, vrf_id);
13027 if (ifp == NULL)
13028 vty_out(vty, "No such interface name\n");
13029 else
13030 ospf_interface_clear(ifp);
13031 }
13032
13033 return CMD_SUCCESS;
13034 }
13035
13036 DEFPY_HIDDEN(ospf_lsa_refresh_timer, ospf_lsa_refresh_timer_cmd,
13037 "[no$no] ospf lsa-refresh [(120-1800)]$value",
13038 NO_STR OSPF_STR
13039 "OSPF lsa refresh timer\n"
13040 "timer value in seconds\n")
13041 {
13042 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf)
13043
13044 if (no)
13045 ospf->lsa_refresh_timer = OSPF_LS_REFRESH_TIME;
13046 else
13047 ospf->lsa_refresh_timer = value;
13048
13049 return CMD_SUCCESS;
13050 }
13051
13052 DEFPY_HIDDEN(ospf_maxage_delay_timer, ospf_maxage_delay_timer_cmd,
13053 "[no$no] ospf maxage-delay [(0-60)]$value",
13054 NO_STR OSPF_STR
13055 "OSPF lsa maxage delay timer\n"
13056 "timer value in seconds\n")
13057 {
13058 VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf)
13059
13060 if (no)
13061 ospf->maxage_delay = OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT;
13062 else
13063 ospf->maxage_delay = value;
13064
13065 THREAD_OFF(ospf->t_maxage);
13066 OSPF_TIMER_ON(ospf->t_maxage, ospf_maxage_lsa_remover,
13067 ospf->maxage_delay);
13068
13069 return CMD_SUCCESS;
13070 }
13071
13072 void ospf_vty_clear_init(void)
13073 {
13074 install_element(ENABLE_NODE, &clear_ip_ospf_interface_cmd);
13075 install_element(ENABLE_NODE, &clear_ip_ospf_process_cmd);
13076 install_element(ENABLE_NODE, &clear_ip_ospf_neighbor_cmd);
13077 }
13078
13079
13080 /* Install OSPF related vty commands. */
13081 void ospf_vty_init(void)
13082 {
13083 /* Install ospf top node. */
13084 install_node(&ospf_node);
13085
13086 /* "router ospf" commands. */
13087 install_element(CONFIG_NODE, &router_ospf_cmd);
13088 install_element(CONFIG_NODE, &no_router_ospf_cmd);
13089
13090
13091 install_default(OSPF_NODE);
13092
13093 /* "ospf router-id" commands. */
13094 install_element(OSPF_NODE, &ospf_router_id_cmd);
13095 install_element(OSPF_NODE, &ospf_router_id_old_cmd);
13096 install_element(OSPF_NODE, &no_ospf_router_id_cmd);
13097
13098 /* "passive-interface" commands. */
13099 install_element(OSPF_NODE, &ospf_passive_interface_default_cmd);
13100 install_element(OSPF_NODE, &ospf_passive_interface_addr_cmd);
13101 install_element(OSPF_NODE, &no_ospf_passive_interface_default_cmd);
13102 install_element(OSPF_NODE, &no_ospf_passive_interface_addr_cmd);
13103
13104 /* "ospf abr-type" commands. */
13105 install_element(OSPF_NODE, &ospf_abr_type_cmd);
13106 install_element(OSPF_NODE, &no_ospf_abr_type_cmd);
13107
13108 /* "ospf log-adjacency-changes" commands. */
13109 install_element(OSPF_NODE, &ospf_log_adjacency_changes_cmd);
13110 install_element(OSPF_NODE, &ospf_log_adjacency_changes_detail_cmd);
13111 install_element(OSPF_NODE, &no_ospf_log_adjacency_changes_cmd);
13112 install_element(OSPF_NODE, &no_ospf_log_adjacency_changes_detail_cmd);
13113
13114 /* "ospf rfc1583-compatible" commands. */
13115 install_element(OSPF_NODE, &ospf_compatible_rfc1583_cmd);
13116 install_element(OSPF_NODE, &no_ospf_compatible_rfc1583_cmd);
13117 install_element(OSPF_NODE, &ospf_rfc1583_flag_cmd);
13118 install_element(OSPF_NODE, &no_ospf_rfc1583_flag_cmd);
13119
13120 /* "ospf send-extra-data zebra" commands. */
13121 install_element(OSPF_NODE, &ospf_send_extra_data_cmd);
13122
13123 /* "network area" commands. */
13124 install_element(OSPF_NODE, &ospf_network_area_cmd);
13125 install_element(OSPF_NODE, &no_ospf_network_area_cmd);
13126
13127 /* "area authentication" commands. */
13128 install_element(OSPF_NODE,
13129 &ospf_area_authentication_message_digest_cmd);
13130 install_element(OSPF_NODE, &ospf_area_authentication_cmd);
13131 install_element(OSPF_NODE, &no_ospf_area_authentication_cmd);
13132
13133 /* "area range" commands. */
13134 install_element(OSPF_NODE, &ospf_area_range_cmd);
13135 install_element(OSPF_NODE, &ospf_area_range_cost_cmd);
13136 install_element(OSPF_NODE, &ospf_area_range_not_advertise_cmd);
13137 install_element(OSPF_NODE, &no_ospf_area_range_cmd);
13138 install_element(OSPF_NODE, &no_ospf_area_range_substitute_cmd);
13139
13140 /* "area virtual-link" commands. */
13141 install_element(OSPF_NODE, &ospf_area_vlink_cmd);
13142 install_element(OSPF_NODE, &ospf_area_vlink_intervals_cmd);
13143 install_element(OSPF_NODE, &no_ospf_area_vlink_cmd);
13144 install_element(OSPF_NODE, &no_ospf_area_vlink_intervals_cmd);
13145
13146
13147 /* "area stub" commands. */
13148 install_element(OSPF_NODE, &ospf_area_stub_no_summary_cmd);
13149 install_element(OSPF_NODE, &ospf_area_stub_cmd);
13150 install_element(OSPF_NODE, &no_ospf_area_stub_no_summary_cmd);
13151 install_element(OSPF_NODE, &no_ospf_area_stub_cmd);
13152
13153 /* "area nssa" commands. */
13154 install_element(OSPF_NODE, &ospf_area_nssa_cmd);
13155 install_element(OSPF_NODE, &ospf_area_nssa_translate_cmd);
13156 install_element(OSPF_NODE, &ospf_area_nssa_no_summary_cmd);
13157 install_element(OSPF_NODE, &no_ospf_area_nssa_no_summary_cmd);
13158 install_element(OSPF_NODE, &ospf_area_nssa_suppress_fa_cmd);
13159 install_element(OSPF_NODE, &no_ospf_area_nssa_suppress_fa_cmd);
13160 install_element(OSPF_NODE, &no_ospf_area_nssa_cmd);
13161
13162 install_element(OSPF_NODE, &ospf_area_default_cost_cmd);
13163 install_element(OSPF_NODE, &no_ospf_area_default_cost_cmd);
13164
13165 install_element(OSPF_NODE, &ospf_area_shortcut_cmd);
13166 install_element(OSPF_NODE, &no_ospf_area_shortcut_cmd);
13167
13168 install_element(OSPF_NODE, &ospf_area_export_list_cmd);
13169 install_element(OSPF_NODE, &no_ospf_area_export_list_cmd);
13170
13171 install_element(OSPF_NODE, &ospf_area_filter_list_cmd);
13172 install_element(OSPF_NODE, &no_ospf_area_filter_list_cmd);
13173
13174 install_element(OSPF_NODE, &ospf_area_import_list_cmd);
13175 install_element(OSPF_NODE, &no_ospf_area_import_list_cmd);
13176
13177 /* SPF timer commands */
13178 install_element(OSPF_NODE, &ospf_timers_throttle_spf_cmd);
13179 install_element(OSPF_NODE, &no_ospf_timers_throttle_spf_cmd);
13180
13181 /* LSA timers commands */
13182 install_element(OSPF_NODE, &ospf_timers_min_ls_interval_cmd);
13183 install_element(OSPF_NODE, &no_ospf_timers_min_ls_interval_cmd);
13184 install_element(OSPF_NODE, &ospf_timers_lsa_min_arrival_cmd);
13185 install_element(OSPF_NODE, &no_ospf_timers_lsa_min_arrival_cmd);
13186
13187 /* refresh timer commands */
13188 install_element(OSPF_NODE, &ospf_refresh_timer_cmd);
13189 install_element(OSPF_NODE, &no_ospf_refresh_timer_val_cmd);
13190
13191 /* max-metric commands */
13192 install_element(OSPF_NODE, &ospf_max_metric_router_lsa_admin_cmd);
13193 install_element(OSPF_NODE, &no_ospf_max_metric_router_lsa_admin_cmd);
13194 install_element(OSPF_NODE, &ospf_max_metric_router_lsa_startup_cmd);
13195 install_element(OSPF_NODE, &no_ospf_max_metric_router_lsa_startup_cmd);
13196 install_element(OSPF_NODE, &ospf_max_metric_router_lsa_shutdown_cmd);
13197 install_element(OSPF_NODE, &no_ospf_max_metric_router_lsa_shutdown_cmd);
13198
13199 /* reference bandwidth commands */
13200 install_element(OSPF_NODE, &ospf_auto_cost_reference_bandwidth_cmd);
13201 install_element(OSPF_NODE, &no_ospf_auto_cost_reference_bandwidth_cmd);
13202
13203 /* "neighbor" commands. */
13204 install_element(OSPF_NODE, &ospf_neighbor_cmd);
13205 install_element(OSPF_NODE, &ospf_neighbor_poll_interval_cmd);
13206 install_element(OSPF_NODE, &no_ospf_neighbor_cmd);
13207 install_element(OSPF_NODE, &no_ospf_neighbor_poll_cmd);
13208
13209 /* write multiplier commands */
13210 install_element(OSPF_NODE, &ospf_write_multiplier_cmd);
13211 install_element(OSPF_NODE, &write_multiplier_cmd);
13212 install_element(OSPF_NODE, &no_ospf_write_multiplier_cmd);
13213 install_element(OSPF_NODE, &no_write_multiplier_cmd);
13214
13215 /* "proactive-arp" commands. */
13216 install_element(OSPF_NODE, &ospf_proactive_arp_cmd);
13217 install_element(OSPF_NODE, &no_ospf_proactive_arp_cmd);
13218
13219 /* TI-LFA commands */
13220 install_element(OSPF_NODE, &ospf_ti_lfa_cmd);
13221 install_element(OSPF_NODE, &no_ospf_ti_lfa_cmd);
13222
13223 /* Max path configurations */
13224 install_element(OSPF_NODE, &ospf_max_multipath_cmd);
13225 install_element(OSPF_NODE, &no_ospf_max_multipath_cmd);
13226
13227 vrf_cmd_init(NULL);
13228
13229 install_element(OSPF_NODE, &ospf_lsa_refresh_timer_cmd);
13230 install_element(OSPF_NODE, &ospf_maxage_delay_timer_cmd);
13231
13232 /* Init interface related vty commands. */
13233 ospf_vty_if_init();
13234
13235 /* Init zebra related vty commands. */
13236 ospf_vty_zebra_init();
13237 }
FRRouting mirror