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