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