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