]> git.proxmox.com Git - mirror_frr.git/blob - ospfd/ospf_vty.c
projects / mirror_frr.git / blob
? search:


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